[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[creduce-bugs] clang_delta crashed
Hi,
...
===< pass_clang_binsrch :: replace-function-def-with-decl >===
...
(29.1 %, 2561056 bytes)
sh: 0: getcwd() failed: No such file or directory
(29.2 %, 2559207 bytes)
...
(29.9 %, 2531005 bytes)
Segmentation fault
[clang_delta_crash_tmp_filehgeaNK.cc]
(30.0 %, 2528460 bytes)
Segmentation fault
[clang_delta_crash_tmp_file6vMNnx.cc]
(30.1 %, 2525469 bytes)
Segmentation fault
[clang_delta_crash_tmp_file23DKB5.cc]
attached.
cheers,
#define __cplusplus 201103L
#define __GNUC__ 5
#define __GNUC_MINOR__ 0
#define __GNUC_PATCHLEVEL__ 0
#define __VERSION__ "5.0.0 20141001 (experimental) [fixups revision 12b2b6a:0acec45:61bcd046b7d40b28fc3e140b32d29f170581737d]"
#define __ATOMIC_RELAXED 0
#define __ATOMIC_SEQ_CST 5
#define __ATOMIC_ACQUIRE 2
#define __ATOMIC_RELEASE 3
#define __ATOMIC_ACQ_REL 4
#define __ATOMIC_CONSUME 1
#define __FINITE_MATH_ONLY__ 0
#define _LP64 1
#define __LP64__ 1
#define __SIZEOF_INT__ 4
#define __SIZEOF_LONG__ 8
#define __SIZEOF_LONG_LONG__ 8
#define __SIZEOF_SHORT__ 2
#define __SIZEOF_FLOAT__ 4
#define __SIZEOF_DOUBLE__ 8
#define __SIZEOF_LONG_DOUBLE__ 16
#define __SIZEOF_SIZE_T__ 8
#define __CHAR_BIT__ 8
#define __BIGGEST_ALIGNMENT__ 16
#define __ORDER_LITTLE_ENDIAN__ 1234
#define __ORDER_BIG_ENDIAN__ 4321
#define __ORDER_PDP_ENDIAN__ 3412
#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
#define __FLOAT_WORD_ORDER__ __ORDER_LITTLE_ENDIAN__
#define __SIZEOF_POINTER__ 8
#define __GNUG__ 5
#define __SIZE_TYPE__ long unsigned int
#define __PTRDIFF_TYPE__ long int
#define __WCHAR_TYPE__ int
#define __WINT_TYPE__ unsigned int
#define __INTMAX_TYPE__ long int
#define __UINTMAX_TYPE__ long unsigned int
#define __CHAR16_TYPE__ short unsigned int
#define __CHAR32_TYPE__ unsigned int
#define __SIG_ATOMIC_TYPE__ int
#define __INT8_TYPE__ signed char
#define __INT16_TYPE__ short int
#define __INT32_TYPE__ int
#define __INT64_TYPE__ long int
#define __UINT8_TYPE__ unsigned char
#define __UINT16_TYPE__ short unsigned int
#define __UINT32_TYPE__ unsigned int
#define __UINT64_TYPE__ long unsigned int
#define __INT_LEAST8_TYPE__ signed char
#define __INT_LEAST16_TYPE__ short int
#define __INT_LEAST32_TYPE__ int
#define __INT_LEAST64_TYPE__ long int
#define __UINT_LEAST8_TYPE__ unsigned char
#define __UINT_LEAST16_TYPE__ short unsigned int
#define __UINT_LEAST32_TYPE__ unsigned int
#define __UINT_LEAST64_TYPE__ long unsigned int
#define __INT_FAST8_TYPE__ signed char
#define __INT_FAST16_TYPE__ long int
#define __INT_FAST32_TYPE__ long int
#define __INT_FAST64_TYPE__ long int
#define __UINT_FAST8_TYPE__ unsigned char
#define __UINT_FAST16_TYPE__ long unsigned int
#define __UINT_FAST32_TYPE__ long unsigned int
#define __UINT_FAST64_TYPE__ long unsigned int
#define __INTPTR_TYPE__ long int
#define __UINTPTR_TYPE__ long unsigned int
#define __GXX_WEAK__ 1
#define __DEPRECATED 1
#define __GXX_RTTI 1
#define __GXX_EXPERIMENTAL_CXX0X__ 1
#define __EXCEPTIONS 1
#define __GXX_ABI_VERSION 999999
#define __SCHAR_MAX__ 0x7f
#define __SHRT_MAX__ 0x7fff
#define __INT_MAX__ 0x7fffffff
#define __LONG_MAX__ 0x7fffffffffffffffL
#define __LONG_LONG_MAX__ 0x7fffffffffffffffLL
#define __WCHAR_MAX__ 0x7fffffff
#define __WCHAR_MIN__ (-__WCHAR_MAX__ - 1)
#define __WINT_MAX__ 0xffffffffU
#define __WINT_MIN__ 0U
#define __PTRDIFF_MAX__ 0x7fffffffffffffffL
#define __SIZE_MAX__ 0xffffffffffffffffUL
#define __INTMAX_MAX__ 0x7fffffffffffffffL
#define __INTMAX_C(c) c ## L
#define __UINTMAX_MAX__ 0xffffffffffffffffUL
#define __UINTMAX_C(c) c ## UL
#define __SIG_ATOMIC_MAX__ 0x7fffffff
#define __SIG_ATOMIC_MIN__ (-__SIG_ATOMIC_MAX__ - 1)
#define __INT8_MAX__ 0x7f
#define __INT16_MAX__ 0x7fff
#define __INT32_MAX__ 0x7fffffff
#define __INT64_MAX__ 0x7fffffffffffffffL
#define __UINT8_MAX__ 0xff
#define __UINT16_MAX__ 0xffff
#define __UINT32_MAX__ 0xffffffffU
#define __UINT64_MAX__ 0xffffffffffffffffUL
#define __INT_LEAST8_MAX__ 0x7f
#define __INT8_C(c) c
#define __INT_LEAST16_MAX__ 0x7fff
#define __INT16_C(c) c
#define __INT_LEAST32_MAX__ 0x7fffffff
#define __INT32_C(c) c
#define __INT_LEAST64_MAX__ 0x7fffffffffffffffL
#define __INT64_C(c) c ## L
#define __UINT_LEAST8_MAX__ 0xff
#define __UINT8_C(c) c
#define __UINT_LEAST16_MAX__ 0xffff
#define __UINT16_C(c) c
#define __UINT_LEAST32_MAX__ 0xffffffffU
#define __UINT32_C(c) c ## U
#define __UINT_LEAST64_MAX__ 0xffffffffffffffffUL
#define __UINT64_C(c) c ## UL
#define __INT_FAST8_MAX__ 0x7f
#define __INT_FAST16_MAX__ 0x7fffffffffffffffL
#define __INT_FAST32_MAX__ 0x7fffffffffffffffL
#define __INT_FAST64_MAX__ 0x7fffffffffffffffL
#define __UINT_FAST8_MAX__ 0xff
#define __UINT_FAST16_MAX__ 0xffffffffffffffffUL
#define __UINT_FAST32_MAX__ 0xffffffffffffffffUL
#define __UINT_FAST64_MAX__ 0xffffffffffffffffUL
#define __INTPTR_MAX__ 0x7fffffffffffffffL
#define __UINTPTR_MAX__ 0xffffffffffffffffUL
#define __GCC_IEC_559 2
#define __GCC_IEC_559_COMPLEX 2
#define __FLT_EVAL_METHOD__ 0
#define __DEC_EVAL_METHOD__ 2
#define __FLT_RADIX__ 2
#define __FLT_MANT_DIG__ 24
#define __FLT_DIG__ 6
#define __FLT_MIN_EXP__ (-125)
#define __FLT_MIN_10_EXP__ (-37)
#define __FLT_MAX_EXP__ 128
#define __FLT_MAX_10_EXP__ 38
#define __FLT_DECIMAL_DIG__ 9
#define __FLT_MAX__ 3.40282346638528859812e+38F
#define __FLT_MIN__ 1.17549435082228750797e-38F
#define __FLT_EPSILON__ 1.19209289550781250000e-7F
#define __FLT_DENORM_MIN__ 1.40129846432481707092e-45F
#define __FLT_HAS_DENORM__ 1
#define __FLT_HAS_INFINITY__ 1
#define __FLT_HAS_QUIET_NAN__ 1
#define __DBL_MANT_DIG__ 53
#define __DBL_DIG__ 15
#define __DBL_MIN_EXP__ (-1021)
#define __DBL_MIN_10_EXP__ (-307)
#define __DBL_MAX_EXP__ 1024
#define __DBL_MAX_10_EXP__ 308
#define __DBL_DECIMAL_DIG__ 17
#define __DBL_MAX__ double(1.79769313486231570815e+308L)
#define __DBL_MIN__ double(2.22507385850720138309e-308L)
#define __DBL_EPSILON__ double(2.22044604925031308085e-16L)
#define __DBL_DENORM_MIN__ double(4.94065645841246544177e-324L)
#define __DBL_HAS_DENORM__ 1
#define __DBL_HAS_INFINITY__ 1
#define __DBL_HAS_QUIET_NAN__ 1
#define __LDBL_MANT_DIG__ 64
#define __LDBL_DIG__ 18
#define __LDBL_MIN_EXP__ (-16381)
#define __LDBL_MIN_10_EXP__ (-4931)
#define __LDBL_MAX_EXP__ 16384
#define __LDBL_MAX_10_EXP__ 4932
#define __DECIMAL_DIG__ 21
#define __LDBL_MAX__ 1.18973149535723176502e+4932L
#define __LDBL_MIN__ 3.36210314311209350626e-4932L
#define __LDBL_EPSILON__ 1.08420217248550443401e-19L
#define __LDBL_DENORM_MIN__ 3.64519953188247460253e-4951L
#define __LDBL_HAS_DENORM__ 1
#define __LDBL_HAS_INFINITY__ 1
#define __LDBL_HAS_QUIET_NAN__ 1
#define __DEC32_MANT_DIG__ 7
#define __DEC32_MIN_EXP__ (-94)
#define __DEC32_MAX_EXP__ 97
#define __DEC32_MIN__ 1E-95DF
#define __DEC32_MAX__ 9.999999E96DF
#define __DEC32_EPSILON__ 1E-6DF
#define __DEC32_SUBNORMAL_MIN__ 0.000001E-95DF
#define __DEC64_MANT_DIG__ 16
#define __DEC64_MIN_EXP__ (-382)
#define __DEC64_MAX_EXP__ 385
#define __DEC64_MIN__ 1E-383DD
#define __DEC64_MAX__ 9.999999999999999E384DD
#define __DEC64_EPSILON__ 1E-15DD
#define __DEC64_SUBNORMAL_MIN__ 0.000000000000001E-383DD
#define __DEC128_MANT_DIG__ 34
#define __DEC128_MIN_EXP__ (-6142)
#define __DEC128_MAX_EXP__ 6145
#define __DEC128_MIN__ 1E-6143DL
#define __DEC128_MAX__ 9.999999999999999999999999999999999E6144DL
#define __DEC128_EPSILON__ 1E-33DL
#define __DEC128_SUBNORMAL_MIN__ 0.000000000000000000000000000000001E-6143DL
#define __REGISTER_PREFIX__
#define __USER_LABEL_PREFIX__
#define __GNUC_STDC_INLINE__ 1
#define __NO_INLINE__ 1
#define __STRICT_ANSI__ 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 __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_TEST_AND_SET_TRUEVAL 1
#define __GCC_ATOMIC_POINTER_LOCK_FREE 2
#define __GCC_HAVE_DWARF2_CFI_ASM 1
#define __PRAGMA_REDEFINE_EXTNAME 1
#define __SIZEOF_INT128__ 16
#define __SIZEOF_WCHAR_T__ 4
#define __SIZEOF_WINT_T__ 4
#define __SIZEOF_PTRDIFF_T__ 8
#define __amd64 1
#define __amd64__ 1
#define __x86_64 1
#define __x86_64__ 1
#define __SIZEOF_FLOAT80__ 16
#define __SIZEOF_FLOAT128__ 16
#define __ATOMIC_HLE_ACQUIRE 65536
#define __ATOMIC_HLE_RELEASE 131072
#define __k8 1
#define __k8__ 1
#define __tune_corei7_avx__ 1
#define __tune_sandybridge__ 1
#define __code_model_small__ 1
#define __MMX__ 1
#define __SSE__ 1
#define __SSE2__ 1
#define __FXSR__ 1
#define __SSE_MATH__ 1
#define __SSE2_MATH__ 1
#define __gnu_linux__ 1
#define __linux 1
#define __linux__ 1
#define __unix 1
#define __unix__ 1
#define __ELF__ 1
#define __DECIMAL_BID_FORMAT__ 1
#define _GNU_SOURCE 1
#define NDEBUG 1
#undef DEBUG
#define _STDC_PREDEF_H 1
#define BOOST_ASIO_HPP
#define BOOST_ASIO_ASYNC_RESULT_HPP
#define BOOST_ASIO_DETAIL_CONFIG_HPP
#define BOOST_CONFIG_HPP
#define BOOST_USER_CONFIG <boost/config/user.hpp>
#define BOOST_COMPILER_CONFIG "boost/config/compiler/gcc.hpp"
#define BOOST_GCC (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
#define BOOST_HAS_PRAGMA_ONCE
#define BOOST_HAS_LONG_LONG
#define BOOST_HAS_NRVO
#define BOOST_LIKELY(x) __builtin_expect(x, 1)
#define BOOST_UNLIKELY(x) __builtin_expect(x, 0)
#define BOOST_SYMBOL_EXPORT __attribute__((__visibility__("default")))
#define BOOST_SYMBOL_IMPORT
#define BOOST_SYMBOL_VISIBLE __attribute__((__visibility__("default")))
#define BOOST_HAS_INT128
#define BOOST_HAS_DECLTYPE
#define BOOST_HAS_RVALUE_REFS
#define BOOST_HAS_STATIC_ASSERT
#define BOOST_HAS_VARIADIC_TMPL
#define BOOST_COMPILER "GNU C++ version " __VERSION__
#define _GLIBCXX_CSTDDEF 1
#define _GLIBCXX_CXX_CONFIG_H 1
#define __GLIBCXX__ 20141001
#define _GLIBCXX_PURE __attribute__ ((__pure__))
#define _GLIBCXX_CONST __attribute__ ((__const__))
#define _GLIBCXX_NORETURN __attribute__ ((__noreturn__))
#define _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY 1
#define _GLIBCXX_VISIBILITY(V) __attribute__ ((__visibility__ (#V)))
#define _GLIBCXX_USE_DEPRECATED 1
#define _GLIBCXX_DEPRECATED __attribute__ ((__deprecated__))
#define _GLIBCXX_ABI_TAG_CXX11 __attribute ((__abi_tag__ ("cxx11")))
#define _GLIBCXX_CONSTEXPR constexpr
#define _GLIBCXX_USE_CONSTEXPR constexpr
#define _GLIBCXX_NOEXCEPT noexcept
#define _GLIBCXX_USE_NOEXCEPT noexcept
#define _GLIBCXX_THROW(_EXC)
#define _GLIBCXX_NOTHROW _GLIBCXX_USE_NOEXCEPT
#define _GLIBCXX_THROW_OR_ABORT(_EXC) (throw (_EXC))
#define _GLIBCXX_EXTERN_TEMPLATE 1
namespace std
{
typedef long unsigned int size_t;
typedef long int ptrdiff_t;
typedef decltype(nullptr) nullptr_t;
}
#define _GLIBCXX_INLINE_VERSION 0
#define _GLIBCXX_BEGIN_NAMESPACE_VERSION
#define _GLIBCXX_END_NAMESPACE_VERSION
#define _GLIBCXX_STD_A std
#define _GLIBCXX_STD_C std
#define _GLIBCXX_BEGIN_NAMESPACE_ALGO
#define _GLIBCXX_END_NAMESPACE_ALGO
#define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
#define _GLIBCXX_END_NAMESPACE_CONTAINER
#undef _GLIBCXX_LONG_DOUBLE_COMPAT
#define _GLIBCXX_NAMESPACE_LDBL
#define _GLIBCXX_BEGIN_NAMESPACE_LDBL
#define _GLIBCXX_END_NAMESPACE_LDBL
#define __glibcxx_assert(_Condition)
#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_OS_DEFINES 1
#define __NO_CTYPE 1
#define _FEATURES_H 1
#undef __USE_ISOC11
#undef __USE_ISOC99
#undef __USE_ISOC95
#undef __USE_ISOCXX11
#undef __USE_POSIX
#undef __USE_POSIX2
#undef __USE_POSIX199309
#undef __USE_POSIX199506
#undef __USE_XOPEN
#undef __USE_XOPEN_EXTENDED
#undef __USE_UNIX98
#undef __USE_XOPEN2K
#undef __USE_XOPEN2KXSI
#undef __USE_XOPEN2K8
#undef __USE_XOPEN2K8XSI
#undef __USE_LARGEFILE
#undef __USE_LARGEFILE64
#undef __USE_FILE_OFFSET64
#undef __USE_BSD
#undef __USE_SVID
#undef __USE_MISC
#undef __USE_ATFILE
#undef __USE_GNU
#undef __USE_REENTRANT
#undef __USE_FORTIFY_LEVEL
#undef __KERNEL_STRICT_NAMES
#define __KERNEL_STRICT_NAMES
#define __GNUC_PREREQ(maj,min) ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
#undef _ISOC95_SOURCE
#define _ISOC95_SOURCE 1
#undef _ISOC99_SOURCE
#define _ISOC99_SOURCE 1
#undef _ISOC11_SOURCE
#define _ISOC11_SOURCE 1
#undef _POSIX_SOURCE
#define _POSIX_SOURCE 1
#undef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 200809L
#undef _XOPEN_SOURCE
#define _XOPEN_SOURCE 700
#undef _XOPEN_SOURCE_EXTENDED
#define _XOPEN_SOURCE_EXTENDED 1
#undef _LARGEFILE64_SOURCE
#define _LARGEFILE64_SOURCE 1
#undef _DEFAULT_SOURCE
#define _DEFAULT_SOURCE 1
#undef _BSD_SOURCE
#define _BSD_SOURCE 1
#undef _SVID_SOURCE
#define _SVID_SOURCE 1
#undef _ATFILE_SOURCE
#define _ATFILE_SOURCE 1
#undef _DEFAULT_SOURCE
#define _DEFAULT_SOURCE 1
#undef _BSD_SOURCE
#define _BSD_SOURCE 1
#undef _SVID_SOURCE
#define _SVID_SOURCE 1
#define __USE_ISOC11 1
#define __USE_ISOC99 1
#define __USE_ISOC95 1
#define __USE_ISOCXX11 1
#undef _POSIX_SOURCE
#define _POSIX_SOURCE 1
#undef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 200809L
#define __USE_POSIX 1
#define __USE_POSIX2 1
#define __USE_POSIX199309 1
#define __USE_POSIX199506 1
#define __USE_XOPEN2K 1
#undef __USE_ISOC95
#define __USE_ISOC95 1
#undef __USE_ISOC99
#define __USE_ISOC99 1
#define __USE_XOPEN2K8 1
#undef _ATFILE_SOURCE
#define _ATFILE_SOURCE 1
#define __USE_XOPEN 1
#define __USE_XOPEN_EXTENDED 1
#define __USE_UNIX98 1
#undef _LARGEFILE_SOURCE
#define _LARGEFILE_SOURCE 1
#define __USE_XOPEN2K8 1
#define __USE_XOPEN2K8XSI 1
#define __USE_XOPEN2K 1
#define __USE_XOPEN2KXSI 1
#undef __USE_ISOC95
#define __USE_ISOC95 1
#undef __USE_ISOC99
#define __USE_ISOC99 1
#define __USE_LARGEFILE 1
#define __USE_LARGEFILE64 1
#define __USE_MISC 1
#define __USE_BSD 1
#define __USE_SVID 1
#define __USE_ATFILE 1
#define __USE_GNU 1
#define __USE_FORTIFY_LEVEL 0
#undef __GNU_LIBRARY__
#define __GNU_LIBRARY__ 6
#define __GLIBC__ 2
#define __GLIBC_MINOR__ 19
#define __GLIBC_PREREQ(maj,min) ((__GLIBC__ << 16) + __GLIBC_MINOR__ >= ((maj) << 16) + (min))
#define _SYS_CDEFS_H 1
#undef __P
#undef __PMT
#define __LEAF , __leaf__
#define __LEAF_ATTR __attribute__ ((__leaf__))
#define __THROW throw ()
#define __THROWNL throw ()
#define __NTH(fct) __LEAF_ATTR fct throw ()
#define __P(args) args
#define __PMT(args) args
#define __CONCAT(x,y) x ## y
#define __STRING(x) #x
#define __ptr_t void *
#define __long_double_t long double
#define __BEGIN_DECLS extern "C" {
#define __END_DECLS }
#define __BEGIN_NAMESPACE_STD
#define __END_NAMESPACE_STD
#define __USING_NAMESPACE_STD(name)
#define __BEGIN_NAMESPACE_C99
#define __END_NAMESPACE_C99
#define __USING_NAMESPACE_C99(name)
#define __bos(ptr) __builtin_object_size (ptr, __USE_FORTIFY_LEVEL > 1)
#define __bos0(ptr) __builtin_object_size (ptr, 0)
#define __fortify_function __extern_always_inline __attribute_artificial__
#define __warndecl(name,msg) extern void name (void) __attribute__((__warning__ (msg)))
#define __warnattr(msg) __attribute__((__warning__ (msg)))
#define __errordecl(name,msg) extern void name (void) __attribute__((__error__ (msg)))
#define __flexarr []
#define __REDIRECT(name,proto,alias) name proto __asm__ (__ASMNAME (#alias))
#define __REDIRECT_NTH(name,proto,alias) name proto __THROW __asm__ (__ASMNAME (#alias))
#define __REDIRECT_NTHNL(name,proto,alias) name proto __THROWNL __asm__ (__ASMNAME (#alias))
#define __ASMNAME(cname) __ASMNAME2 (__USER_LABEL_PREFIX__, cname)
#define __ASMNAME2(prefix,cname) __STRING (prefix) cname
#define __attribute_malloc__ __attribute__ ((__malloc__))
#define __attribute_alloc_size__(params) __attribute__ ((__alloc_size__ params))
#define __attribute_pure__ __attribute__ ((__pure__))
#define __attribute_const__ __attribute__ ((__const__))
#define __attribute_used__ __attribute__ ((__used__))
#define __attribute_noinline__ __attribute__ ((__noinline__))
#define __attribute_deprecated__ __attribute__ ((__deprecated__))
#define __attribute_format_arg__(x) __attribute__ ((__format_arg__ (x)))
#define __attribute_format_strfmon__(a,b) __attribute__ ((__format__ (__strfmon__, a, b)))
#define __nonnull(params) __attribute__ ((__nonnull__ params))
#define __attribute_warn_unused_result__ __attribute__ ((__warn_unused_result__))
#define __wur
#define __always_inline __inline __attribute__ ((__always_inline__))
#define __attribute_artificial__ __attribute__ ((__artificial__))
#define __extern_inline extern __inline __attribute__ ((__gnu_inline__))
#define __extern_always_inline extern __always_inline __attribute__ ((__gnu_inline__))
#define __va_arg_pack() __builtin_va_arg_pack ()
#define __va_arg_pack_len() __builtin_va_arg_pack_len ()
#define __restrict_arr
#define __glibc_unlikely(cond) __builtin_expect ((cond), 0)
#define __glibc_likely(cond) __builtin_expect ((cond), 1)
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
#define __LDBL_REDIR1(name,proto,alias) name proto
#define __LDBL_REDIR(name,proto) name proto
#define __LDBL_REDIR1_NTH(name,proto,alias) name proto __THROW
#define __LDBL_REDIR_NTH(name,proto) name proto __THROW
#define __LDBL_REDIR_DECL(name)
#define __REDIRECT_LDBL(name,proto,alias) __REDIRECT (name, proto, alias)
#define __REDIRECT_NTH_LDBL(name,proto,alias) __REDIRECT_NTH (name, proto, alias)
#define __stub_bdflush
#define __stub_chflags
#define __stub_fattach
#define __stub_fchflags
#define __stub_fdetach
#define __stub_getmsg
#define __stub_gtty
#define __stub_lchmod
#define __stub_putmsg
#define __stub_revoke
#define __stub_setlogin
#define __stub_sigreturn
#define __stub_sstk
#define __stub_stty
#undef _GLIBCXX_HAVE_GETS
#define _GLIBCXX_CPU_DEFINES 1
#define _GLIBCXX_PSEUDO_VISIBILITY(V)
#define _GLIBCXX_WEAK_DEFINITION
#define _GLIBCXX_FAST_MATH 0
#define __N(msgid) (msgid)
#undef min
#undef max
#define _GLIBCXX_HAVE_ACOSF 1
#define _GLIBCXX_HAVE_ACOSL 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_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_EXECINFO_H 1
#define _GLIBCXX_HAVE_EXPF 1
#define _GLIBCXX_HAVE_EXPL 1
#define _GLIBCXX_HAVE_FABSF 1
#define _GLIBCXX_HAVE_FABSL 1
#define _GLIBCXX_HAVE_FENV_H 1
#define _GLIBCXX_HAVE_FINITE 1
#define _GLIBCXX_HAVE_FINITEF 1
#define _GLIBCXX_HAVE_FINITEL 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
#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
#define _GLIBCXX_HAVE_ISINF 1
#define _GLIBCXX_HAVE_ISINFF 1
#define _GLIBCXX_HAVE_ISINFL 1
#define _GLIBCXX_HAVE_ISNAN 1
#define _GLIBCXX_HAVE_ISNANF 1
#define _GLIBCXX_HAVE_ISNANL 1
#define _GLIBCXX_HAVE_ISWBLANK 1
#define _GLIBCXX_HAVE_LC_MESSAGES 1
#define _GLIBCXX_HAVE_LDEXPF 1
#define _GLIBCXX_HAVE_LDEXPL 1
#define _GLIBCXX_HAVE_LIBINTL_H 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
#define _GLIBCXX_HAVE_MBSTATE_T 1
#define _GLIBCXX_HAVE_MEMORY_H 1
#define _GLIBCXX_HAVE_MODF 1
#define _GLIBCXX_HAVE_MODFF 1
#define _GLIBCXX_HAVE_MODFL 1
#define _GLIBCXX_HAVE_POLL 1
#define _GLIBCXX_HAVE_POWF 1
#define _GLIBCXX_HAVE_POWL 1
#define _GLIBCXX_HAVE_QUICK_EXIT 1
#define _GLIBCXX_HAVE_SETENV 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_L 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_STRXFRM_L 1
#define _GLIBCXX_HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT 1
#define _GLIBCXX_HAVE_SYS_IOCTL_H 1
#define _GLIBCXX_HAVE_SYS_IPC_H 1
#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_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_UNISTD_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
#define _GLIBCXX_HAVE___CXA_THREAD_ATEXIT_IMPL 1
#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"
#define STDC_HEADERS 1
#define _GLIBCXX_ATOMIC_BUILTINS 1
#define _GLIBCXX_FULLY_DYNAMIC_STRING 0
#define _GLIBCXX_HAS_GTHREADS 1
#define _GLIBCXX_HOSTED 1
#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
#define _GLIBCXX_USE_C99 1
#define _GLIBCXX_USE_C99_COMPLEX 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 1
#define _GLIBCXX_USE_C99_MATH_TR1 1
#define _GLIBCXX_USE_C99_STDINT_TR1 1
#define _GLIBCXX_USE_CLOCK_MONOTONIC 1
#define _GLIBCXX_USE_CLOCK_REALTIME 1
#define _GLIBCXX_USE_DECIMAL_FLOAT 1
#define _GLIBCXX_USE_FLOAT128 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
#define _GLIBCXX_USE_NLS 1
#define _GLIBCXX_USE_RANDOM_TR1 1
#define _GLIBCXX_USE_SCHED_YIELD 1
#define _GLIBCXX_USE_SC_NPROCESSORS_ONLN 1
#define _GLIBCXX_USE_TMPNAM 1
#define _GLIBCXX_USE_WCHAR_T 1
#define _GLIBCXX_VERBOSE 1
#define _GLIBCXX_X86_RDRAND 1
#define _GTHREAD_USE_MUTEX_TIMEDLOCK 1
#define _STDDEF_H
#define _STDDEF_H_
#define _ANSI_STDDEF_H
#define _PTRDIFF_T
#define _T_PTRDIFF_
#define _T_PTRDIFF
#define __PTRDIFF_T
#define _PTRDIFF_T_
#define _BSD_PTRDIFF_T_
#define ___int_ptrdiff_t_h
#define _GCC_PTRDIFF_T
#define _PTRDIFF_T_DECLARED
typedef long int ptrdiff_t;
#undef __need_ptrdiff_t
#define __size_t__
#define __SIZE_T__
#define _SIZE_T
#define _SYS_SIZE_T_H
#define _T_SIZE_
#define _T_SIZE
#define __SIZE_T
#define _SIZE_T_
#define _BSD_SIZE_T_
#define _SIZE_T_DEFINED_
#define _SIZE_T_DEFINED
#define _BSD_SIZE_T_DEFINED_
#define _SIZE_T_DECLARED
#define ___int_size_t_h
#define _GCC_SIZE_T
#define _SIZET_
#define __size_t
typedef long unsigned int size_t;
#undef __need_size_t
#define __wchar_t__
#define __WCHAR_T__
#define _WCHAR_T
#define _T_WCHAR_
#define _T_WCHAR
#define __WCHAR_T
#define _WCHAR_T_
#define _BSD_WCHAR_T_
#define _WCHAR_T_DEFINED_
#define _WCHAR_T_DEFINED
#define _WCHAR_T_H
#define ___int_wchar_t_h
#define __INT_WCHAR_T_H
#define _GCC_WCHAR_T
#define _WCHAR_T_DECLARED
#undef _BSD_WCHAR_T_
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define _GCC_MAX_ALIGN_T
typedef struct {
long long __max_align_ll __attribute__((__aligned__(__alignof__(long long))));
long double __max_align_ld __attribute__((__aligned__(__alignof__(long double))));
} max_align_t;
#define _GXX_NULLPTR_T
typedef decltype(nullptr) nullptr_t;
namespace std
{
using ::max_align_t;
}
#define BOOST_CONFIG_UTILITY
#define BOOST_TR1_NO_RECURSION
#define BOOST_CONFIG_NO_UTILITY_RECURSION
#define _GLIBCXX_UTILITY 1
#define _STL_RELOPS_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
namespace rel_ops
{
template <class _Tp>
bool
operator!=(const _Tp& __x, const _Tp& __y)
;
template <class _Tp>
bool
operator>(const _Tp& __x, const _Tp& __y)
;
template <class _Tp>
bool
operator<=(const _Tp& __x, const _Tp& __y)
;
template <class _Tp>
bool
operator>=(const _Tp& __x, const _Tp& __y)
;
}
}
#define _STL_PAIR_H 1
#define _MOVE_H 1
#define _CONCEPT_CHECK_H 1
#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)
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp>
inline _Tp*
__addressof(_Tp& __r) noexcept
{
return reinterpret_cast<_Tp*>
(&const_cast<char&>(reinterpret_cast<const volatile char&>(__r)));
}
}
#define _GLIBCXX_TYPE_TRAITS 1
namespace std
{
typedef short unsigned int uint_least16_t;
typedef unsigned int uint_least32_t;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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 ;
};
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, 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>
{ };
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<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 { };
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 { };
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_standard_layout
: public integral_constant<bool, __is_standard_layout(_Tp)>
{ };
template<typename _Tp>
struct is_pod
: public integral_constant<bool, __is_pod(_Tp)>
{ };
template<typename _Tp>
struct is_literal_type
: public integral_constant<bool, __is_literal_type(_Tp)>
{ };
template<typename _Tp>
struct is_empty
: public integral_constant<bool, __is_empty(_Tp)>
{ };
template<typename _Tp>
struct is_polymorphic
: public integral_constant<bool, __is_polymorphic(_Tp)>
{ };
template<typename _Tp>
struct is_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>>>::type
{ };
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>>>::type
{ };
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>>::type
{ };
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>>::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
{ };
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>>::type
{ };
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 _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>> 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>
>>>::type
{ };
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>>::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>>::type
{ };
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...>>::type
{ };
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>>::type
{ };
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>
struct is_trivially_destructible
: public __and_<is_destructible<_Tp>, integral_constant<bool,
__has_trivial_destructor(_Tp)>>::type
{ };
template<typename _Tp>
struct has_trivial_default_constructor
: public integral_constant<bool, __has_trivial_constructor(_Tp)>
{ };
template<typename _Tp>
struct has_trivial_copy_constructor
: public integral_constant<bool, __has_trivial_copy(_Tp)>
{ };
template<typename _Tp>
struct has_trivial_copy_assign
: public integral_constant<bool, __has_trivial_assign(_Tp)>
{ };
template<typename _Tp>
struct has_virtual_destructor
: public integral_constant<bool, __has_virtual_destructor(_Tp)>
{ };
template<typename _Tp>
struct alignment_of
: public integral_constant<std::size_t, __alignof__(_Tp)> { };
template<typename>
struct rank
: public integral_constant<std::size_t, 0> { };
template<typename _Tp, std::size_t _Size>
struct rank<_Tp[_Size]>
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
template<typename _Tp>
struct rank<_Tp[]>
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
template<typename, unsigned _Uint>
struct extent
: public integral_constant<std::size_t, 0> { };
template<typename _Tp, unsigned _Uint, std::size_t _Size>
struct extent<_Tp[_Size], _Uint>
: public integral_constant<std::size_t,
_Uint == 0 ? _Size : extent<_Tp,
_Uint - 1>::value>
{ };
template<typename _Tp, unsigned _Uint>
struct extent<_Tp[], _Uint>
: public integral_constant<std::size_t,
_Uint == 0 ? 0 : extent<_Tp,
_Uint - 1>::value>
{ };
template<typename, typename>
struct is_same
: public false_type { };
template<typename _Tp>
struct is_same<_Tp, _Tp>
: public true_type { };
template<typename _Base, typename _Derived>
struct is_base_of
: public integral_constant<bool, __is_base_of(_Base, _Derived)>
{ };
template<typename _From, typename _To,
bool = __or_<is_void<_From>, is_function<_To>,
is_array<_To>>::value>
struct __is_convertible_helper
{ typedef typename is_void<_To>::type type; };
template<typename _From, typename _To>
class __is_convertible_helper<_From, _To, false>
{
template<typename _To1>
static void __test_aux(_To1);
template<typename _From1, typename _To1,
typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
static true_type
__test(int);
template<typename, typename>
static false_type
__test(...);
public:
typedef decltype(__test<_From, _To>(0)) type;
};
template<typename _From, typename _To>
struct is_convertible
: public __is_convertible_helper<_From, _To>::type
{ };
template<typename _Tp>
struct remove_const
{ typedef _Tp type; };
template<typename _Tp>
struct remove_const<_Tp const>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_volatile
{ typedef _Tp type; };
template<typename _Tp>
struct remove_volatile<_Tp volatile>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_cv
{
typedef typename
remove_const<typename remove_volatile<_Tp>::type>::type type;
};
template<typename _Tp>
struct add_const
{ typedef _Tp const type; };
template<typename _Tp>
struct add_volatile
{ typedef _Tp volatile type; };
template<typename _Tp>
struct add_cv
{
typedef typename
add_const<typename add_volatile<_Tp>::type>::type type;
};
template<typename _Tp>
struct remove_reference
{ typedef _Tp type; };
template<typename _Tp>
struct remove_reference<_Tp&>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_reference<_Tp&&>
{ typedef _Tp type; };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __add_lvalue_reference_helper
{ typedef _Tp type; };
template<typename _Tp>
struct __add_lvalue_reference_helper<_Tp, true>
{ typedef _Tp& type; };
template<typename _Tp>
struct add_lvalue_reference
: public __add_lvalue_reference_helper<_Tp>
{ };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __add_rvalue_reference_helper
{ typedef _Tp type; };
template<typename _Tp>
struct __add_rvalue_reference_helper<_Tp, true>
{ typedef _Tp&& type; };
template<typename _Tp>
struct add_rvalue_reference
: public __add_rvalue_reference_helper<_Tp>
{ };
template<typename _Unqualified, bool _IsConst, bool _IsVol>
struct __cv_selector;
template<typename _Unqualified>
struct __cv_selector<_Unqualified, false, false>
{ typedef _Unqualified __type; };
template<typename _Unqualified>
struct __cv_selector<_Unqualified, false, true>
{ typedef volatile _Unqualified __type; };
template<typename _Unqualified>
struct __cv_selector<_Unqualified, true, false>
{ typedef const _Unqualified __type; };
template<typename _Unqualified>
struct __cv_selector<_Unqualified, true, true>
{ typedef const volatile _Unqualified __type; };
template<typename _Qualified, typename _Unqualified,
bool _IsConst = is_const<_Qualified>::value,
bool _IsVol = is_volatile<_Qualified>::value>
class __match_cv_qualifiers
{
typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
public:
typedef typename __match::__type __type;
};
template<typename _Tp>
struct __make_unsigned
{ typedef _Tp __type; };
template<>
struct __make_unsigned<char>
{ typedef unsigned char __type; };
template<>
struct __make_unsigned<signed char>
{ typedef unsigned char __type; };
template<>
struct __make_unsigned<short>
{ typedef unsigned short __type; };
template<>
struct __make_unsigned<int>
{ typedef unsigned int __type; };
template<>
struct __make_unsigned<long>
{ typedef unsigned long __type; };
template<>
struct __make_unsigned<long long>
{ typedef unsigned long long __type; };
template<>
struct __make_unsigned<wchar_t> : __make_unsigned<int>
{ };
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);
typedef conditional<__b2, unsigned int, unsigned long> __cond2;
typedef typename __cond2::type __cond2_type;
typedef conditional<__b1, unsigned short, __cond2_type> __cond1;
typedef typename __cond1::type __cond1_type;
public:
typedef typename conditional<__b0, __smallest, __cond1_type>::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<char16_t> : __make_signed<uint_least16_t>
{ };
template<>
struct __make_signed<char32_t> : __make_signed<uint_least32_t>
{ };
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 signed char __smallest;
static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
static const bool __b1 = sizeof(_Tp) <= sizeof(signed short);
static const bool __b2 = sizeof(_Tp) <= sizeof(signed int);
typedef conditional<__b2, signed int, signed long> __cond2;
typedef typename __cond2::type __cond2_type;
typedef conditional<__b1, signed short, __cond2_type> __cond1;
typedef typename __cond1::type __cond1_type;
public:
typedef typename conditional<__b0, __smallest, __cond1_type>::type __type;
};
template<typename _Tp>
struct make_signed
{ typedef typename __make_signed_selector<_Tp>::__type type; };
template<>
struct make_signed<bool>;
template<typename _Tp>
struct remove_extent
{ typedef _Tp type; };
template<typename _Tp, std::size_t _Size>
struct remove_extent<_Tp[_Size]>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_extent<_Tp[]>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_all_extents
{ typedef _Tp type; };
template<typename _Tp, std::size_t _Size>
struct remove_all_extents<_Tp[_Size]>
{ typedef typename remove_all_extents<_Tp>::type type; };
template<typename _Tp>
struct remove_all_extents<_Tp[]>
{ typedef typename remove_all_extents<_Tp>::type type; };
template<typename _Tp, typename>
struct __remove_pointer_helper
{ typedef _Tp type; };
template<typename _Tp, typename _Up>
struct __remove_pointer_helper<_Tp, _Up*>
{ typedef _Up type; };
template<typename _Tp>
struct remove_pointer
: public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type>
{ };
template<typename _Tp, bool = __or_<__is_referenceable<_Tp>,
is_void<_Tp>>::value>
struct __add_pointer_helper
{ typedef _Tp type; };
template<typename _Tp>
struct __add_pointer_helper<_Tp, true>
{ typedef typename remove_reference<_Tp>::type* type; };
template<typename _Tp>
struct add_pointer
: public __add_pointer_helper<_Tp>
{ };
template<std::size_t _Len>
struct __aligned_storage_msa
{
union __type
{
unsigned char __data[_Len];
struct __attribute__((__aligned__)) { } __align;
};
};
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;
};
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;
struct __result_of_memfun_ref_impl
{
template<typename _Fp, typename _Tp1, typename... _Args>
static __success_type<decltype(
(std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
)> _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 __success_type<decltype(
((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
)> _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 __success_type<decltype(
std::declval<_Tp1>().*std::declval<_Fp>()
)> _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 __success_type<decltype(
(*std::declval<_Tp1>()).*std::declval<_Fp>()
)> _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<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, _Arg>
{ };
template<typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
: public __result_of_memfun<typename decay<_MemPtr>::type, _Arg, _Args...>
{ };
struct __result_of_other_impl
{
template<typename _Fn, typename... _Args>
static __success_type<decltype(
std::declval<_Fn>()(std::declval<_Args>()...)
)> _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 result_of<_Functor(_ArgTypes...)>
: 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
{ };
#define _GLIBCXX_HAS_NESTED_TYPE(_NTYPE) template<typename _Tp> class __has_ ##_NTYPE ##_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::_NTYPE>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_ ##_NTYPE : public __has_ ##_NTYPE ##_helper <typename remove_cv<_Tp>::type>::type { };
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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 { };
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); }
template<typename _Tp>
inline _Tp*
addressof(_Tp& __r) noexcept
{ return std::__addressof(__r); }
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")))
{
template<typename _Tp>
inline void
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 void
swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
noexcept(noexcept(swap(*__a, *__b)))
{
for (size_t __n = 0; __n < _Nm; ++__n)
swap(__a[__n], __b[__n]);
}
}
namespace std __attribute__ ((__visibility__ ("default")))
{
struct piecewise_construct_t { };
constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
template<typename...>
class tuple;
template<std::size_t...>
struct _Index_tuple;
template<class _T1, class _T2>
struct pair
{
typedef _T1 first_type;
typedef _T2 second_type;
_T1 first;
_T2 second;
constexpr pair()
: first(), second() { }
constexpr pair(const _T1& __a, const _T2& __b)
: first(__a), second(__b) { }
template<class _U1, class _U2, class = typename
enable_if<__and_<is_convertible<const _U1&, _T1>,
is_convertible<const _U2&, _T2>>::value>::type>
constexpr pair(const pair<_U1, _U2>& __p)
: first(__p.first), second(__p.second) { }
constexpr pair(const pair&) = default;
constexpr pair(pair&&) = default;
template<class _U1, class = typename
enable_if<is_convertible<_U1, _T1>::value>::type>
constexpr pair(_U1&& __x, const _T2& __y)
: first(std::forward<_U1>(__x)), second(__y) { }
template<class _U2, class = typename
enable_if<is_convertible<_U2, _T2>::value>::type>
constexpr pair(const _T1& __x, _U2&& __y)
: first(__x), second(std::forward<_U2>(__y)) { }
template<class _U1, class _U2, class = typename
enable_if<__and_<is_convertible<_U1, _T1>,
is_convertible<_U2, _T2>>::value>::type>
constexpr pair(_U1&& __x, _U2&& __y)
: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
template<class _U1, class _U2, class = typename
enable_if<__and_<is_convertible<_U1, _T1>,
is_convertible<_U2, _T2>>::value>::type>
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=(const pair& __p)
;
pair&
operator=(pair&& __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<class _U1, class _U2>
pair&
operator=(const pair<_U1, _U2>& __p)
{
first = __p.first;
second = __p.second;
return *this;
}
template<class _U1, class _U2>
pair&
operator=(pair<_U1, _U2>&& __p)
{
first = std::forward<_U1>(__p.first);
second = std::forward<_U2>(__p.second);
return *this;
}
void
swap(pair& __p)
noexcept(noexcept(swap(first, __p.first))
&& noexcept(swap(second, __p.second)))
{
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<class _T1, class _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<class _T1, class _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<class _T1, class _T2>
inline constexpr bool
operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x == __y); }
template<class _T1, class _T2>
inline constexpr bool
operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __y < __x; }
template<class _T1, class _T2>
inline constexpr bool
operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__y < __x); }
template<class _T1, class _T2>
inline constexpr bool
operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x < __y); }
template<class _T1, class _T2>
inline void
swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
template<class _T1, class _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));
}
}
#define _INITIALIZER_LIST
#pragma GCC visibility push(default)
namespace std
{
template<class _E>
class initializer_list
{
public:
typedef _E value_type;
typedef const _E& reference;
typedef const _E& const_reference;
typedef size_t size_type;
typedef const _E* iterator;
typedef const _E* const_iterator;
private:
iterator _M_array;
size_type _M_len;
constexpr initializer_list(const_iterator __a, size_type __l)
: _M_array(__a), _M_len(__l) { }
public:
constexpr initializer_list() noexcept
: _M_array(0), _M_len(0) { }
constexpr size_type
size() const noexcept { return _M_len; }
constexpr const_iterator
begin() const noexcept { return _M_array; }
constexpr const_iterator
end() const noexcept { return begin() + size(); }
};
template<class _Tp>
constexpr const _Tp*
begin(initializer_list<_Tp> __ils) noexcept
{ return __ils.begin(); }
template<class _Tp>
constexpr const _Tp*
end(initializer_list<_Tp> __ils) noexcept
{ return __ils.end(); }
}
#pragma GCC visibility pop
namespace std __attribute__ ((__visibility__ ("default")))
{
template<class _Tp>
class tuple_size;
template<std::size_t _Int, class _Tp>
class tuple_element;
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); }
template<size_t... _Indexes>
struct _Index_tuple
{
typedef _Index_tuple<_Indexes..., sizeof...(_Indexes)> __next;
};
template<size_t _Num>
struct _Build_index_tuple
{
typedef typename _Build_index_tuple<_Num - 1>::__type::__next __type;
};
template<>
struct _Build_index_tuple<0>
{
typedef _Index_tuple<> __type;
};
}
#undef BOOST_TR1_NO_RECURSION
#undef BOOST_CONFIG_NO_UTILITY_RECURSION
#define BOOST_STDLIB_CONFIG "boost/config/stdlib/libstdcpp3.hpp"
#define BOOST_GNU_STDLIB 1
#define BOOST_STDLIB "GNU libstdc++ version " BOOST_STRINGIZE(__GLIBCXX__)
#define BOOST_HAS_THREADS
#define _UNISTD_H 1
extern "C" {
#define _POSIX_VERSION 200809L
#define __POSIX2_THIS_VERSION 200809L
#define _POSIX2_VERSION __POSIX2_THIS_VERSION
#define _POSIX2_C_BIND __POSIX2_THIS_VERSION
#define _POSIX2_C_DEV __POSIX2_THIS_VERSION
#define _POSIX2_SW_DEV __POSIX2_THIS_VERSION
#define _POSIX2_LOCALEDEF __POSIX2_THIS_VERSION
#define _XOPEN_VERSION 700
#define _XOPEN_XCU_VERSION 4
#define _XOPEN_XPG2 1
#define _XOPEN_XPG3 1
#define _XOPEN_XPG4 1
#define _XOPEN_UNIX 1
#define _XOPEN_CRYPT 1
#define _XOPEN_ENH_I18N 1
#define _XOPEN_LEGACY 1
#define _BITS_POSIX_OPT_H 1
#define _POSIX_JOB_CONTROL 1
#define _POSIX_SAVED_IDS 1
#define _POSIX_PRIORITY_SCHEDULING 200809L
#define _POSIX_SYNCHRONIZED_IO 200809L
#define _POSIX_FSYNC 200809L
#define _POSIX_MAPPED_FILES 200809L
#define _POSIX_MEMLOCK 200809L
#define _POSIX_MEMLOCK_RANGE 200809L
#define _POSIX_MEMORY_PROTECTION 200809L
#define _POSIX_CHOWN_RESTRICTED 0
#define _POSIX_VDISABLE '\0'
#define _POSIX_NO_TRUNC 1
#define _XOPEN_REALTIME 1
#define _XOPEN_REALTIME_THREADS 1
#define _XOPEN_SHM 1
#define _POSIX_THREADS 200809L
#define _POSIX_REENTRANT_FUNCTIONS 1
#define _POSIX_THREAD_SAFE_FUNCTIONS 200809L
#define _POSIX_THREAD_PRIORITY_SCHEDULING 200809L
#define _POSIX_THREAD_ATTR_STACKSIZE 200809L
#define _POSIX_THREAD_ATTR_STACKADDR 200809L
#define _POSIX_THREAD_PRIO_INHERIT 200809L
#define _POSIX_THREAD_PRIO_PROTECT 200809L
#define _POSIX_THREAD_ROBUST_PRIO_INHERIT 200809L
#define _POSIX_THREAD_ROBUST_PRIO_PROTECT -1
#define _POSIX_SEMAPHORES 200809L
#define _POSIX_REALTIME_SIGNALS 200809L
#define _POSIX_ASYNCHRONOUS_IO 200809L
#define _POSIX_ASYNC_IO 1
#define _LFS_ASYNCHRONOUS_IO 1
#define _POSIX_PRIORITIZED_IO 200809L
#define _LFS64_ASYNCHRONOUS_IO 1
#define _LFS_LARGEFILE 1
#define _LFS64_LARGEFILE 1
#define _LFS64_STDIO 1
#define _POSIX_SHARED_MEMORY_OBJECTS 200809L
#define _POSIX_CPUTIME 0
#define _POSIX_THREAD_CPUTIME 0
#define _POSIX_REGEXP 1
#define _POSIX_READER_WRITER_LOCKS 200809L
#define _POSIX_SHELL 1
#define _POSIX_TIMEOUTS 200809L
#define _POSIX_SPIN_LOCKS 200809L
#define _POSIX_SPAWN 200809L
#define _POSIX_TIMERS 200809L
#define _POSIX_BARRIERS 200809L
#define _POSIX_MESSAGE_PASSING 200809L
#define _POSIX_THREAD_PROCESS_SHARED 200809L
#define _POSIX_MONOTONIC_CLOCK 0
#define _POSIX_CLOCK_SELECTION 200809L
#define _POSIX_ADVISORY_INFO 200809L
#define _POSIX_IPV6 200809L
#define _POSIX_RAW_SOCKETS 200809L
#define _POSIX2_CHAR_TERM 200809L
#define _POSIX_SPORADIC_SERVER -1
#define _POSIX_THREAD_SPORADIC_SERVER -1
#define _POSIX_TRACE -1
#define _POSIX_TRACE_EVENT_FILTER -1
#define _POSIX_TRACE_INHERIT -1
#define _POSIX_TRACE_LOG -1
#define _POSIX_TYPED_MEMORY_OBJECTS -1
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
#define _POSIX_V7_LPBIG_OFFBIG -1
#define _POSIX_V6_LPBIG_OFFBIG -1
#define _XBS5_LPBIG_OFFBIG -1
#define _POSIX_V7_LP64_OFF64 1
#define _POSIX_V6_LP64_OFF64 1
#define _XBS5_LP64_OFF64 1
#define __ILP32_OFF32_CFLAGS "-m32"
#define __ILP32_OFF32_LDFLAGS "-m32"
#define __ILP32_OFFBIG_CFLAGS "-m32 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64"
#define __ILP32_OFFBIG_LDFLAGS "-m32"
#define __LP64_OFF64_CFLAGS "-m64"
#define __LP64_OFF64_LDFLAGS "-m64"
#define STDIN_FILENO 0
#define STDOUT_FILENO 1
#define STDERR_FILENO 2
#define _BITS_TYPES_H 1
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;
typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;
typedef signed long int __int64_t;
typedef unsigned long int __uint64_t;
typedef long int __quad_t;
typedef unsigned long int __u_quad_t;
#define __S16_TYPE short int
#define __U16_TYPE unsigned short int
#define __S32_TYPE int
#define __U32_TYPE unsigned int
#define __SLONGWORD_TYPE long int
#define __ULONGWORD_TYPE unsigned long int
#define __SQUAD_TYPE long int
#define __UQUAD_TYPE unsigned long int
#define __SWORD_TYPE long int
#define __UWORD_TYPE unsigned long int
#define __SLONG32_TYPE int
#define __ULONG32_TYPE unsigned int
#define __S64_TYPE long int
#define __U64_TYPE unsigned long int
#define __STD_TYPE typedef
#define _BITS_TYPESIZES_H 1
#define __SYSCALL_SLONG_TYPE __SLONGWORD_TYPE
#define __SYSCALL_ULONG_TYPE __ULONGWORD_TYPE
#define __DEV_T_TYPE __UQUAD_TYPE
#define __UID_T_TYPE __U32_TYPE
#define __GID_T_TYPE __U32_TYPE
#define __INO_T_TYPE __SYSCALL_ULONG_TYPE
#define __INO64_T_TYPE __UQUAD_TYPE
#define __MODE_T_TYPE __U32_TYPE
#define __NLINK_T_TYPE __SYSCALL_ULONG_TYPE
#define __FSWORD_T_TYPE __SYSCALL_SLONG_TYPE
#define __OFF_T_TYPE __SYSCALL_SLONG_TYPE
#define __OFF64_T_TYPE __SQUAD_TYPE
#define __PID_T_TYPE __S32_TYPE
#define __RLIM_T_TYPE __SYSCALL_ULONG_TYPE
#define __RLIM64_T_TYPE __UQUAD_TYPE
#define __BLKCNT_T_TYPE __SYSCALL_SLONG_TYPE
#define __BLKCNT64_T_TYPE __SQUAD_TYPE
#define __FSBLKCNT_T_TYPE __SYSCALL_ULONG_TYPE
#define __FSBLKCNT64_T_TYPE __UQUAD_TYPE
#define __FSFILCNT_T_TYPE __SYSCALL_ULONG_TYPE
#define __FSFILCNT64_T_TYPE __UQUAD_TYPE
#define __ID_T_TYPE __U32_TYPE
#define __CLOCK_T_TYPE __SYSCALL_SLONG_TYPE
#define __TIME_T_TYPE __SYSCALL_SLONG_TYPE
#define __USECONDS_T_TYPE __U32_TYPE
#define __SUSECONDS_T_TYPE __SYSCALL_SLONG_TYPE
#define __DADDR_T_TYPE __S32_TYPE
#define __KEY_T_TYPE __S32_TYPE
#define __CLOCKID_T_TYPE __S32_TYPE
#define __TIMER_T_TYPE void *
#define __BLKSIZE_T_TYPE __SYSCALL_SLONG_TYPE
#define __FSID_T_TYPE struct { int __val[2]; }
#define __SSIZE_T_TYPE __SWORD_TYPE
#define __OFF_T_MATCHES_OFF64_T 1
#define __INO_T_MATCHES_INO64_T 1
#define __FD_SETSIZE 1024
typedef unsigned long int __dev_t;
typedef unsigned int __uid_t;
typedef unsigned int __gid_t;
typedef unsigned long int __ino_t;
typedef unsigned long int __ino64_t;
typedef unsigned int __mode_t;
typedef unsigned long int __nlink_t;
typedef long int __off_t;
typedef long int __off64_t;
typedef int __pid_t;
typedef struct { int __val[2]; } __fsid_t;
typedef long int __clock_t;
typedef unsigned long int __rlim_t;
typedef unsigned long int __rlim64_t;
typedef unsigned int __id_t;
typedef long int __time_t;
typedef unsigned int __useconds_t;
typedef long int __suseconds_t;
typedef int __daddr_t;
typedef int __key_t;
typedef int __clockid_t;
typedef void * __timer_t;
typedef long int __blksize_t;
typedef long int __blkcnt_t;
typedef long int __blkcnt64_t;
typedef unsigned long int __fsblkcnt_t;
typedef unsigned long int __fsblkcnt64_t;
typedef unsigned long int __fsfilcnt_t;
typedef unsigned long int __fsfilcnt64_t;
typedef long int __fsword_t;
typedef long int __ssize_t;
typedef long int __syscall_slong_t;
typedef unsigned long int __syscall_ulong_t;
typedef __off64_t __loff_t;
typedef __quad_t *__qaddr_t;
typedef char *__caddr_t;
typedef long int __intptr_t;
typedef unsigned int __socklen_t;
#undef __STD_TYPE
typedef __ssize_t ssize_t;
#define __ssize_t_defined
#define __need_size_t
#define __need_NULL
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
typedef __gid_t gid_t;
#define __gid_t_defined
typedef __uid_t uid_t;
#define __uid_t_defined
typedef __off_t off_t;
#define __off_t_defined
typedef __off64_t off64_t;
#define __off64_t_defined
typedef __useconds_t useconds_t;
#define __useconds_t_defined
typedef __pid_t pid_t;
#define __pid_t_defined
typedef __intptr_t intptr_t;
#define __intptr_t_defined
typedef __socklen_t socklen_t;
#define __socklen_t_defined
#define R_OK 4
#define W_OK 2
#define X_OK 1
#define F_OK 0
extern int access (const char *__name, int __type) throw () __attribute__ ((__nonnull__ (1)));
extern int euidaccess (const char *__name, int __type)
throw () __attribute__ ((__nonnull__ (1)));
extern int eaccess (const char *__name, int __type)
throw () __attribute__ ((__nonnull__ (1)));
extern int faccessat (int __fd, const char *__file, int __type, int __flag)
throw () __attribute__ ((__nonnull__ (2))) ;
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2
#define SEEK_DATA 3
#define SEEK_HOLE 4
#define L_SET SEEK_SET
#define L_INCR SEEK_CUR
#define L_XTND SEEK_END
extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
throw ();
extern int close (int __fd);
extern ssize_t read (int __fd, void *__buf, size_t __nbytes) ;
extern ssize_t write (int __fd, const void *__buf, size_t __n) ;
extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
__off_t __offset) ;
extern ssize_t pwrite (int __fd, const void *__buf, size_t __n,
__off_t __offset) ;
extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
__off64_t __offset) ;
extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n,
__off64_t __offset) ;
extern int pipe (int __pipedes[2]) throw () ;
extern int pipe2 (int __pipedes[2], int __flags) throw () ;
extern unsigned int alarm (unsigned int __seconds) throw ();
extern unsigned int sleep (unsigned int __seconds);
extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
throw ();
extern int usleep (__useconds_t __useconds);
extern int pause (void);
extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int fchown (int __fd, __uid_t __owner, __gid_t __group) throw () ;
extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int fchownat (int __fd, const char *__file, __uid_t __owner,
__gid_t __group, int __flag)
throw () __attribute__ ((__nonnull__ (2))) ;
extern int chdir (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;
extern int fchdir (int __fd) throw () ;
extern char *getcwd (char *__buf, size_t __size) throw () ;
extern char *get_current_dir_name (void) throw ();
extern char *getwd (char *__buf)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) ;
extern int dup (int __fd) throw () ;
extern int dup2 (int __fd, int __fd2) throw ();
extern int dup3 (int __fd, int __fd2, int __flags) throw ();
extern char **__environ;
extern char **environ;
extern int execve (const char *__path, char *const __argv[],
char *const __envp[]) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
throw () __attribute__ ((__nonnull__ (2)));
extern int execv (const char *__path, char *const __argv[])
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execle (const char *__path, const char *__arg, ...)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execl (const char *__path, const char *__arg, ...)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execvp (const char *__file, char *const __argv[])
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execlp (const char *__file, const char *__arg, ...)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execvpe (const char *__file, char *const __argv[],
char *const __envp[])
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int nice (int __inc) throw () ;
extern void _exit (int __status) __attribute__ ((__noreturn__));
enum
{
_PC_LINK_MAX,
#define _PC_LINK_MAX _PC_LINK_MAX
_PC_MAX_CANON,
#define _PC_MAX_CANON _PC_MAX_CANON
_PC_MAX_INPUT,
#define _PC_MAX_INPUT _PC_MAX_INPUT
_PC_NAME_MAX,
#define _PC_NAME_MAX _PC_NAME_MAX
_PC_PATH_MAX,
#define _PC_PATH_MAX _PC_PATH_MAX
_PC_PIPE_BUF,
#define _PC_PIPE_BUF _PC_PIPE_BUF
_PC_CHOWN_RESTRICTED,
#define _PC_CHOWN_RESTRICTED _PC_CHOWN_RESTRICTED
_PC_NO_TRUNC,
#define _PC_NO_TRUNC _PC_NO_TRUNC
_PC_VDISABLE,
#define _PC_VDISABLE _PC_VDISABLE
_PC_SYNC_IO,
#define _PC_SYNC_IO _PC_SYNC_IO
_PC_ASYNC_IO,
#define _PC_ASYNC_IO _PC_ASYNC_IO
_PC_PRIO_IO,
#define _PC_PRIO_IO _PC_PRIO_IO
_PC_SOCK_MAXBUF,
#define _PC_SOCK_MAXBUF _PC_SOCK_MAXBUF
_PC_FILESIZEBITS,
#define _PC_FILESIZEBITS _PC_FILESIZEBITS
_PC_REC_INCR_XFER_SIZE,
#define _PC_REC_INCR_XFER_SIZE _PC_REC_INCR_XFER_SIZE
_PC_REC_MAX_XFER_SIZE,
#define _PC_REC_MAX_XFER_SIZE _PC_REC_MAX_XFER_SIZE
_PC_REC_MIN_XFER_SIZE,
#define _PC_REC_MIN_XFER_SIZE _PC_REC_MIN_XFER_SIZE
_PC_REC_XFER_ALIGN,
#define _PC_REC_XFER_ALIGN _PC_REC_XFER_ALIGN
_PC_ALLOC_SIZE_MIN,
#define _PC_ALLOC_SIZE_MIN _PC_ALLOC_SIZE_MIN
_PC_SYMLINK_MAX,
#define _PC_SYMLINK_MAX _PC_SYMLINK_MAX
_PC_2_SYMLINKS
#define _PC_2_SYMLINKS _PC_2_SYMLINKS
};
enum
{
_SC_ARG_MAX,
#define _SC_ARG_MAX _SC_ARG_MAX
_SC_CHILD_MAX,
#define _SC_CHILD_MAX _SC_CHILD_MAX
_SC_CLK_TCK,
#define _SC_CLK_TCK _SC_CLK_TCK
_SC_NGROUPS_MAX,
#define _SC_NGROUPS_MAX _SC_NGROUPS_MAX
_SC_OPEN_MAX,
#define _SC_OPEN_MAX _SC_OPEN_MAX
_SC_STREAM_MAX,
#define _SC_STREAM_MAX _SC_STREAM_MAX
_SC_TZNAME_MAX,
#define _SC_TZNAME_MAX _SC_TZNAME_MAX
_SC_JOB_CONTROL,
#define _SC_JOB_CONTROL _SC_JOB_CONTROL
_SC_SAVED_IDS,
#define _SC_SAVED_IDS _SC_SAVED_IDS
_SC_REALTIME_SIGNALS,
#define _SC_REALTIME_SIGNALS _SC_REALTIME_SIGNALS
_SC_PRIORITY_SCHEDULING,
#define _SC_PRIORITY_SCHEDULING _SC_PRIORITY_SCHEDULING
_SC_TIMERS,
#define _SC_TIMERS _SC_TIMERS
_SC_ASYNCHRONOUS_IO,
#define _SC_ASYNCHRONOUS_IO _SC_ASYNCHRONOUS_IO
_SC_PRIORITIZED_IO,
#define _SC_PRIORITIZED_IO _SC_PRIORITIZED_IO
_SC_SYNCHRONIZED_IO,
#define _SC_SYNCHRONIZED_IO _SC_SYNCHRONIZED_IO
_SC_FSYNC,
#define _SC_FSYNC _SC_FSYNC
_SC_MAPPED_FILES,
#define _SC_MAPPED_FILES _SC_MAPPED_FILES
_SC_MEMLOCK,
#define _SC_MEMLOCK _SC_MEMLOCK
_SC_MEMLOCK_RANGE,
#define _SC_MEMLOCK_RANGE _SC_MEMLOCK_RANGE
_SC_MEMORY_PROTECTION,
#define _SC_MEMORY_PROTECTION _SC_MEMORY_PROTECTION
_SC_MESSAGE_PASSING,
#define _SC_MESSAGE_PASSING _SC_MESSAGE_PASSING
_SC_SEMAPHORES,
#define _SC_SEMAPHORES _SC_SEMAPHORES
_SC_SHARED_MEMORY_OBJECTS,
#define _SC_SHARED_MEMORY_OBJECTS _SC_SHARED_MEMORY_OBJECTS
_SC_AIO_LISTIO_MAX,
#define _SC_AIO_LISTIO_MAX _SC_AIO_LISTIO_MAX
_SC_AIO_MAX,
#define _SC_AIO_MAX _SC_AIO_MAX
_SC_AIO_PRIO_DELTA_MAX,
#define _SC_AIO_PRIO_DELTA_MAX _SC_AIO_PRIO_DELTA_MAX
_SC_DELAYTIMER_MAX,
#define _SC_DELAYTIMER_MAX _SC_DELAYTIMER_MAX
_SC_MQ_OPEN_MAX,
#define _SC_MQ_OPEN_MAX _SC_MQ_OPEN_MAX
_SC_MQ_PRIO_MAX,
#define _SC_MQ_PRIO_MAX _SC_MQ_PRIO_MAX
_SC_VERSION,
#define _SC_VERSION _SC_VERSION
_SC_PAGESIZE,
#define _SC_PAGESIZE _SC_PAGESIZE
#define _SC_PAGE_SIZE _SC_PAGESIZE
_SC_RTSIG_MAX,
#define _SC_RTSIG_MAX _SC_RTSIG_MAX
_SC_SEM_NSEMS_MAX,
#define _SC_SEM_NSEMS_MAX _SC_SEM_NSEMS_MAX
_SC_SEM_VALUE_MAX,
#define _SC_SEM_VALUE_MAX _SC_SEM_VALUE_MAX
_SC_SIGQUEUE_MAX,
#define _SC_SIGQUEUE_MAX _SC_SIGQUEUE_MAX
_SC_TIMER_MAX,
#define _SC_TIMER_MAX _SC_TIMER_MAX
_SC_BC_BASE_MAX,
#define _SC_BC_BASE_MAX _SC_BC_BASE_MAX
_SC_BC_DIM_MAX,
#define _SC_BC_DIM_MAX _SC_BC_DIM_MAX
_SC_BC_SCALE_MAX,
#define _SC_BC_SCALE_MAX _SC_BC_SCALE_MAX
_SC_BC_STRING_MAX,
#define _SC_BC_STRING_MAX _SC_BC_STRING_MAX
_SC_COLL_WEIGHTS_MAX,
#define _SC_COLL_WEIGHTS_MAX _SC_COLL_WEIGHTS_MAX
_SC_EQUIV_CLASS_MAX,
#define _SC_EQUIV_CLASS_MAX _SC_EQUIV_CLASS_MAX
_SC_EXPR_NEST_MAX,
#define _SC_EXPR_NEST_MAX _SC_EXPR_NEST_MAX
_SC_LINE_MAX,
#define _SC_LINE_MAX _SC_LINE_MAX
_SC_RE_DUP_MAX,
#define _SC_RE_DUP_MAX _SC_RE_DUP_MAX
_SC_CHARCLASS_NAME_MAX,
#define _SC_CHARCLASS_NAME_MAX _SC_CHARCLASS_NAME_MAX
_SC_2_VERSION,
#define _SC_2_VERSION _SC_2_VERSION
_SC_2_C_BIND,
#define _SC_2_C_BIND _SC_2_C_BIND
_SC_2_C_DEV,
#define _SC_2_C_DEV _SC_2_C_DEV
_SC_2_FORT_DEV,
#define _SC_2_FORT_DEV _SC_2_FORT_DEV
_SC_2_FORT_RUN,
#define _SC_2_FORT_RUN _SC_2_FORT_RUN
_SC_2_SW_DEV,
#define _SC_2_SW_DEV _SC_2_SW_DEV
_SC_2_LOCALEDEF,
#define _SC_2_LOCALEDEF _SC_2_LOCALEDEF
_SC_PII,
#define _SC_PII _SC_PII
_SC_PII_XTI,
#define _SC_PII_XTI _SC_PII_XTI
_SC_PII_SOCKET,
#define _SC_PII_SOCKET _SC_PII_SOCKET
_SC_PII_INTERNET,
#define _SC_PII_INTERNET _SC_PII_INTERNET
_SC_PII_OSI,
#define _SC_PII_OSI _SC_PII_OSI
_SC_POLL,
#define _SC_POLL _SC_POLL
_SC_SELECT,
#define _SC_SELECT _SC_SELECT
_SC_UIO_MAXIOV,
#define _SC_UIO_MAXIOV _SC_UIO_MAXIOV
_SC_IOV_MAX = _SC_UIO_MAXIOV,
#define _SC_IOV_MAX _SC_IOV_MAX
_SC_PII_INTERNET_STREAM,
#define _SC_PII_INTERNET_STREAM _SC_PII_INTERNET_STREAM
_SC_PII_INTERNET_DGRAM,
#define _SC_PII_INTERNET_DGRAM _SC_PII_INTERNET_DGRAM
_SC_PII_OSI_COTS,
#define _SC_PII_OSI_COTS _SC_PII_OSI_COTS
_SC_PII_OSI_CLTS,
#define _SC_PII_OSI_CLTS _SC_PII_OSI_CLTS
_SC_PII_OSI_M,
#define _SC_PII_OSI_M _SC_PII_OSI_M
_SC_T_IOV_MAX,
#define _SC_T_IOV_MAX _SC_T_IOV_MAX
_SC_THREADS,
#define _SC_THREADS _SC_THREADS
_SC_THREAD_SAFE_FUNCTIONS,
#define _SC_THREAD_SAFE_FUNCTIONS _SC_THREAD_SAFE_FUNCTIONS
_SC_GETGR_R_SIZE_MAX,
#define _SC_GETGR_R_SIZE_MAX _SC_GETGR_R_SIZE_MAX
_SC_GETPW_R_SIZE_MAX,
#define _SC_GETPW_R_SIZE_MAX _SC_GETPW_R_SIZE_MAX
_SC_LOGIN_NAME_MAX,
#define _SC_LOGIN_NAME_MAX _SC_LOGIN_NAME_MAX
_SC_TTY_NAME_MAX,
#define _SC_TTY_NAME_MAX _SC_TTY_NAME_MAX
_SC_THREAD_DESTRUCTOR_ITERATIONS,
#define _SC_THREAD_DESTRUCTOR_ITERATIONS _SC_THREAD_DESTRUCTOR_ITERATIONS
_SC_THREAD_KEYS_MAX,
#define _SC_THREAD_KEYS_MAX _SC_THREAD_KEYS_MAX
_SC_THREAD_STACK_MIN,
#define _SC_THREAD_STACK_MIN _SC_THREAD_STACK_MIN
_SC_THREAD_THREADS_MAX,
#define _SC_THREAD_THREADS_MAX _SC_THREAD_THREADS_MAX
_SC_THREAD_ATTR_STACKADDR,
#define _SC_THREAD_ATTR_STACKADDR _SC_THREAD_ATTR_STACKADDR
_SC_THREAD_ATTR_STACKSIZE,
#define _SC_THREAD_ATTR_STACKSIZE _SC_THREAD_ATTR_STACKSIZE
_SC_THREAD_PRIORITY_SCHEDULING,
#define _SC_THREAD_PRIORITY_SCHEDULING _SC_THREAD_PRIORITY_SCHEDULING
_SC_THREAD_PRIO_INHERIT,
#define _SC_THREAD_PRIO_INHERIT _SC_THREAD_PRIO_INHERIT
_SC_THREAD_PRIO_PROTECT,
#define _SC_THREAD_PRIO_PROTECT _SC_THREAD_PRIO_PROTECT
_SC_THREAD_PROCESS_SHARED,
#define _SC_THREAD_PROCESS_SHARED _SC_THREAD_PROCESS_SHARED
_SC_NPROCESSORS_CONF,
#define _SC_NPROCESSORS_CONF _SC_NPROCESSORS_CONF
_SC_NPROCESSORS_ONLN,
#define _SC_NPROCESSORS_ONLN _SC_NPROCESSORS_ONLN
_SC_PHYS_PAGES,
#define _SC_PHYS_PAGES _SC_PHYS_PAGES
_SC_AVPHYS_PAGES,
#define _SC_AVPHYS_PAGES _SC_AVPHYS_PAGES
_SC_ATEXIT_MAX,
#define _SC_ATEXIT_MAX _SC_ATEXIT_MAX
_SC_PASS_MAX,
#define _SC_PASS_MAX _SC_PASS_MAX
_SC_XOPEN_VERSION,
#define _SC_XOPEN_VERSION _SC_XOPEN_VERSION
_SC_XOPEN_XCU_VERSION,
#define _SC_XOPEN_XCU_VERSION _SC_XOPEN_XCU_VERSION
_SC_XOPEN_UNIX,
#define _SC_XOPEN_UNIX _SC_XOPEN_UNIX
_SC_XOPEN_CRYPT,
#define _SC_XOPEN_CRYPT _SC_XOPEN_CRYPT
_SC_XOPEN_ENH_I18N,
#define _SC_XOPEN_ENH_I18N _SC_XOPEN_ENH_I18N
_SC_XOPEN_SHM,
#define _SC_XOPEN_SHM _SC_XOPEN_SHM
_SC_2_CHAR_TERM,
#define _SC_2_CHAR_TERM _SC_2_CHAR_TERM
_SC_2_C_VERSION,
#define _SC_2_C_VERSION _SC_2_C_VERSION
_SC_2_UPE,
#define _SC_2_UPE _SC_2_UPE
_SC_XOPEN_XPG2,
#define _SC_XOPEN_XPG2 _SC_XOPEN_XPG2
_SC_XOPEN_XPG3,
#define _SC_XOPEN_XPG3 _SC_XOPEN_XPG3
_SC_XOPEN_XPG4,
#define _SC_XOPEN_XPG4 _SC_XOPEN_XPG4
_SC_CHAR_BIT,
#define _SC_CHAR_BIT _SC_CHAR_BIT
_SC_CHAR_MAX,
#define _SC_CHAR_MAX _SC_CHAR_MAX
_SC_CHAR_MIN,
#define _SC_CHAR_MIN _SC_CHAR_MIN
_SC_INT_MAX,
#define _SC_INT_MAX _SC_INT_MAX
_SC_INT_MIN,
#define _SC_INT_MIN _SC_INT_MIN
_SC_LONG_BIT,
#define _SC_LONG_BIT _SC_LONG_BIT
_SC_WORD_BIT,
#define _SC_WORD_BIT _SC_WORD_BIT
_SC_MB_LEN_MAX,
#define _SC_MB_LEN_MAX _SC_MB_LEN_MAX
_SC_NZERO,
#define _SC_NZERO _SC_NZERO
_SC_SSIZE_MAX,
#define _SC_SSIZE_MAX _SC_SSIZE_MAX
_SC_SCHAR_MAX,
#define _SC_SCHAR_MAX _SC_SCHAR_MAX
_SC_SCHAR_MIN,
#define _SC_SCHAR_MIN _SC_SCHAR_MIN
_SC_SHRT_MAX,
#define _SC_SHRT_MAX _SC_SHRT_MAX
_SC_SHRT_MIN,
#define _SC_SHRT_MIN _SC_SHRT_MIN
_SC_UCHAR_MAX,
#define _SC_UCHAR_MAX _SC_UCHAR_MAX
_SC_UINT_MAX,
#define _SC_UINT_MAX _SC_UINT_MAX
_SC_ULONG_MAX,
#define _SC_ULONG_MAX _SC_ULONG_MAX
_SC_USHRT_MAX,
#define _SC_USHRT_MAX _SC_USHRT_MAX
_SC_NL_ARGMAX,
#define _SC_NL_ARGMAX _SC_NL_ARGMAX
_SC_NL_LANGMAX,
#define _SC_NL_LANGMAX _SC_NL_LANGMAX
_SC_NL_MSGMAX,
#define _SC_NL_MSGMAX _SC_NL_MSGMAX
_SC_NL_NMAX,
#define _SC_NL_NMAX _SC_NL_NMAX
_SC_NL_SETMAX,
#define _SC_NL_SETMAX _SC_NL_SETMAX
_SC_NL_TEXTMAX,
#define _SC_NL_TEXTMAX _SC_NL_TEXTMAX
_SC_XBS5_ILP32_OFF32,
#define _SC_XBS5_ILP32_OFF32 _SC_XBS5_ILP32_OFF32
_SC_XBS5_ILP32_OFFBIG,
#define _SC_XBS5_ILP32_OFFBIG _SC_XBS5_ILP32_OFFBIG
_SC_XBS5_LP64_OFF64,
#define _SC_XBS5_LP64_OFF64 _SC_XBS5_LP64_OFF64
_SC_XBS5_LPBIG_OFFBIG,
#define _SC_XBS5_LPBIG_OFFBIG _SC_XBS5_LPBIG_OFFBIG
_SC_XOPEN_LEGACY,
#define _SC_XOPEN_LEGACY _SC_XOPEN_LEGACY
_SC_XOPEN_REALTIME,
#define _SC_XOPEN_REALTIME _SC_XOPEN_REALTIME
_SC_XOPEN_REALTIME_THREADS,
#define _SC_XOPEN_REALTIME_THREADS _SC_XOPEN_REALTIME_THREADS
_SC_ADVISORY_INFO,
#define _SC_ADVISORY_INFO _SC_ADVISORY_INFO
_SC_BARRIERS,
#define _SC_BARRIERS _SC_BARRIERS
_SC_BASE,
#define _SC_BASE _SC_BASE
_SC_C_LANG_SUPPORT,
#define _SC_C_LANG_SUPPORT _SC_C_LANG_SUPPORT
_SC_C_LANG_SUPPORT_R,
#define _SC_C_LANG_SUPPORT_R _SC_C_LANG_SUPPORT_R
_SC_CLOCK_SELECTION,
#define _SC_CLOCK_SELECTION _SC_CLOCK_SELECTION
_SC_CPUTIME,
#define _SC_CPUTIME _SC_CPUTIME
_SC_THREAD_CPUTIME,
#define _SC_THREAD_CPUTIME _SC_THREAD_CPUTIME
_SC_DEVICE_IO,
#define _SC_DEVICE_IO _SC_DEVICE_IO
_SC_DEVICE_SPECIFIC,
#define _SC_DEVICE_SPECIFIC _SC_DEVICE_SPECIFIC
_SC_DEVICE_SPECIFIC_R,
#define _SC_DEVICE_SPECIFIC_R _SC_DEVICE_SPECIFIC_R
_SC_FD_MGMT,
#define _SC_FD_MGMT _SC_FD_MGMT
_SC_FIFO,
#define _SC_FIFO _SC_FIFO
_SC_PIPE,
#define _SC_PIPE _SC_PIPE
_SC_FILE_ATTRIBUTES,
#define _SC_FILE_ATTRIBUTES _SC_FILE_ATTRIBUTES
_SC_FILE_LOCKING,
#define _SC_FILE_LOCKING _SC_FILE_LOCKING
_SC_FILE_SYSTEM,
#define _SC_FILE_SYSTEM _SC_FILE_SYSTEM
_SC_MONOTONIC_CLOCK,
#define _SC_MONOTONIC_CLOCK _SC_MONOTONIC_CLOCK
_SC_MULTI_PROCESS,
#define _SC_MULTI_PROCESS _SC_MULTI_PROCESS
_SC_SINGLE_PROCESS,
#define _SC_SINGLE_PROCESS _SC_SINGLE_PROCESS
_SC_NETWORKING,
#define _SC_NETWORKING _SC_NETWORKING
_SC_READER_WRITER_LOCKS,
#define _SC_READER_WRITER_LOCKS _SC_READER_WRITER_LOCKS
_SC_SPIN_LOCKS,
#define _SC_SPIN_LOCKS _SC_SPIN_LOCKS
_SC_REGEXP,
#define _SC_REGEXP _SC_REGEXP
_SC_REGEX_VERSION,
#define _SC_REGEX_VERSION _SC_REGEX_VERSION
_SC_SHELL,
#define _SC_SHELL _SC_SHELL
_SC_SIGNALS,
#define _SC_SIGNALS _SC_SIGNALS
_SC_SPAWN,
#define _SC_SPAWN _SC_SPAWN
_SC_SPORADIC_SERVER,
#define _SC_SPORADIC_SERVER _SC_SPORADIC_SERVER
_SC_THREAD_SPORADIC_SERVER,
#define _SC_THREAD_SPORADIC_SERVER _SC_THREAD_SPORADIC_SERVER
_SC_SYSTEM_DATABASE,
#define _SC_SYSTEM_DATABASE _SC_SYSTEM_DATABASE
_SC_SYSTEM_DATABASE_R,
#define _SC_SYSTEM_DATABASE_R _SC_SYSTEM_DATABASE_R
_SC_TIMEOUTS,
#define _SC_TIMEOUTS _SC_TIMEOUTS
_SC_TYPED_MEMORY_OBJECTS,
#define _SC_TYPED_MEMORY_OBJECTS _SC_TYPED_MEMORY_OBJECTS
_SC_USER_GROUPS,
#define _SC_USER_GROUPS _SC_USER_GROUPS
_SC_USER_GROUPS_R,
#define _SC_USER_GROUPS_R _SC_USER_GROUPS_R
_SC_2_PBS,
#define _SC_2_PBS _SC_2_PBS
_SC_2_PBS_ACCOUNTING,
#define _SC_2_PBS_ACCOUNTING _SC_2_PBS_ACCOUNTING
_SC_2_PBS_LOCATE,
#define _SC_2_PBS_LOCATE _SC_2_PBS_LOCATE
_SC_2_PBS_MESSAGE,
#define _SC_2_PBS_MESSAGE _SC_2_PBS_MESSAGE
_SC_2_PBS_TRACK,
#define _SC_2_PBS_TRACK _SC_2_PBS_TRACK
_SC_SYMLOOP_MAX,
#define _SC_SYMLOOP_MAX _SC_SYMLOOP_MAX
_SC_STREAMS,
#define _SC_STREAMS _SC_STREAMS
_SC_2_PBS_CHECKPOINT,
#define _SC_2_PBS_CHECKPOINT _SC_2_PBS_CHECKPOINT
_SC_V6_ILP32_OFF32,
#define _SC_V6_ILP32_OFF32 _SC_V6_ILP32_OFF32
_SC_V6_ILP32_OFFBIG,
#define _SC_V6_ILP32_OFFBIG _SC_V6_ILP32_OFFBIG
_SC_V6_LP64_OFF64,
#define _SC_V6_LP64_OFF64 _SC_V6_LP64_OFF64
_SC_V6_LPBIG_OFFBIG,
#define _SC_V6_LPBIG_OFFBIG _SC_V6_LPBIG_OFFBIG
_SC_HOST_NAME_MAX,
#define _SC_HOST_NAME_MAX _SC_HOST_NAME_MAX
_SC_TRACE,
#define _SC_TRACE _SC_TRACE
_SC_TRACE_EVENT_FILTER,
#define _SC_TRACE_EVENT_FILTER _SC_TRACE_EVENT_FILTER
_SC_TRACE_INHERIT,
#define _SC_TRACE_INHERIT _SC_TRACE_INHERIT
_SC_TRACE_LOG,
#define _SC_TRACE_LOG _SC_TRACE_LOG
_SC_LEVEL1_ICACHE_SIZE,
#define _SC_LEVEL1_ICACHE_SIZE _SC_LEVEL1_ICACHE_SIZE
_SC_LEVEL1_ICACHE_ASSOC,
#define _SC_LEVEL1_ICACHE_ASSOC _SC_LEVEL1_ICACHE_ASSOC
_SC_LEVEL1_ICACHE_LINESIZE,
#define _SC_LEVEL1_ICACHE_LINESIZE _SC_LEVEL1_ICACHE_LINESIZE
_SC_LEVEL1_DCACHE_SIZE,
#define _SC_LEVEL1_DCACHE_SIZE _SC_LEVEL1_DCACHE_SIZE
_SC_LEVEL1_DCACHE_ASSOC,
#define _SC_LEVEL1_DCACHE_ASSOC _SC_LEVEL1_DCACHE_ASSOC
_SC_LEVEL1_DCACHE_LINESIZE,
#define _SC_LEVEL1_DCACHE_LINESIZE _SC_LEVEL1_DCACHE_LINESIZE
_SC_LEVEL2_CACHE_SIZE,
#define _SC_LEVEL2_CACHE_SIZE _SC_LEVEL2_CACHE_SIZE
_SC_LEVEL2_CACHE_ASSOC,
#define _SC_LEVEL2_CACHE_ASSOC _SC_LEVEL2_CACHE_ASSOC
_SC_LEVEL2_CACHE_LINESIZE,
#define _SC_LEVEL2_CACHE_LINESIZE _SC_LEVEL2_CACHE_LINESIZE
_SC_LEVEL3_CACHE_SIZE,
#define _SC_LEVEL3_CACHE_SIZE _SC_LEVEL3_CACHE_SIZE
_SC_LEVEL3_CACHE_ASSOC,
#define _SC_LEVEL3_CACHE_ASSOC _SC_LEVEL3_CACHE_ASSOC
_SC_LEVEL3_CACHE_LINESIZE,
#define _SC_LEVEL3_CACHE_LINESIZE _SC_LEVEL3_CACHE_LINESIZE
_SC_LEVEL4_CACHE_SIZE,
#define _SC_LEVEL4_CACHE_SIZE _SC_LEVEL4_CACHE_SIZE
_SC_LEVEL4_CACHE_ASSOC,
#define _SC_LEVEL4_CACHE_ASSOC _SC_LEVEL4_CACHE_ASSOC
_SC_LEVEL4_CACHE_LINESIZE,
#define _SC_LEVEL4_CACHE_LINESIZE _SC_LEVEL4_CACHE_LINESIZE
_SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
#define _SC_IPV6 _SC_IPV6
_SC_RAW_SOCKETS,
#define _SC_RAW_SOCKETS _SC_RAW_SOCKETS
_SC_V7_ILP32_OFF32,
#define _SC_V7_ILP32_OFF32 _SC_V7_ILP32_OFF32
_SC_V7_ILP32_OFFBIG,
#define _SC_V7_ILP32_OFFBIG _SC_V7_ILP32_OFFBIG
_SC_V7_LP64_OFF64,
#define _SC_V7_LP64_OFF64 _SC_V7_LP64_OFF64
_SC_V7_LPBIG_OFFBIG,
#define _SC_V7_LPBIG_OFFBIG _SC_V7_LPBIG_OFFBIG
_SC_SS_REPL_MAX,
#define _SC_SS_REPL_MAX _SC_SS_REPL_MAX
_SC_TRACE_EVENT_NAME_MAX,
#define _SC_TRACE_EVENT_NAME_MAX _SC_TRACE_EVENT_NAME_MAX
_SC_TRACE_NAME_MAX,
#define _SC_TRACE_NAME_MAX _SC_TRACE_NAME_MAX
_SC_TRACE_SYS_MAX,
#define _SC_TRACE_SYS_MAX _SC_TRACE_SYS_MAX
_SC_TRACE_USER_EVENT_MAX,
#define _SC_TRACE_USER_EVENT_MAX _SC_TRACE_USER_EVENT_MAX
_SC_XOPEN_STREAMS,
#define _SC_XOPEN_STREAMS _SC_XOPEN_STREAMS
_SC_THREAD_ROBUST_PRIO_INHERIT,
#define _SC_THREAD_ROBUST_PRIO_INHERIT _SC_THREAD_ROBUST_PRIO_INHERIT
_SC_THREAD_ROBUST_PRIO_PROTECT
#define _SC_THREAD_ROBUST_PRIO_PROTECT _SC_THREAD_ROBUST_PRIO_PROTECT
};
enum
{
_CS_PATH,
#define _CS_PATH _CS_PATH
_CS_V6_WIDTH_RESTRICTED_ENVS,
#define _CS_V6_WIDTH_RESTRICTED_ENVS _CS_V6_WIDTH_RESTRICTED_ENVS
#define _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS _CS_V6_WIDTH_RESTRICTED_ENVS
_CS_GNU_LIBC_VERSION,
#define _CS_GNU_LIBC_VERSION _CS_GNU_LIBC_VERSION
_CS_GNU_LIBPTHREAD_VERSION,
#define _CS_GNU_LIBPTHREAD_VERSION _CS_GNU_LIBPTHREAD_VERSION
_CS_V5_WIDTH_RESTRICTED_ENVS,
#define _CS_V5_WIDTH_RESTRICTED_ENVS _CS_V5_WIDTH_RESTRICTED_ENVS
#define _CS_POSIX_V5_WIDTH_RESTRICTED_ENVS _CS_V5_WIDTH_RESTRICTED_ENVS
_CS_V7_WIDTH_RESTRICTED_ENVS,
#define _CS_V7_WIDTH_RESTRICTED_ENVS _CS_V7_WIDTH_RESTRICTED_ENVS
#define _CS_POSIX_V7_WIDTH_RESTRICTED_ENVS _CS_V7_WIDTH_RESTRICTED_ENVS
_CS_LFS_CFLAGS = 1000,
#define _CS_LFS_CFLAGS _CS_LFS_CFLAGS
_CS_LFS_LDFLAGS,
#define _CS_LFS_LDFLAGS _CS_LFS_LDFLAGS
_CS_LFS_LIBS,
#define _CS_LFS_LIBS _CS_LFS_LIBS
_CS_LFS_LINTFLAGS,
#define _CS_LFS_LINTFLAGS _CS_LFS_LINTFLAGS
_CS_LFS64_CFLAGS,
#define _CS_LFS64_CFLAGS _CS_LFS64_CFLAGS
_CS_LFS64_LDFLAGS,
#define _CS_LFS64_LDFLAGS _CS_LFS64_LDFLAGS
_CS_LFS64_LIBS,
#define _CS_LFS64_LIBS _CS_LFS64_LIBS
_CS_LFS64_LINTFLAGS,
#define _CS_LFS64_LINTFLAGS _CS_LFS64_LINTFLAGS
_CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
#define _CS_XBS5_ILP32_OFF32_CFLAGS _CS_XBS5_ILP32_OFF32_CFLAGS
_CS_XBS5_ILP32_OFF32_LDFLAGS,
#define _CS_XBS5_ILP32_OFF32_LDFLAGS _CS_XBS5_ILP32_OFF32_LDFLAGS
_CS_XBS5_ILP32_OFF32_LIBS,
#define _CS_XBS5_ILP32_OFF32_LIBS _CS_XBS5_ILP32_OFF32_LIBS
_CS_XBS5_ILP32_OFF32_LINTFLAGS,
#define _CS_XBS5_ILP32_OFF32_LINTFLAGS _CS_XBS5_ILP32_OFF32_LINTFLAGS
_CS_XBS5_ILP32_OFFBIG_CFLAGS,
#define _CS_XBS5_ILP32_OFFBIG_CFLAGS _CS_XBS5_ILP32_OFFBIG_CFLAGS
_CS_XBS5_ILP32_OFFBIG_LDFLAGS,
#define _CS_XBS5_ILP32_OFFBIG_LDFLAGS _CS_XBS5_ILP32_OFFBIG_LDFLAGS
_CS_XBS5_ILP32_OFFBIG_LIBS,
#define _CS_XBS5_ILP32_OFFBIG_LIBS _CS_XBS5_ILP32_OFFBIG_LIBS
_CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
#define _CS_XBS5_ILP32_OFFBIG_LINTFLAGS _CS_XBS5_ILP32_OFFBIG_LINTFLAGS
_CS_XBS5_LP64_OFF64_CFLAGS,
#define _CS_XBS5_LP64_OFF64_CFLAGS _CS_XBS5_LP64_OFF64_CFLAGS
_CS_XBS5_LP64_OFF64_LDFLAGS,
#define _CS_XBS5_LP64_OFF64_LDFLAGS _CS_XBS5_LP64_OFF64_LDFLAGS
_CS_XBS5_LP64_OFF64_LIBS,
#define _CS_XBS5_LP64_OFF64_LIBS _CS_XBS5_LP64_OFF64_LIBS
_CS_XBS5_LP64_OFF64_LINTFLAGS,
#define _CS_XBS5_LP64_OFF64_LINTFLAGS _CS_XBS5_LP64_OFF64_LINTFLAGS
_CS_XBS5_LPBIG_OFFBIG_CFLAGS,
#define _CS_XBS5_LPBIG_OFFBIG_CFLAGS _CS_XBS5_LPBIG_OFFBIG_CFLAGS
_CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
#define _CS_XBS5_LPBIG_OFFBIG_LDFLAGS _CS_XBS5_LPBIG_OFFBIG_LDFLAGS
_CS_XBS5_LPBIG_OFFBIG_LIBS,
#define _CS_XBS5_LPBIG_OFFBIG_LIBS _CS_XBS5_LPBIG_OFFBIG_LIBS
_CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
#define _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
_CS_POSIX_V6_ILP32_OFF32_CFLAGS,
#define _CS_POSIX_V6_ILP32_OFF32_CFLAGS _CS_POSIX_V6_ILP32_OFF32_CFLAGS
_CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
#define _CS_POSIX_V6_ILP32_OFF32_LDFLAGS _CS_POSIX_V6_ILP32_OFF32_LDFLAGS
_CS_POSIX_V6_ILP32_OFF32_LIBS,
#define _CS_POSIX_V6_ILP32_OFF32_LIBS _CS_POSIX_V6_ILP32_OFF32_LIBS
_CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
#define _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS
_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
#define _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS
_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
#define _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS
_CS_POSIX_V6_ILP32_OFFBIG_LIBS,
#define _CS_POSIX_V6_ILP32_OFFBIG_LIBS _CS_POSIX_V6_ILP32_OFFBIG_LIBS
_CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
#define _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS
_CS_POSIX_V6_LP64_OFF64_CFLAGS,
#define _CS_POSIX_V6_LP64_OFF64_CFLAGS _CS_POSIX_V6_LP64_OFF64_CFLAGS
_CS_POSIX_V6_LP64_OFF64_LDFLAGS,
#define _CS_POSIX_V6_LP64_OFF64_LDFLAGS _CS_POSIX_V6_LP64_OFF64_LDFLAGS
_CS_POSIX_V6_LP64_OFF64_LIBS,
#define _CS_POSIX_V6_LP64_OFF64_LIBS _CS_POSIX_V6_LP64_OFF64_LIBS
_CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
#define _CS_POSIX_V6_LP64_OFF64_LINTFLAGS _CS_POSIX_V6_LP64_OFF64_LINTFLAGS
_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
#define _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS
_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
#define _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS
_CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
#define _CS_POSIX_V6_LPBIG_OFFBIG_LIBS _CS_POSIX_V6_LPBIG_OFFBIG_LIBS
_CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,
#define _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS
_CS_POSIX_V7_ILP32_OFF32_CFLAGS,
#define _CS_POSIX_V7_ILP32_OFF32_CFLAGS _CS_POSIX_V7_ILP32_OFF32_CFLAGS
_CS_POSIX_V7_ILP32_OFF32_LDFLAGS,
#define _CS_POSIX_V7_ILP32_OFF32_LDFLAGS _CS_POSIX_V7_ILP32_OFF32_LDFLAGS
_CS_POSIX_V7_ILP32_OFF32_LIBS,
#define _CS_POSIX_V7_ILP32_OFF32_LIBS _CS_POSIX_V7_ILP32_OFF32_LIBS
_CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,
#define _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS
_CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,
#define _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS
_CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,
#define _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS
_CS_POSIX_V7_ILP32_OFFBIG_LIBS,
#define _CS_POSIX_V7_ILP32_OFFBIG_LIBS _CS_POSIX_V7_ILP32_OFFBIG_LIBS
_CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,
#define _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS
_CS_POSIX_V7_LP64_OFF64_CFLAGS,
#define _CS_POSIX_V7_LP64_OFF64_CFLAGS _CS_POSIX_V7_LP64_OFF64_CFLAGS
_CS_POSIX_V7_LP64_OFF64_LDFLAGS,
#define _CS_POSIX_V7_LP64_OFF64_LDFLAGS _CS_POSIX_V7_LP64_OFF64_LDFLAGS
_CS_POSIX_V7_LP64_OFF64_LIBS,
#define _CS_POSIX_V7_LP64_OFF64_LIBS _CS_POSIX_V7_LP64_OFF64_LIBS
_CS_POSIX_V7_LP64_OFF64_LINTFLAGS,
#define _CS_POSIX_V7_LP64_OFF64_LINTFLAGS _CS_POSIX_V7_LP64_OFF64_LINTFLAGS
_CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,
#define _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS
_CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,
#define _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS
_CS_POSIX_V7_LPBIG_OFFBIG_LIBS,
#define _CS_POSIX_V7_LPBIG_OFFBIG_LIBS _CS_POSIX_V7_LPBIG_OFFBIG_LIBS
_CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS,
#define _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS
_CS_V6_ENV,
#define _CS_V6_ENV _CS_V6_ENV
_CS_V7_ENV
#define _CS_V7_ENV _CS_V7_ENV
};
extern long int pathconf (const char *__path, int __name)
throw () __attribute__ ((__nonnull__ (1)));
extern long int fpathconf (int __fd, int __name) throw ();
extern long int sysconf (int __name) throw ();
extern size_t confstr (int __name, char *__buf, size_t __len) throw ();
extern __pid_t getpid (void) throw ();
extern __pid_t getppid (void) throw ();
extern __pid_t getpgrp (void) throw ();
extern __pid_t __getpgid (__pid_t __pid) throw ();
extern __pid_t getpgid (__pid_t __pid) throw ();
extern int setpgid (__pid_t __pid, __pid_t __pgid) throw ();
extern int setpgrp (void) throw ();
extern __pid_t setsid (void) throw ();
extern __pid_t getsid (__pid_t __pid) throw ();
extern __uid_t getuid (void) throw ();
extern __uid_t geteuid (void) throw ();
extern __gid_t getgid (void) throw ();
extern __gid_t getegid (void) throw ();
extern int getgroups (int __size, __gid_t __list[]) throw () ;
extern int group_member (__gid_t __gid) throw ();
extern int setuid (__uid_t __uid) throw () ;
extern int setreuid (__uid_t __ruid, __uid_t __euid) throw () ;
extern int seteuid (__uid_t __uid) throw () ;
extern int setgid (__gid_t __gid) throw () ;
extern int setregid (__gid_t __rgid, __gid_t __egid) throw () ;
extern int setegid (__gid_t __gid) throw () ;
extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
throw ();
extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
throw ();
extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
throw () ;
extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
throw () ;
extern __pid_t fork (void) throw ();
extern __pid_t vfork (void) throw ();
extern char *ttyname (int __fd) throw ();
extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2))) ;
extern int isatty (int __fd) throw ();
extern int ttyslot (void) throw ();
extern int link (const char *__from, const char *__to)
throw () __attribute__ ((__nonnull__ (1, 2))) ;
extern int linkat (int __fromfd, const char *__from, int __tofd,
const char *__to, int __flags)
throw () __attribute__ ((__nonnull__ (2, 4))) ;
extern int symlink (const char *__from, const char *__to)
throw () __attribute__ ((__nonnull__ (1, 2))) ;
extern ssize_t readlink (const char *__restrict __path,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (1, 2))) ;
extern int symlinkat (const char *__from, int __tofd,
const char *__to) throw () __attribute__ ((__nonnull__ (1, 3))) ;
extern ssize_t readlinkat (int __fd, const char *__restrict __path,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (2, 3))) ;
extern int unlink (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
extern int unlinkat (int __fd, const char *__name, int __flag)
throw () __attribute__ ((__nonnull__ (2)));
extern int rmdir (const char *__path) throw () __attribute__ ((__nonnull__ (1)));
extern __pid_t tcgetpgrp (int __fd) throw ();
extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) throw ();
extern char *getlogin (void);
extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)));
extern int setlogin (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
#define __need_getopt
extern "C" {
extern char *optarg;
extern int optind;
extern int opterr;
extern int optopt;
extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
throw ();
}
#undef __need_getopt
extern int gethostname (char *__name, size_t __len) throw () __attribute__ ((__nonnull__ (1)));
extern int sethostname (const char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int sethostid (long int __id) throw () ;
extern int getdomainname (char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int setdomainname (const char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int vhangup (void) throw ();
extern int revoke (const char *__file) throw () __attribute__ ((__nonnull__ (1))) ;
extern int profil (unsigned short int *__sample_buffer, size_t __size,
size_t __offset, unsigned int __scale)
throw () __attribute__ ((__nonnull__ (1)));
extern int acct (const char *__name) throw ();
extern char *getusershell (void) throw ();
extern void endusershell (void) throw ();
extern void setusershell (void) throw ();
extern int daemon (int __nochdir, int __noclose) throw () ;
extern int chroot (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;
extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1)));
extern int fsync (int __fd);
extern int syncfs (int __fd) throw ();
extern long int gethostid (void);
extern void sync (void) throw ();
extern int getpagesize (void) throw () __attribute__ ((__const__));
extern int getdtablesize (void) throw ();
extern int truncate (const char *__file, __off_t __length)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int truncate64 (const char *__file, __off64_t __length)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int ftruncate (int __fd, __off_t __length) throw () ;
extern int ftruncate64 (int __fd, __off64_t __length) throw () ;
extern int brk (void *__addr) throw () ;
extern void *sbrk (intptr_t __delta) throw ();
extern long int syscall (long int __sysno, ...) throw ();
#define F_ULOCK 0
#define F_LOCK 1
#define F_TLOCK 2
#define F_TEST 3
extern int lockf (int __fd, int __cmd, __off_t __len) ;
extern int lockf64 (int __fd, int __cmd, __off64_t __len) ;
#define TEMP_FAILURE_RETRY(expression) (__extension__ ({ long int __result; do __result = (long int) (expression); while (__result == -1L && errno == EINTR); __result; }))
extern int fdatasync (int __fildes);
extern char *crypt (const char *__key, const char *__salt)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void encrypt (char *__glibc_block, int __edflag)
throw () __attribute__ ((__nonnull__ (1)));
extern void swab (const void *__restrict __from, void *__restrict __to,
ssize_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
}
#define BOOST_STD_EXTENSION_NAMESPACE __gnu_cxx
#define BOOST_HAS_SLIST
#define BOOST_HAS_HASH
#define BOOST_SLIST_HEADER <ext/slist>
#define BOOST_HASH_SET_HEADER <backward/hash_set>
#define BOOST_HASH_MAP_HEADER <backward/hash_map>
#define BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG
#define BOOST_HAS_TR1_COMPLEX_OVERLOADS
#define BOOST_NO_CXX11_HDR_THREAD
#define BOOST_NO_CXX11_HDR_TYPE_TRAITS
#define BOOST_NO_CXX11_HDR_CODECVT
#define BOOST_NO_CXX11_ATOMIC_SMART_PTR
#define BOOST_PLATFORM_CONFIG "boost/config/platform/linux.hpp"
#define BOOST_PLATFORM "linux"
#define _GLIBCXX_CSTDLIB 1
#define __need_size_t
#define __need_wchar_t
#define __need_NULL
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
extern "C" {
#define _STDLIB_H 1
#define WNOHANG 1
#define WUNTRACED 2
#define WSTOPPED 2
#define WEXITED 4
#define WCONTINUED 8
#define WNOWAIT 0x01000000
#define __WNOTHREAD 0x20000000
#define __WALL 0x40000000
#define __WCLONE 0x80000000
#define __ENUM_IDTYPE_T 1
#undef P_ALL
#undef P_PID
#undef P_PGID
typedef enum
{
P_ALL,
P_PID,
P_PGID
} idtype_t;
#define __WEXITSTATUS(status) (((status) & 0xff00) >> 8)
#define __WTERMSIG(status) ((status) & 0x7f)
#define __WSTOPSIG(status) __WEXITSTATUS(status)
#define __WIFEXITED(status) (__WTERMSIG(status) == 0)
#define __WIFSIGNALED(status) (((signed char) (((status) & 0x7f) + 1) >> 1) > 0)
#define __WIFSTOPPED(status) (((status) & 0xff) == 0x7f)
#define __WIFCONTINUED(status) ((status) == __W_CONTINUED)
#define __WCOREDUMP(status) ((status) & __WCOREFLAG)
#define __W_EXITCODE(ret,sig) ((ret) << 8 | (sig))
#define __W_STOPCODE(sig) ((sig) << 8 | 0x7f)
#define __W_CONTINUED 0xffff
#define __WCOREFLAG 0x80
#define _ENDIAN_H 1
#define __LITTLE_ENDIAN 1234
#define __BIG_ENDIAN 4321
#define __PDP_ENDIAN 3412
#define __BYTE_ORDER __LITTLE_ENDIAN
#define __FLOAT_WORD_ORDER __BYTE_ORDER
#define LITTLE_ENDIAN __LITTLE_ENDIAN
#define BIG_ENDIAN __BIG_ENDIAN
#define PDP_ENDIAN __PDP_ENDIAN
#define BYTE_ORDER __BYTE_ORDER
#define __LONG_LONG_PAIR(HI,LO) LO, HI
#define _BITS_BYTESWAP_H 1
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
#define __bswap_constant_16(x) ((unsigned short int) ((((x) >> 8) & 0xff) | (((x) & 0xff) << 8)))
#define __bswap_16(x) (__extension__ ({ unsigned short int __v, __x = (unsigned short int) (x); if (__builtin_constant_p (__x)) __v = __bswap_constant_16 (__x); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; }))
#define __bswap_constant_32(x) ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | (((x) & 0x0000ff00) << 8) | (((x) & 0x000000ff) << 24))
static unsigned int
__bswap_32 (unsigned int __bsx)
;
#define __bswap_constant_64(x) (__extension__ ((((x) & 0xff00000000000000ull) >> 56) | (((x) & 0x00ff000000000000ull) >> 40) | (((x) & 0x0000ff0000000000ull) >> 24) | (((x) & 0x000000ff00000000ull) >> 8) | (((x) & 0x00000000ff000000ull) << 8) | (((x) & 0x0000000000ff0000ull) << 24) | (((x) & 0x000000000000ff00ull) << 40) | (((x) & 0x00000000000000ffull) << 56)))
static __uint64_t
__bswap_64 (__uint64_t __bsx)
;
#define htobe16(x) __bswap_16 (x)
#define htole16(x) (x)
#define be16toh(x) __bswap_16 (x)
#define le16toh(x) (x)
#define htobe32(x) __bswap_32 (x)
#define htole32(x) (x)
#define be32toh(x) __bswap_32 (x)
#define le32toh(x) (x)
#define htobe64(x) __bswap_64 (x)
#define htole64(x) (x)
#define be64toh(x) __bswap_64 (x)
#define le64toh(x) (x)
union wait
{
int w_status;
struct
{
unsigned int __w_termsig:7;
unsigned int __w_coredump:1;
unsigned int __w_retcode:8;
unsigned int:16;
} __wait_terminated;
struct
{
unsigned int __w_stopval:8;
unsigned int __w_stopsig:8;
unsigned int:16;
} __wait_stopped;
};
#define w_termsig __wait_terminated.__w_termsig
#define w_coredump __wait_terminated.__w_coredump
#define w_retcode __wait_terminated.__w_retcode
#define w_stopsig __wait_stopped.__w_stopsig
#define w_stopval __wait_stopped.__w_stopval
#define __WAIT_INT(status) (*(int *) &(status))
#define __WAIT_STATUS void *
#define __WAIT_STATUS_DEFN void *
#define WEXITSTATUS(status) __WEXITSTATUS (__WAIT_INT (status))
#define WTERMSIG(status) __WTERMSIG (__WAIT_INT (status))
#define WSTOPSIG(status) __WSTOPSIG (__WAIT_INT (status))
#define WIFEXITED(status) __WIFEXITED (__WAIT_INT (status))
#define WIFSIGNALED(status) __WIFSIGNALED (__WAIT_INT (status))
#define WIFSTOPPED(status) __WIFSTOPPED (__WAIT_INT (status))
#define WIFCONTINUED(status) __WIFCONTINUED (__WAIT_INT (status))
typedef struct
{
int quot;
int rem;
} div_t;
typedef struct
{
long int quot;
long int rem;
} ldiv_t;
#define __ldiv_t_defined 1
__extension__ typedef struct
{
long long int quot;
long long int rem;
} lldiv_t;
#define __lldiv_t_defined 1
#define RAND_MAX 2147483647
#define EXIT_FAILURE 1
#define EXIT_SUCCESS 0
#define MB_CUR_MAX (__ctype_get_mb_cur_max ())
extern size_t __ctype_get_mb_cur_max (void) throw () ;
extern double atof (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern int atoi (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern long int atol (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
__extension__ extern long long int atoll (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern double strtod (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
extern float strtof (const char *__restrict __nptr,
char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1)));
extern long double strtold (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
extern long int strtol (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
extern unsigned long int strtoul (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern long long int strtoq (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern unsigned long long int strtouq (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern long long int strtoll (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern unsigned long long int strtoull (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
#define _XLOCALE_H 1
typedef struct __locale_struct
{
struct __locale_data *__locales[13];
const unsigned short int *__ctype_b;
const int *__ctype_tolower;
const int *__ctype_toupper;
const char *__names[13];
} *__locale_t;
typedef __locale_t locale_t;
extern long int strtol_l (const char *__restrict __nptr,
char **__restrict __endptr, int __base,
__locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4)));
extern unsigned long int strtoul_l (const char *__restrict __nptr,
char **__restrict __endptr,
int __base, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4)));
__extension__
extern long long int strtoll_l (const char *__restrict __nptr,
char **__restrict __endptr, int __base,
__locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4)));
__extension__
extern unsigned long long int strtoull_l (const char *__restrict __nptr,
char **__restrict __endptr,
int __base, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4)));
extern double strtod_l (const char *__restrict __nptr,
char **__restrict __endptr, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern float strtof_l (const char *__restrict __nptr,
char **__restrict __endptr, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern long double strtold_l (const char *__restrict __nptr,
char **__restrict __endptr,
__locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern char *l64a (long int __n) throw () ;
extern long int a64l (const char *__s)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
#define _SYS_TYPES_H 1
extern "C" {
typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;
#define __u_char_defined
typedef __loff_t loff_t;
typedef __ino_t ino_t;
#define __ino_t_defined
typedef __ino64_t ino64_t;
#define __ino64_t_defined
typedef __dev_t dev_t;
#define __dev_t_defined
typedef __mode_t mode_t;
#define __mode_t_defined
typedef __nlink_t nlink_t;
#define __nlink_t_defined
typedef __id_t id_t;
#define __id_t_defined
typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;
#define __daddr_t_defined
typedef __key_t key_t;
#define __key_t_defined
#define __need_clock_t
#define __need_time_t
#define __need_timer_t
#define __need_clockid_t
#define __clock_t_defined 1
typedef __clock_t clock_t;
#undef __need_clock_t
#define __time_t_defined 1
typedef __time_t time_t;
#undef __need_time_t
#define __clockid_t_defined 1
typedef __clockid_t clockid_t;
#undef __clockid_time_t
#define __timer_t_defined 1
typedef __timer_t timer_t;
#undef __need_timer_t
#undef __need_timespec
typedef __suseconds_t suseconds_t;
#define __suseconds_t_defined
#define __need_size_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
#define __intN_t(N,MODE) typedef int int ##N ##_t __attribute__ ((__mode__ (MODE)))
#define __u_intN_t(N,MODE) typedef unsigned int u_int ##N ##_t __attribute__ ((__mode__ (MODE)))
#define __int8_t_defined
typedef int int8_t __attribute__ ((__mode__ (__QI__)));
typedef int int16_t __attribute__ ((__mode__ (__HI__)));
typedef int int32_t __attribute__ ((__mode__ (__SI__)));
typedef int int64_t __attribute__ ((__mode__ (__DI__)));
typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
typedef int register_t __attribute__ ((__mode__ (__word__)));
#define __BIT_TYPES_DEFINED__ 1
#define _SYS_SELECT_H 1
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
#define __FD_ZERO_STOS "stosq"
#define __FD_ZERO(fdsp) do { int __d0, __d1; __asm__ __volatile__ ("cld; rep; " __FD_ZERO_STOS : "=c" (__d0), "=D" (__d1) : "a" (0), "0" (sizeof (fd_set) / sizeof (__fd_mask)), "1" (&__FDS_BITS (fdsp)[0]) : "memory"); } while (0)
#define __FD_SET(d,set) ((void) (__FDS_BITS (set)[__FD_ELT (d)] |= __FD_MASK (d)))
#define __FD_CLR(d,set) ((void) (__FDS_BITS (set)[__FD_ELT (d)] &= ~__FD_MASK (d)))
#define __FD_ISSET(d,set) ((__FDS_BITS (set)[__FD_ELT (d)] & __FD_MASK (d)) != 0)
#define _SIGSET_H_types 1
typedef int __sig_atomic_t;
#define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int)))
typedef struct
{
unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
} __sigset_t;
#define __sigset_t_defined
typedef __sigset_t sigset_t;
#define __need_time_t
#define __need_timespec
#undef __need_clock_t
#undef __need_time_t
#undef __clockid_time_t
#undef __need_timer_t
#define __timespec_defined 1
struct timespec
{
__time_t tv_sec;
__syscall_slong_t tv_nsec;
};
#undef __need_timespec
#define __need_timeval
#define _STRUCT_TIMEVAL 1
struct timeval
{
__time_t tv_sec;
__suseconds_t tv_usec;
};
#undef __need_timeval
typedef long int __fd_mask;
#undef __NFDBITS
#define __NFDBITS (8 * (int) sizeof (__fd_mask))
#define __FD_ELT(d) ((d) / __NFDBITS)
#define __FD_MASK(d) ((__fd_mask) 1 << ((d) % __NFDBITS))
typedef struct
{
__fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
#define __FDS_BITS(set) ((set)->fds_bits)
} fd_set;
#define FD_SETSIZE __FD_SETSIZE
typedef __fd_mask fd_mask;
#define NFDBITS __NFDBITS
#define FD_SET(fd,fdsetp) __FD_SET (fd, fdsetp)
#define FD_CLR(fd,fdsetp) __FD_CLR (fd, fdsetp)
#define FD_ISSET(fd,fdsetp) __FD_ISSET (fd, fdsetp)
#define FD_ZERO(fdsetp) __FD_ZERO (fdsetp)
extern "C" {
extern int select (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
struct timeval *__restrict __timeout);
extern int pselect (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
const struct timespec *__restrict __timeout,
const __sigset_t *__restrict __sigmask);
}
#define _SYS_SYSMACROS_H 1
extern "C" {
__extension__
extern unsigned int gnu_dev_major (unsigned long long int __dev)
throw () __attribute__ ((__const__));
__extension__
extern unsigned int gnu_dev_minor (unsigned long long int __dev)
throw () __attribute__ ((__const__));
__extension__
extern unsigned long long int gnu_dev_makedev (unsigned int __major,
unsigned int __minor)
throw () __attribute__ ((__const__));
}
#define major(dev) gnu_dev_major (dev)
#define minor(dev) gnu_dev_minor (dev)
#define makedev(maj,min) gnu_dev_makedev (maj, min)
typedef __blksize_t blksize_t;
#define __blksize_t_defined
typedef __blkcnt_t blkcnt_t;
#define __blkcnt_t_defined
typedef __fsblkcnt_t fsblkcnt_t;
#define __fsblkcnt_t_defined
typedef __fsfilcnt_t fsfilcnt_t;
#define __fsfilcnt_t_defined
typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;
#define _BITS_PTHREADTYPES_H 1
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
#define __SIZEOF_PTHREAD_ATTR_T 56
#define __SIZEOF_PTHREAD_MUTEX_T 40
#define __SIZEOF_PTHREAD_MUTEXATTR_T 4
#define __SIZEOF_PTHREAD_COND_T 48
#define __SIZEOF_PTHREAD_CONDATTR_T 4
#define __SIZEOF_PTHREAD_RWLOCK_T 56
#define __SIZEOF_PTHREAD_RWLOCKATTR_T 8
#define __SIZEOF_PTHREAD_BARRIER_T 32
#define __SIZEOF_PTHREAD_BARRIERATTR_T 4
typedef unsigned long int pthread_t;
union pthread_attr_t
{
char __size[56];
long int __align;
};
typedef union pthread_attr_t pthread_attr_t;
#define __have_pthread_attr_t 1
typedef struct __pthread_internal_list
{
struct __pthread_internal_list *__prev;
struct __pthread_internal_list *__next;
} __pthread_list_t;
typedef union
{
struct __pthread_mutex_s
{
int __lock;
unsigned int __count;
int __owner;
unsigned int __nusers;
int __kind;
short __spins;
short __elision;
__pthread_list_t __list;
#define __PTHREAD_MUTEX_HAVE_PREV 1
#define __PTHREAD_MUTEX_HAVE_ELISION 1
} __data;
char __size[40];
long int __align;
} pthread_mutex_t;
typedef union
{
char __size[4];
int __align;
} pthread_mutexattr_t;
typedef union
{
struct
{
int __lock;
unsigned int __futex;
__extension__ unsigned long long int __total_seq;
__extension__ unsigned long long int __wakeup_seq;
__extension__ unsigned long long int __woken_seq;
void *__mutex;
unsigned int __nwaiters;
unsigned int __broadcast_seq;
} __data;
char __size[48];
__extension__ long long int __align;
} pthread_cond_t;
typedef union
{
char __size[4];
int __align;
} pthread_condattr_t;
typedef unsigned int pthread_key_t;
typedef int pthread_once_t;
typedef union
{
struct
{
int __lock;
unsigned int __nr_readers;
unsigned int __readers_wakeup;
unsigned int __writer_wakeup;
unsigned int __nr_readers_queued;
unsigned int __nr_writers_queued;
int __writer;
int __shared;
unsigned long int __pad1;
unsigned long int __pad2;
unsigned int __flags;
#define __PTHREAD_RWLOCK_INT_FLAGS_SHARED 1
} __data;
char __size[56];
long int __align;
} pthread_rwlock_t;
typedef union
{
char __size[8];
long int __align;
} pthread_rwlockattr_t;
typedef volatile int pthread_spinlock_t;
typedef union
{
char __size[32];
long int __align;
} pthread_barrier_t;
typedef union
{
char __size[4];
int __align;
} pthread_barrierattr_t;
}
extern long int random (void) throw ();
extern void srandom (unsigned int __seed) throw ();
extern char *initstate (unsigned int __seed, char *__statebuf,
size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));
extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));
struct random_data
{
int32_t *fptr;
int32_t *rptr;
int32_t *state;
int rand_type;
int rand_deg;
int rand_sep;
int32_t *end_ptr;
};
extern int random_r (struct random_data *__restrict __buf,
int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int srandom_r (unsigned int __seed, struct random_data *__buf)
throw () __attribute__ ((__nonnull__ (2)));
extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
size_t __statelen,
struct random_data *__restrict __buf)
throw () __attribute__ ((__nonnull__ (2, 4)));
extern int setstate_r (char *__restrict __statebuf,
struct random_data *__restrict __buf)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int rand (void) throw ();
extern void srand (unsigned int __seed) throw ();
extern int rand_r (unsigned int *__seed) throw ();
extern double drand48 (void) throw ();
extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));
extern long int lrand48 (void) throw ();
extern long int nrand48 (unsigned short int __xsubi[3])
throw () __attribute__ ((__nonnull__ (1)));
extern long int mrand48 (void) throw ();
extern long int jrand48 (unsigned short int __xsubi[3])
throw () __attribute__ ((__nonnull__ (1)));
extern void srand48 (long int __seedval) throw ();
extern unsigned short int *seed48 (unsigned short int __seed16v[3])
throw () __attribute__ ((__nonnull__ (1)));
extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));
struct drand48_data
{
unsigned short int __x[3];
unsigned short int __old_x[3];
unsigned short int __c;
unsigned short int __init;
__extension__ unsigned long long int __a;
};
extern int drand48_r (struct drand48_data *__restrict __buffer,
double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int erand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int lrand48_r (struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int nrand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int mrand48_r (struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int jrand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
throw () __attribute__ ((__nonnull__ (2)));
extern int seed48_r (unsigned short int __seed16v[3],
struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int lcong48_r (unsigned short int __param[7],
struct drand48_data *__buffer)
throw () __attribute__ ((__nonnull__ (1, 2)));
#define __malloc_and_calloc_defined
extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
extern void *calloc (size_t __nmemb, size_t __size)
throw () __attribute__ ((__malloc__)) ;
extern void *realloc (void *__ptr, size_t __size)
throw () __attribute__ ((__warn_unused_result__));
extern void free (void *__ptr) throw ();
extern void cfree (void *__ptr) throw ();
#define _ALLOCA_H 1
#define __need_size_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
extern "C" {
#undef alloca
extern void *alloca (size_t __size) throw ();
#define alloca(size) __builtin_alloca (size)
}
extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
throw () __attribute__ ((__nonnull__ (1))) ;
extern void *aligned_alloc (size_t __alignment, size_t __size)
throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) ;
extern void abort (void) throw () __attribute__ ((__noreturn__));
extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));
extern "C++" int at_quick_exit (void (*__func) (void))
throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));
extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
throw () __attribute__ ((__nonnull__ (1)));
extern void exit (int __status) throw () __attribute__ ((__noreturn__));
extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__));
extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));
extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ;
extern char *secure_getenv (const char *__name)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));
extern int setenv (const char *__name, const char *__value, int __replace)
throw () __attribute__ ((__nonnull__ (2)));
extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
extern int clearenv (void) throw ();
extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
extern int mkstemps64 (char *__template, int __suffixlen)
__attribute__ ((__nonnull__ (1))) ;
extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
extern int mkostemps (char *__template, int __suffixlen, int __flags)
__attribute__ ((__nonnull__ (1))) ;
extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
__attribute__ ((__nonnull__ (1))) ;
extern int system (const char *__command) ;
extern char *canonicalize_file_name (const char *__name)
throw () __attribute__ ((__nonnull__ (1))) ;
extern char *realpath (const char *__restrict __name,
char *__restrict __resolved) throw () ;
#define __COMPAR_FN_T
typedef int (*__compar_fn_t) (const void *, const void *);
typedef __compar_fn_t comparison_fn_t;
typedef int (*__compar_d_fn_t) (const void *, const void *, void *);
extern void *bsearch (const void *__key, const void *__base,
size_t __nmemb, size_t __size, __compar_fn_t __compar)
__attribute__ ((__nonnull__ (1, 2, 5))) ;
extern void qsort (void *__base, size_t __nmemb, size_t __size,
__compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
__compar_d_fn_t __compar, void *__arg)
__attribute__ ((__nonnull__ (1, 4)));
extern int abs (int __x) throw () __attribute__ ((__const__)) ;
extern long int labs (long int __x) throw () __attribute__ ((__const__)) ;
__extension__ extern long long int llabs (long long int __x)
throw () __attribute__ ((__const__)) ;
extern div_t div (int __numer, int __denom)
throw () __attribute__ ((__const__)) ;
extern ldiv_t ldiv (long int __numer, long int __denom)
throw () __attribute__ ((__const__)) ;
__extension__ extern lldiv_t lldiv (long long int __numer,
long long int __denom)
throw () __attribute__ ((__const__)) ;
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *gcvt (double __value, int __ndigit, char *__buf)
throw () __attribute__ ((__nonnull__ (3))) ;
extern char *qecvt (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign)
throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qfcvt (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign)
throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qgcvt (long double __value, int __ndigit, char *__buf)
throw () __attribute__ ((__nonnull__ (3))) ;
extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign, char *__restrict __buf,
size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign, char *__restrict __buf,
size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qecvt_r (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qfcvt_r (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int mblen (const char *__s, size_t __n) throw ();
extern int mbtowc (wchar_t *__restrict __pwc,
const char *__restrict __s, size_t __n) throw ();
extern int wctomb (char *__s, wchar_t __wchar) throw ();
extern size_t mbstowcs (wchar_t *__restrict __pwcs,
const char *__restrict __s, size_t __n) throw ();
extern size_t wcstombs (char *__restrict __s,
const wchar_t *__restrict __pwcs, size_t __n)
throw ();
extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) ;
extern int getsubopt (char **__restrict __optionp,
char *const *__restrict __tokens,
char **__restrict __valuep)
throw () __attribute__ ((__nonnull__ (1, 2, 3))) ;
extern void setkey (const char *__key) throw () __attribute__ ((__nonnull__ (1)));
extern int posix_openpt (int __oflag) ;
extern int grantpt (int __fd) throw ();
extern int unlockpt (int __fd) throw ();
extern char *ptsname (int __fd) throw () ;
extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2)));
extern int getpt (void);
extern int getloadavg (double __loadavg[], int __nelem)
throw () __attribute__ ((__nonnull__ (1)));
#undef __need_malloc_and_calloc
}
#undef abort
#undef abs
#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
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::div_t;
using ::ldiv_t;
using ::abort;
using ::abs;
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;
long
abs(long __i) ;
ldiv_t
div(long __i, long __j) ;
long long
abs(long long __x) ;
}
#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;
lldiv_t
div(long long __n, long long __d)
;
using ::lldiv;
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;
}
#define BOOST_HAS_STDINT_H
#define BOOST_HAS_GETTIMEOFDAY
#define BOOST_HAS_NANOSLEEP
#define BOOST_HAS_UNISTD_H
#define BOOST_HAS_NL_TYPES_H
#define BOOST_HAS_STDINT_H
#define BOOST_HAS_DIRENT_H
#define BOOST_HAS_SIGACTION
#define BOOST_HAS_PTHREADS
#define BOOST_HAS_NANOSLEEP
#define BOOST_HAS_CLOCK_GETTIME
#define BOOST_HAS_SCHED_YIELD
#define BOOST_HAS_GETTIMEOFDAY
#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
#define BOOST_HAS_LOG1P
#define BOOST_HAS_EXPM1
#define BOOST_HAS_PTHREAD_YIELD
#define BOOST_CONFIG_SUFFIX_HPP
#define BOOST_NO_MS_INT64_NUMERIC_LIMITS
#define BOOST_MSVC6_MEMBER_TEMPLATES
#define BOOST_HAS_PARTIAL_STD_ALLOCATOR
#define BOOST_PREVENT_MACRO_SUBSTITUTION
#define BOOST_USING_STD_MIN() using std::min
#define BOOST_USING_STD_MAX() using std::max
#define BOOST_STATIC_CONSTANT(type,assignment) static const type assignment
#define BOOST_USE_FACET(Type,loc) std::use_facet< Type >(loc)
#define BOOST_HAS_FACET(Type,loc) std::has_facet< Type >(loc)
#define BOOST_NESTED_TEMPLATE template
#define BOOST_UNREACHABLE_RETURN(x)
#define BOOST_DEDUCED_TYPENAME typename
#define BOOST_CTOR_TYPENAME typename
namespace boost{
__extension__ typedef long long long_long_type;
__extension__ typedef unsigned long long ulong_long_type;
}
namespace boost{
__extension__ typedef __int128 int128_type;
__extension__ typedef unsigned __int128 uint128_type;
}
#define BOOST_EXPLICIT_TEMPLATE_TYPE(t)
#define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
#define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t,v)
#define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t,v)
#define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t)
#define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
#define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t,v)
#define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t,v)
#define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X)
#define BOOST_DO_STRINGIZE(X) #X
#define BOOST_JOIN(X,Y) BOOST_DO_JOIN( X, Y )
#define BOOST_DO_JOIN(X,Y) BOOST_DO_JOIN2(X,Y)
#define BOOST_DO_JOIN2(X,Y) X ##Y
#define BOOST_GPU_ENABLED
#define BOOST_FORCEINLINE inline __attribute__ ((__always_inline__))
#define BOOST_NOINLINE __attribute__ ((__noinline__))
#define BOOST_ALIGNMENT(x) alignas(x)
#define BOOST_DEFAULTED_FUNCTION(fun,body) fun = default;
#define BOOST_DELETED_FUNCTION(fun) fun = delete;
#define BOOST_NO_0X_HDR_CODECVT
#define BOOST_NO_0X_HDR_THREAD
#define BOOST_NO_0X_HDR_TYPE_TRAITS
#define BOOST_NOEXCEPT noexcept
#define BOOST_NOEXCEPT_OR_NOTHROW noexcept
#define BOOST_NOEXCEPT_IF(Predicate) noexcept((Predicate))
#define BOOST_NOEXCEPT_EXPR(Expression) noexcept((Expression))
#define BOOST_FALLTHROUGH ((void)0)
#define BOOST_CONSTEXPR constexpr
#define BOOST_CONSTEXPR_OR_CONST constexpr
#define BOOST_STATIC_CONSTEXPR static BOOST_CONSTEXPR_OR_CONST
#define BOOST_VERSION_HPP
#define BOOST_VERSION 105500
#define BOOST_LIB_VERSION "1_55"
#define BOOST_ASIO_HAS_BOOST_CONFIG 1
#define BOOST_ASIO_HEADER_ONLY 1
#define BOOST_ASIO_DECL inline
#define BOOST_ASIO_HAS_MOVE 1
#define BOOST_ASIO_MOVE_ARG(type) type&&
#define BOOST_ASIO_MOVE_CAST(type) static_cast<type&&>
#define BOOST_ASIO_MOVE_CAST2(type1,type2) static_cast<type1, type2&&>
#define BOOST_ASIO_HAS_VARIADIC_TEMPLATES 1
#define BOOST_ASIO_HAS_CONSTEXPR 1
#define BOOST_ASIO_CONSTEXPR constexpr
#define BOOST_ASIO_HAS_STD_SYSTEM_ERROR 1
#define BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT BOOST_NOEXCEPT
#define BOOST_ASIO_HAS_STD_ARRAY 1
#define BOOST_ASIO_HAS_STD_SHARED_PTR 1
#define BOOST_ASIO_HAS_STD_ATOMIC 1
#define BOOST_ASIO_HAS_STD_CHRONO 1
#define BOOST_ASIO_HAS_BOOST_CHRONO 1
#define BOOST_ASIO_HAS_BOOST_DATE_TIME 1
#define BOOST_ASIO_HAS_STD_ADDRESSOF 1
#define BOOST_ASIO_HAS_STD_FUNCTION 1
#define BOOST_ASIO_HAS_STD_TYPE_TRAITS 1
#define BOOST_ASIO_HAS_CSTDINT 1
#define BOOST_ASIO_HAS_STD_THREAD 1
#define BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR 1
#define LINUX_VERSION_CODE 200707
#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
#define BOOST_ASIO_HAS_EPOLL 1
#define BOOST_ASIO_HAS_EVENTFD 1
#define BOOST_ASIO_HAS_TIMERFD 1
#define BOOST_ASIO_HAS_SERIAL_PORT 1
#define BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR 1
#define BOOST_ASIO_HAS_LOCAL_SOCKETS 1
#define BOOST_ASIO_HAS_SIGACTION 1
#define BOOST_ASIO_HAS_SIGNAL 1
#define BOOST_ASIO_HAS_THREADS 1
#define BOOST_ASIO_HAS_PTHREADS 1
#define BOOST_ASIO_PREVENT_MACRO_SUBSTITUTION
#define BOOST_ASIO_STATIC_CONSTANT(type,assignment) BOOST_STATIC_CONSTANT(type, assignment)
#define BOOST_ASIO_HAS_BOOST_ARRAY 1
#define BOOST_ASIO_HAS_BOOST_ASSERT 1
#define BOOST_ASIO_HAS_BOOST_LIMITS 1
#define BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION 1
#define BOOST_ASIO_HAS_BOOST_REGEX 1
#define BOOST_ASIO_HAS_BOOST_BIND 1
#define BOOST_ASIO_HAS_BOOST_WORKAROUND 1
#define BOOST_ASIO_HAS_HANDLER_HOOKS 1
#define BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION 1
#define BOOST_ASIO_THREAD_KEYWORD __thread
#define BOOST_ASIO_HAS_SSIZE_T 1
#define BOOST_ASIO_HANDLER_TYPE_HPP
namespace boost {
namespace asio {
template <typename Handler, typename Signature>
struct handler_type
{
typedef Handler type;
};
template <typename Handler, typename Signature>
struct handler_type<const Handler, Signature>
: handler_type<Handler, Signature> {};
template <typename Handler, typename Signature>
struct handler_type<volatile Handler, Signature>
: handler_type<Handler, Signature> {};
template <typename Handler, typename Signature>
struct handler_type<const volatile Handler, Signature>
: handler_type<Handler, Signature> {};
template <typename Handler, typename Signature>
struct handler_type<const Handler&, Signature>
: handler_type<Handler, Signature> {};
template <typename Handler, typename Signature>
struct handler_type<volatile Handler&, Signature>
: handler_type<Handler, Signature> {};
template <typename Handler, typename Signature>
struct handler_type<const volatile Handler&, Signature>
: handler_type<Handler, Signature> {};
template <typename Handler, typename Signature>
struct handler_type<Handler&, Signature>
: handler_type<Handler, Signature> {};
template <typename Handler, typename Signature>
struct handler_type<Handler&&, Signature>
: handler_type<Handler, Signature> {};
template <typename ReturnType, typename Signature>
struct handler_type<ReturnType(), Signature>
: handler_type<ReturnType(*)(), Signature> {};
template <typename ReturnType, typename Arg1, typename Signature>
struct handler_type<ReturnType(Arg1), Signature>
: handler_type<ReturnType(*)(Arg1), Signature> {};
template <typename ReturnType, typename Arg1, typename Arg2, typename Signature>
struct handler_type<ReturnType(Arg1, Arg2), Signature>
: handler_type<ReturnType(*)(Arg1, Arg2), Signature> {};
template <typename ReturnType, typename Arg1, typename Arg2, typename Arg3,
typename Signature>
struct handler_type<ReturnType(Arg1, Arg2, Arg3), Signature>
: handler_type<ReturnType(*)(Arg1, Arg2, Arg3), Signature> {};
template <typename ReturnType, typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Signature>
struct handler_type<ReturnType(Arg1, Arg2, Arg3, Arg4), Signature>
: handler_type<ReturnType(*)(Arg1, Arg2, Arg3, Arg4), Signature> {};
template <typename ReturnType, typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5, typename Signature>
struct handler_type<ReturnType(Arg1, Arg2, Arg3, Arg4, Arg5), Signature>
: handler_type<ReturnType(*)(Arg1, Arg2, Arg3, Arg4, Arg5), Signature> {};
}
}
#define BOOST_ASIO_HANDLER_TYPE(h,sig) typename handler_type<h, sig>::type
namespace boost {
namespace asio {
template <typename Handler>
class async_result
{
public:
typedef void type;
explicit async_result(Handler&)
;
type get()
;
};
namespace detail {
template <typename Handler, typename Signature>
struct async_result_init
{
explicit async_result_init(Handler&& orig_handler)
;
typename handler_type<Handler, Signature>::type handler;
async_result<typename handler_type<Handler, Signature>::type> result;
};
template <typename Handler, typename Signature>
struct async_result_type_helper
{
typedef typename async_result<
typename handler_type<Handler, Signature>::type
>::type type;
};
}
}
}
#define BOOST_ASIO_INITFN_RESULT_TYPE(h,sig) typename ::boost::asio::async_result< typename ::boost::asio::handler_type<h, sig>::type>::type
#define BOOST_ASIO_BASIC_DATAGRAM_SOCKET_HPP
#define BOOST_ASIO_BASIC_SOCKET_HPP
#define BOOST_ASIO_BASIC_IO_OBJECT_HPP
#define BOOST_ASIO_IO_SERVICE_HPP
#define _GLIBCXX_STDEXCEPT 1
#define __EXCEPTION__
#pragma GCC visibility push(default)
#define _GLIBCXX_ATOMIC_LOCK_FREE_H 1
#define ATOMIC_BOOL_LOCK_FREE __GCC_ATOMIC_BOOL_LOCK_FREE
#define ATOMIC_CHAR_LOCK_FREE __GCC_ATOMIC_CHAR_LOCK_FREE
#define ATOMIC_WCHAR_T_LOCK_FREE __GCC_ATOMIC_WCHAR_T_LOCK_FREE
#define ATOMIC_CHAR16_T_LOCK_FREE __GCC_ATOMIC_CHAR16_T_LOCK_FREE
#define ATOMIC_CHAR32_T_LOCK_FREE __GCC_ATOMIC_CHAR32_T_LOCK_FREE
#define ATOMIC_SHORT_LOCK_FREE __GCC_ATOMIC_SHORT_LOCK_FREE
#define ATOMIC_INT_LOCK_FREE __GCC_ATOMIC_INT_LOCK_FREE
#define ATOMIC_LONG_LOCK_FREE __GCC_ATOMIC_LONG_LOCK_FREE
#define ATOMIC_LLONG_LOCK_FREE __GCC_ATOMIC_LLONG_LOCK_FREE
#define ATOMIC_POINTER_LOCK_FREE __GCC_ATOMIC_POINTER_LOCK_FREE
extern "C++" {
namespace std
{
class exception
{
public:
exception() noexcept { }
virtual ~exception() noexcept;
virtual const char* what() const noexcept;
};
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__));
bool uncaught_exception() noexcept __attribute__ ((__pure__));
}
namespace __gnu_cxx
{
void __verbose_terminate_handler();
}
}
#pragma GCC visibility pop
#define _EXCEPTION_PTR_H
#pragma GCC visibility push(default)
#define _EXCEPTION_DEFINES_H 1
#define __try try
#define __catch(X) catch(X)
#define __throw_exception_again throw
extern "C++" {
namespace std
{
class type_info;
namespace __exception_ptr
{
class exception_ptr;
}
using __exception_ptr::exception_ptr;
exception_ptr current_exception() noexcept;
void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__));
namespace __exception_ptr
{
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);
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; }
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;
explicit operator bool() const
;
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__));
void
swap(exception_ptr& __lhs, exception_ptr& __rhs)
;
}
template<typename _Ex>
exception_ptr
make_exception_ptr(_Ex __ex) noexcept
{
try
{
throw __ex;
}
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
#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)
;
explicit _Nested_exception(_Except&& __ex)
;
};
template<typename _Tp,
bool __with_nested = !__is_base_of(nested_exception, _Tp)>
struct _Throw_with_nested_impl
{
template<typename _Up>
static void _S_throw(_Up&& __t)
;
};
template<typename _Tp>
struct _Throw_with_nested_impl<_Tp, false>
{
template<typename _Up>
static void _S_throw(_Up&& __t)
;
};
template<typename _Tp, bool = __is_class(_Tp)>
struct _Throw_with_nested_helper : _Throw_with_nested_impl<_Tp>
{ };
template<typename _Tp>
struct _Throw_with_nested_helper<_Tp, false>
: _Throw_with_nested_impl<_Tp, false>
{ };
template<typename _Tp>
struct _Throw_with_nested_helper<_Tp&, false>
: _Throw_with_nested_helper<_Tp>
{ };
template<typename _Tp>
struct _Throw_with_nested_helper<_Tp&&, false>
: _Throw_with_nested_helper<_Tp>
{ };
template<typename _Tp>
[[noreturn]]
inline void
throw_with_nested(_Tp&& __t)
{
_Throw_with_nested_helper<_Tp>::_S_throw(static_cast<_Tp&&>(__t));
}
template<typename _Tp, bool = __is_polymorphic(_Tp)>
struct _Rethrow_if_nested_impl
{
static void _S_rethrow(const _Tp& __t)
{
if (auto __tp = dynamic_cast<const nested_exception*>(&__t))
__tp->rethrow_nested();
}
};
template<typename _Tp>
struct _Rethrow_if_nested_impl<_Tp, false>
{
static void _S_rethrow(const _Tp&) { }
};
template<typename _Ex>
void
rethrow_if_nested(const _Ex& __ex)
;
}
}
#pragma GCC visibility pop
#define _GLIBCXX_STRING 1
#define _STRINGFWD_H 1
#define _MEMORYFWD_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename>
class allocator;
template<>
class allocator<void>;
template<typename, typename>
struct uses_allocator;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<class _CharT>
struct char_traits;
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_string;
template<> struct char_traits<char>;
typedef basic_string<char> string;
template<> struct char_traits<wchar_t>;
typedef basic_string<wchar_t> wstring;
template<> struct char_traits<char16_t>;
template<> struct char_traits<char32_t>;
typedef basic_string<char16_t> u16string;
typedef basic_string<char32_t> u32string;
}
#define _CHAR_TRAITS_H 1
#define _STL_ALGOBASE_H 1
#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__));
}
#define _CPP_TYPE_TRAITS_H 1
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
template<typename _Iterator, typename _Container>
class __normal_iterator;
}
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;
};
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_normal_iterator
{
enum { __value = 0 };
typedef __false_type __type;
};
template<typename _Iterator, typename _Container>
struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
_Container> >
{
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>
class move_iterator;
template<typename _Iterator>
struct __is_move_iterator< move_iterator<_Iterator> >
{
enum { __value = 1 };
typedef __true_type __type;
};
}
#define _EXT_TYPE_TRAITS 1
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>
bool
__is_null_pointer(_Type* __ptr)
;
template<typename _Type>
bool
__is_null_pointer(_Type)
;
bool
__is_null_pointer(std::nullptr_t)
;
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;
};
}
#define _EXT_NUMERIC_TRAITS 1
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 : 64) * 643L / 2136);
static const bool __is_signed = true;
static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18);
static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
};
template<typename _Value>
const int __numeric_traits_floating<_Value>::__max_digits10;
template<typename _Value>
const bool __numeric_traits_floating<_Value>::__is_signed;
template<typename _Value>
const int __numeric_traits_floating<_Value>::__digits10;
template<typename _Value>
const int __numeric_traits_floating<_Value>::__max_exponent10;
template<typename _Value>
struct __numeric_traits
: public __conditional_type<std::__is_integer<_Value>::__value,
__numeric_traits_integer<_Value>,
__numeric_traits_floating<_Value> >::__type
{ };
}
#undef __glibcxx_floating
#undef __glibcxx_max_digits10
#undef __glibcxx_digits10
#undef __glibcxx_max_exponent10
#define _STL_ITERATOR_BASE_TYPES_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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 { };
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;
};
template<typename _Tp> class __has_iterator_category_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::iterator_category>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_iterator_category : public __has_iterator_category_helper <typename remove_cv<_Tp>::type>::type { };
template<typename _Iterator,
bool = __has_iterator_category<_Iterator>::value>
struct __iterator_traits { };
template<typename _Iterator>
struct __iterator_traits<_Iterator, true>
{
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> { };
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>
typename iterator_traits<_Iter>::iterator_category
__iterator_category(const _Iter&)
;
template<typename _Iterator, bool _HasBase>
struct _Iter_base
{
typedef _Iterator iterator_type;
static iterator_type _S_base(_Iterator __it)
;
};
template<typename _Iterator>
struct _Iter_base<_Iterator, true>
{
typedef typename _Iterator::iterator_type iterator_type;
static iterator_type _S_base(_Iterator __it)
;
};
template<typename _InIter>
using _RequireInputIter = typename
enable_if<is_convertible<typename
iterator_traits<_InIter>::iterator_category,
input_iterator_tag>::value>::type;
}
#define _STL_ITERATOR_BASE_FUNCS_H 1
#define _GLIBCXX_DEBUG_MACRO_SWITCH_H 1
namespace std
{
namespace __debug { }
}
namespace __gnu_debug
{
using namespace std::__debug;
}
#define _GLIBCXX_DEBUG_ASSERT(_Condition)
#define _GLIBCXX_DEBUG_PEDASSERT(_Condition)
#define _GLIBCXX_DEBUG_ONLY(_Statement) ;
#define __glibcxx_requires_cond(_Cond,_Msg)
#define __glibcxx_requires_valid_range(_First,_Last)
#define __glibcxx_requires_non_empty_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_nonempty()
#define __glibcxx_requires_string(_String)
#define __glibcxx_requires_string_len(_String,_Len)
#define __glibcxx_requires_subscript(_N)
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _InputIterator>
typename iterator_traits<_InputIterator>::difference_type
__distance(_InputIterator __first, _InputIterator __last,
input_iterator_tag)
;
template<typename _RandomAccessIterator>
typename iterator_traits<_RandomAccessIterator>::difference_type
__distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
random_access_iterator_tag)
;
template<typename _InputIterator>
typename iterator_traits<_InputIterator>::difference_type
distance(_InputIterator __first, _InputIterator __last)
;
template<typename _InputIterator, typename _Distance>
void
__advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
;
template<typename _BidirectionalIterator, typename _Distance>
void
__advance(_BidirectionalIterator& __i, _Distance __n,
bidirectional_iterator_tag)
;
template<typename _RandomAccessIterator, typename _Distance>
void
__advance(_RandomAccessIterator& __i, _Distance __n,
random_access_iterator_tag)
;
template<typename _InputIterator, typename _Distance>
void
advance(_InputIterator& __i, _Distance __n)
;
template<typename _ForwardIterator>
_ForwardIterator
next(_ForwardIterator __x, typename
iterator_traits<_ForwardIterator>::difference_type __n = 1)
;
template<typename _BidirectionalIterator>
_BidirectionalIterator
prev(_BidirectionalIterator __x, typename
iterator_traits<_BidirectionalIterator>::difference_type __n = 1)
;
}
#define _STL_ITERATOR_H 1
#define _PTR_TRAITS_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp> class __has_element_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::element_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_element_type : public __has_element_type_helper <typename remove_cv<_Tp>::type>::type { };
template<typename _Tp> class __has_difference_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::difference_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_difference_type : public __has_difference_type_helper <typename remove_cv<_Tp>::type>::type { };
template<typename _Tp, bool = __has_element_type<_Tp>::value>
struct __ptrtr_elt_type;
template<typename _Tp>
struct __ptrtr_elt_type<_Tp, true>
{
typedef typename _Tp::element_type __type;
};
template<template<typename, typename...> class _SomePtr, typename _Tp,
typename... _Args>
struct __ptrtr_elt_type<_SomePtr<_Tp, _Args...>, false>
{
typedef _Tp __type;
};
template<typename _Tp, bool = __has_difference_type<_Tp>::value>
struct __ptrtr_diff_type
{
typedef typename _Tp::difference_type __type;
};
template<typename _Tp>
struct __ptrtr_diff_type<_Tp, false>
{
typedef ptrdiff_t __type;
};
template<typename _Ptr, typename _Up>
class __ptrtr_rebind_helper
{
template<typename _Ptr2, typename _Up2>
static constexpr true_type
_S_chk(typename _Ptr2::template rebind<_Up2>*);
template<typename, typename>
static constexpr false_type
_S_chk(...);
public:
using __type = decltype(_S_chk<_Ptr, _Up>(nullptr));
};
template<typename _Tp, typename _Up,
bool = __ptrtr_rebind_helper<_Tp, _Up>::__type::value>
struct __ptrtr_rebind;
template<typename _Tp, typename _Up>
struct __ptrtr_rebind<_Tp, _Up, true>
{
typedef typename _Tp::template rebind<_Up> __type;
};
template<template<typename, typename...> class _SomePtr, typename _Up,
typename _Tp, typename... _Args>
struct __ptrtr_rebind<_SomePtr<_Tp, _Args...>, _Up, false>
{
typedef _SomePtr<_Up, _Args...> __type;
};
template<typename _Tp, typename = typename remove_cv<_Tp>::type>
struct __ptrtr_not_void
{
typedef _Tp __type;
};
template<typename _Tp>
struct __ptrtr_not_void<_Tp, void>
{
struct __type { };
};
template<typename _Ptr>
class __ptrtr_pointer_to
{
typedef typename __ptrtr_elt_type<_Ptr>::__type __orig_type;
typedef typename __ptrtr_not_void<__orig_type>::__type __element_type;
public:
static _Ptr pointer_to(__element_type& __e)
;
};
template<typename _Ptr>
struct pointer_traits : __ptrtr_pointer_to<_Ptr>
{
typedef _Ptr pointer;
typedef typename __ptrtr_elt_type<_Ptr>::__type element_type;
typedef typename __ptrtr_diff_type<_Ptr>::__type difference_type;
template<typename _Up>
using rebind = typename __ptrtr_rebind<_Ptr, _Up>::__type;
};
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(typename __ptrtr_not_void<element_type>::__type& __r) noexcept
{ return std::addressof(__r); }
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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;
reverse_iterator() ;
explicit
reverse_iterator(iterator_type __x) ;
reverse_iterator(const reverse_iterator& __x) ;
template<typename _Iter>
reverse_iterator(const reverse_iterator<_Iter>& __x) ;
iterator_type
base() const
;
reference
operator*() const
;
pointer
operator->() const
;
reverse_iterator&
operator++()
;
reverse_iterator
operator++(int)
;
reverse_iterator&
operator--()
;
reverse_iterator
operator--(int)
;
reverse_iterator
operator+(difference_type __n) const
;
reverse_iterator&
operator+=(difference_type __n)
;
reverse_iterator
operator-(difference_type __n) const
;
reverse_iterator&
operator-=(difference_type __n)
;
reference
operator[](difference_type __n) const
;
};
template<typename _Iterator>
bool
operator==(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
bool
operator<(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
bool
operator!=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
bool
operator>(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
bool
operator<=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
bool
operator>=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
typename reverse_iterator<_Iterator>::difference_type
operator-(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
reverse_iterator<_Iterator>
operator+(typename reverse_iterator<_Iterator>::difference_type __n,
const reverse_iterator<_Iterator>& __x)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator==(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator<(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator!=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator>(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator<=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator>=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
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 _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) ;
back_insert_iterator&
operator=(const typename _Container::value_type& __value)
;
back_insert_iterator&
operator=(typename _Container::value_type&& __value)
;
back_insert_iterator&
operator*()
;
back_insert_iterator&
operator++()
;
back_insert_iterator
operator++(int)
;
};
template<typename _Container>
back_insert_iterator<_Container>
back_inserter(_Container& __x)
;
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) ;
front_insert_iterator&
operator=(const typename _Container::value_type& __value)
;
front_insert_iterator&
operator=(typename _Container::value_type&& __value)
;
front_insert_iterator&
operator*()
;
front_insert_iterator&
operator++()
;
front_insert_iterator
operator++(int)
;
};
template<typename _Container>
front_insert_iterator<_Container>
front_inserter(_Container& __x)
;
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) ;
insert_iterator&
operator=(const typename _Container::value_type& __value)
;
insert_iterator&
operator=(typename _Container::value_type&& __value)
;
insert_iterator&
operator*()
;
insert_iterator&
operator++()
;
insert_iterator&
operator++(int)
;
};
template<typename _Container, typename _Iterator>
insert_iterator<_Container>
inserter(_Container& __x, _Iterator __i)
;
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
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; }
};
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>
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() ;
explicit
move_iterator(iterator_type __i) ;
template<typename _Iter>
move_iterator(const move_iterator<_Iter>& __i) ;
iterator_type
base() const
;
reference
operator*() const
;
pointer
operator->() const
;
move_iterator&
operator++()
;
move_iterator
operator++(int)
;
move_iterator&
operator--()
;
move_iterator
operator--(int)
;
move_iterator
operator+(difference_type __n) const
;
move_iterator&
operator+=(difference_type __n)
;
move_iterator
operator-(difference_type __n) const
;
move_iterator&
operator-=(difference_type __n)
;
reference
operator[](difference_type __n) const
;
};
template<typename _IteratorL, typename _IteratorR>
bool
operator==(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
;
template<typename _Iterator>
bool
operator==(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator!=(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
;
template<typename _Iterator>
bool
operator!=(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator<(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
;
template<typename _Iterator>
bool
operator<(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator<=(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
;
template<typename _Iterator>
bool
operator<=(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator>(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
;
template<typename _Iterator>
bool
operator>(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator>=(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
;
template<typename _Iterator>
bool
operator>=(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __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 auto
operator-(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
-> decltype(__x.base() - __y.base())
{ return __x.base() - __y.base(); }
template<typename _Iterator>
move_iterator<_Iterator>
operator+(typename move_iterator<_Iterator>::difference_type __n,
const move_iterator<_Iterator>& __x)
;
template<typename _Iterator>
move_iterator<_Iterator>
make_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); }
}
#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)
#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
;
};
_Iter_less_iter
__iter_less_iter()
;
struct _Iter_less_val
{
template<typename _Iterator, typename _Value>
bool
operator()(_Iterator __it, _Value& __val) const
;
};
_Iter_less_val
__iter_less_val()
;
_Iter_less_val
__iter_comp_val(_Iter_less_iter)
;
struct _Val_less_iter
{
template<typename _Value, typename _Iterator>
bool
operator()(_Value& __val, _Iterator __it) const
;
};
_Val_less_iter
__val_less_iter()
;
_Val_less_iter
__val_comp_iter(_Iter_less_iter)
;
struct _Iter_equal_to_iter
{
template<typename _Iterator1, typename _Iterator2>
bool
operator()(_Iterator1 __it1, _Iterator2 __it2) const
;
};
_Iter_equal_to_iter
__iter_equal_to_iter()
;
struct _Iter_equal_to_val
{
template<typename _Iterator, typename _Value>
bool
operator()(_Iterator __it, _Value& __val) const
;
};
_Iter_equal_to_val
__iter_equal_to_val()
;
_Iter_equal_to_val
__iter_comp_val(_Iter_equal_to_iter)
;
template<typename _Compare>
struct _Iter_comp_iter
{
_Compare _M_comp;
_Iter_comp_iter(_Compare __comp)
;
template<typename _Iterator1, typename _Iterator2>
bool
operator()(_Iterator1 __it1, _Iterator2 __it2)
;
};
template<typename _Compare>
_Iter_comp_iter<_Compare>
__iter_comp_iter(_Compare __comp)
;
template<typename _Compare>
struct _Iter_comp_val
{
_Compare _M_comp;
_Iter_comp_val(_Compare __comp)
;
template<typename _Iterator, typename _Value>
bool
operator()(_Iterator __it, _Value& __val)
;
};
template<typename _Compare>
_Iter_comp_val<_Compare>
__iter_comp_val(_Compare __comp)
;
template<typename _Compare>
_Iter_comp_val<_Compare>
__iter_comp_val(_Iter_comp_iter<_Compare> __comp)
;
template<typename _Compare>
struct _Val_comp_iter
{
_Compare _M_comp;
_Val_comp_iter(_Compare __comp)
;
template<typename _Value, typename _Iterator>
bool
operator()(_Value& __val, _Iterator __it)
;
};
template<typename _Compare>
_Val_comp_iter<_Compare>
__val_comp_iter(_Compare __comp)
;
template<typename _Compare>
_Val_comp_iter<_Compare>
__val_comp_iter(_Iter_comp_iter<_Compare> __comp)
;
template<typename _Value>
struct _Iter_equals_val
{
_Value& _M_value;
_Iter_equals_val(_Value& __value)
;
template<typename _Iterator>
bool
operator()(_Iterator __it)
;
};
template<typename _Value>
_Iter_equals_val<_Value>
__iter_equals_val(_Value& __val)
;
template<typename _Iterator1>
struct _Iter_equals_iter
{
typename std::iterator_traits<_Iterator1>::reference _M_ref;
_Iter_equals_iter(_Iterator1 __it1)
;
template<typename _Iterator2>
bool
operator()(_Iterator2 __it2)
;
};
template<typename _Iterator>
_Iter_equals_iter<_Iterator>
__iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
;
template<typename _Predicate>
struct _Iter_pred
{
_Predicate _M_pred;
_Iter_pred(_Predicate __pred)
;
template<typename _Iterator>
bool
operator()(_Iterator __it)
;
};
template<typename _Predicate>
_Iter_pred<_Predicate>
__pred_iter(_Predicate __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)
;
template<typename _Iterator>
bool
operator()(_Iterator __it)
;
};
template<typename _Compare, typename _Value>
_Iter_comp_to_val<_Compare, _Value>
__iter_comp_val(_Compare __comp, _Value &__val)
;
template<typename _Compare, typename _Iterator1>
struct _Iter_comp_to_iter
{
_Compare _M_comp;
typename std::iterator_traits<_Iterator1>::reference _M_ref;
_Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
;
template<typename _Iterator2>
bool
operator()(_Iterator2 __it2)
;
};
template<typename _Compare, typename _Iterator>
_Iter_comp_to_iter<_Compare, _Iterator>
__iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
;
template<typename _Predicate>
struct _Iter_negate
{
_Predicate _M_pred;
_Iter_negate(_Predicate __pred)
;
template<typename _Iterator>
bool
operator()(_Iterator __it)
;
};
template<typename _Predicate>
_Iter_negate<_Predicate>
__negate(_Iter_pred<_Predicate> __pred)
;
}
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _ForwardIterator1, typename _ForwardIterator2>
void
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
;
template<typename _ForwardIterator1, typename _ForwardIterator2>
_ForwardIterator2
swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2)
;
template<typename _Tp>
const _Tp&
min(const _Tp& __a, const _Tp& __b)
;
template<typename _Tp>
const _Tp&
max(const _Tp& __a, const _Tp& __b)
;
template<typename _Tp, typename _Compare>
const _Tp&
min(const _Tp& __a, const _Tp& __b, _Compare __comp)
;
template<typename _Tp, typename _Compare>
const _Tp&
max(const _Tp& __a, const _Tp& __b, _Compare __comp)
;
template<typename _Iterator>
struct _Niter_base
: _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value>
{ };
template<typename _Iterator>
typename _Niter_base<_Iterator>::iterator_type
__niter_base(_Iterator __it)
;
template<typename _Iterator>
struct _Miter_base
: _Iter_base<_Iterator, __is_move_iterator<_Iterator>::__value>
{ };
template<typename _Iterator>
typename _Miter_base<_Iterator>::iterator_type
__miter_base(_Iterator __it)
;
template<bool, bool, typename>
struct __copy_move
{
template<typename _II, typename _OI>
static _OI
__copy_m(_II __first, _II __last, _OI __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)
;
};
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)
;
};
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)
;
};
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)
;
};
template<bool _IsMove, typename _II, typename _OI>
_OI
__copy_move_a(_II __first, _II __last, _OI __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>
_OI
__copy_move_a2(_II __first, _II __last, _OI __result)
;
template<typename _II, typename _OI>
_OI
copy(_II __first, _II __last, _OI __result)
;
template<typename _II, typename _OI>
_OI
move(_II __first, _II __last, _OI __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)
;
};
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)
;
};
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)
;
};
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)
;
};
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)
;
};
template<bool _IsMove, typename _BI1, typename _BI2>
_BI2
__copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
;
template<bool _IsMove, typename _BI1, typename _BI2>
_BI2
__copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
;
template<typename _BI1, typename _BI2>
_BI2
copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
;
template<typename _BI1, typename _BI2>
_BI2
move_backward(_BI1 __first, _BI1 __last, _BI2 __result)
;
#define _GLIBCXX_MOVE_BACKWARD3(_Tp,_Up,_Vp) std::move_backward(_Tp, _Up, _Vp)
template<typename _ForwardIterator, typename _Tp>
typename
__gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
__fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __value)
;
template<typename _ForwardIterator, typename _Tp>
typename
__gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
__fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __value)
;
template<typename _Tp>
typename
__gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
__fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)
;
template<typename _ForwardIterator, typename _Tp>
void
fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
;
template<typename _OutputIterator, typename _Size, typename _Tp>
typename
__gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
;
template<typename _OutputIterator, typename _Size, typename _Tp>
typename
__gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
;
template<typename _Size, typename _Tp>
typename
__gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
__fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
;
template<typename _OI, typename _Size, typename _Tp>
_OI
fill_n(_OI __first, _Size __n, const _Tp& __value)
;
template<bool _BoolType>
struct __equal
{
template<typename _II1, typename _II2>
static bool
equal(_II1 __first1, _II1 __last1, _II2 __first2)
;
};
template<>
struct __equal<true>
{
template<typename _Tp>
static bool
equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
;
};
template<typename _II1, typename _II2>
bool
__equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
;
template<typename, typename>
struct __lc_rai
{
template<typename _II1, typename _II2>
static _II1
__newlast1(_II1, _II1 __last1, _II2, _II2)
;
template<typename _II>
static bool
__cnd2(_II __first, _II __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)
;
template<typename _RAI>
static bool
__cnd2(_RAI, _RAI)
;
};
template<typename _II1, typename _II2, typename _Compare>
bool
__lexicographical_compare_impl(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2,
_Compare __comp)
;
template<bool _BoolType>
struct __lexicographical_compare
{
template<typename _II1, typename _II2>
static bool __lc(_II1, _II1, _II2, _II2);
};
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)
;
};
template<typename _II1, typename _II2>
bool
__lexicographical_compare_aux(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
_ForwardIterator
__lower_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
;
template<typename _ForwardIterator, typename _Tp>
_ForwardIterator
lower_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __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); }
template<typename _II1, typename _II2>
bool
equal(_II1 __first1, _II1 __last1, _II2 __first2)
;
template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
bool
equal(_IIter1 __first1, _IIter1 __last1,
_IIter2 __first2, _BinaryPredicate __binary_pred)
;
template<typename _II1, typename _II2>
bool
lexicographical_compare(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2)
;
template<typename _II1, typename _II2, typename _Compare>
bool
lexicographical_compare(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2, _Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _BinaryPredicate>
pair<_InputIterator1, _InputIterator2>
__mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _BinaryPredicate __binary_pred)
;
template<typename _InputIterator1, typename _InputIterator2>
pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _BinaryPredicate>
pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _BinaryPredicate __binary_pred)
;
}
#define _GLIBCXX_POSTYPES_H 1
#define _WCHAR_H 1
#define __need___FILE
#define __need_FILE
struct _IO_FILE;
typedef struct _IO_FILE FILE;
#define __FILE_defined 1
#undef __need_FILE
typedef struct _IO_FILE __FILE;
#define ____FILE_defined 1
#undef __need___FILE
#define __need___va_list
#undef __need___va_list
#define __GNUC_VA_LIST
typedef __builtin_va_list __gnuc_va_list;
#define _BITS_WCHAR_H 1
#define __WCHAR_MAX __WCHAR_MAX__
#define __WCHAR_MIN __WCHAR_MIN__
#define __need_size_t
#define __need_wchar_t
#define __need_NULL
#undef __need_wint_t
#define __need_wint_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#define _WINT_T
typedef unsigned int wint_t;
#undef __need_wint_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define __CORRECT_ISO_CPP_WCHAR_H_PROTO
#define ____mbstate_t_defined 1
typedef struct
{
int __count;
union
{
unsigned int __wch;
char __wchb[4];
} __value;
} __mbstate_t;
#undef __need_mbstate_t
typedef __mbstate_t mbstate_t;
#define __mbstate_t_defined 1
#define WCHAR_MIN __WCHAR_MIN
#define WCHAR_MAX __WCHAR_MAX
#define WEOF (0xffffffffu)
extern "C" {
struct tm;
extern wchar_t *wcscpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src) throw ();
extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw ();
extern wchar_t *wcscat (wchar_t *__restrict __dest,
const wchar_t *__restrict __src) throw ();
extern wchar_t *wcsncat (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw ();
extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
throw () __attribute__ ((__pure__));
extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw () __attribute__ ((__pure__));
extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw ();
extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2,
size_t __n) throw ();
extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
__locale_t __loc) throw ();
extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
size_t __n, __locale_t __loc) throw ();
extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw ();
extern size_t wcsxfrm (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n) throw ();
extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2,
__locale_t __loc) throw ();
extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2,
size_t __n, __locale_t __loc) throw ();
extern wchar_t *wcsdup (const wchar_t *__s) throw () __attribute__ ((__malloc__));
extern "C++" wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcschr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcschr") __attribute__ ((__pure__));
extern "C++" wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcsrchr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcsrchr") __attribute__ ((__pure__));
extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc)
throw () __attribute__ ((__pure__));
extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject)
throw () __attribute__ ((__pure__));
extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept)
throw () __attribute__ ((__pure__));
extern "C++" wchar_t *wcspbrk (wchar_t *__wcs, const wchar_t *__accept)
throw () __asm ("wcspbrk") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcspbrk (const wchar_t *__wcs,
const wchar_t *__accept)
throw () __asm ("wcspbrk") __attribute__ ((__pure__));
extern "C++" wchar_t *wcsstr (wchar_t *__haystack, const wchar_t *__needle)
throw () __asm ("wcsstr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcsstr (const wchar_t *__haystack,
const wchar_t *__needle)
throw () __asm ("wcsstr") __attribute__ ((__pure__));
extern wchar_t *wcstok (wchar_t *__restrict __s,
const wchar_t *__restrict __delim,
wchar_t **__restrict __ptr) throw ();
extern size_t wcslen (const wchar_t *__s) throw () __attribute__ ((__pure__));
extern "C++" wchar_t *wcswcs (wchar_t *__haystack, const wchar_t *__needle)
throw () __asm ("wcswcs") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcswcs (const wchar_t *__haystack,
const wchar_t *__needle)
throw () __asm ("wcswcs") __attribute__ ((__pure__));
extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
throw () __attribute__ ((__pure__));
extern "C++" wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n)
throw () __asm ("wmemchr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wmemchr (const wchar_t *__s, wchar_t __c,
size_t __n)
throw () __asm ("wmemchr") __attribute__ ((__pure__));
extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw () __attribute__ ((__pure__));
extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n) throw ();
extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw ();
extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();
extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n)
throw ();
extern wint_t btowc (int __c) throw ();
extern int wctob (wint_t __c) throw ();
extern int mbsinit (const mbstate_t *__ps) throw () __attribute__ ((__pure__));
extern size_t mbrtowc (wchar_t *__restrict __pwc,
const char *__restrict __s, size_t __n,
mbstate_t *__restrict __p) throw ();
extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
mbstate_t *__restrict __ps) throw ();
extern size_t __mbrlen (const char *__restrict __s, size_t __n,
mbstate_t *__restrict __ps) throw ();
extern size_t mbrlen (const char *__restrict __s, size_t __n,
mbstate_t *__restrict __ps) throw ();
extern size_t mbsrtowcs (wchar_t *__restrict __dst,
const char **__restrict __src, size_t __len,
mbstate_t *__restrict __ps) throw ();
extern size_t wcsrtombs (char *__restrict __dst,
const wchar_t **__restrict __src, size_t __len,
mbstate_t *__restrict __ps) throw ();
extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
const char **__restrict __src, size_t __nmc,
size_t __len, mbstate_t *__restrict __ps) throw ();
extern size_t wcsnrtombs (char *__restrict __dst,
const wchar_t **__restrict __src,
size_t __nwc, size_t __len,
mbstate_t *__restrict __ps) throw ();
extern int wcwidth (wchar_t __c) throw ();
extern int wcswidth (const wchar_t *__s, size_t __n) throw ();
extern double wcstod (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern float wcstof (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern long double wcstold (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern long int wcstol (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base) throw ();
extern unsigned long int wcstoul (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
__extension__
extern long long int wcstoll (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
__extension__
extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base) throw ();
__extension__
extern long long int wcstoq (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
__extension__
extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base) throw ();
extern long int wcstol_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base,
__locale_t __loc) throw ();
extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, __locale_t __loc) throw ();
__extension__
extern long long int wcstoll_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, __locale_t __loc) throw ();
__extension__
extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, __locale_t __loc)
throw ();
extern double wcstod_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, __locale_t __loc)
throw ();
extern float wcstof_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, __locale_t __loc)
throw ();
extern long double wcstold_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
__locale_t __loc) throw ();
extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src) throw ();
extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw ();
extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();
extern int fwide (__FILE *__fp, int __mode) throw ();
extern int fwprintf (__FILE *__restrict __stream,
const wchar_t *__restrict __format, ...)
;
extern int wprintf (const wchar_t *__restrict __format, ...)
;
extern int swprintf (wchar_t *__restrict __s, size_t __n,
const wchar_t *__restrict __format, ...)
throw () ;
extern int vfwprintf (__FILE *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vwprintf (const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vswprintf (wchar_t *__restrict __s, size_t __n,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
throw () ;
extern int fwscanf (__FILE *__restrict __stream,
const wchar_t *__restrict __format, ...)
;
extern int wscanf (const wchar_t *__restrict __format, ...)
;
extern int swscanf (const wchar_t *__restrict __s,
const wchar_t *__restrict __format, ...)
throw () ;
extern int vfwscanf (__FILE *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vwscanf (const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vswscanf (const wchar_t *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
throw () ;
extern wint_t fgetwc (__FILE *__stream);
extern wint_t getwc (__FILE *__stream);
extern wint_t getwchar (void);
extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
extern wint_t putwc (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar (wchar_t __wc);
extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
__FILE *__restrict __stream);
extern int fputws (const wchar_t *__restrict __ws,
__FILE *__restrict __stream);
extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
extern wint_t getwc_unlocked (__FILE *__stream);
extern wint_t getwchar_unlocked (void);
extern wint_t fgetwc_unlocked (__FILE *__stream);
extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar_unlocked (wchar_t __wc);
extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
__FILE *__restrict __stream);
extern int fputws_unlocked (const wchar_t *__restrict __ws,
__FILE *__restrict __stream);
extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
const wchar_t *__restrict __format,
const struct tm *__restrict __tp) throw ();
extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
const wchar_t *__restrict __format,
const struct tm *__restrict __tp,
__locale_t __loc) throw ();
}
#undef __need_mbstate_t
#undef __need_wint_t
#define _GLIBCXX_CWCHAR 1
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;
}
#undef wcstold
#undef wcstoll
#undef wcstoull
namespace __gnu_cxx
{
using ::wcstold;
using ::wcstoll;
using ::wcstoull;
}
namespace std
{
using ::__gnu_cxx::wcstold;
using ::__gnu_cxx::wcstoll;
using ::__gnu_cxx::wcstoull;
}
namespace std
{
using std::wcstof;
using std::vfwscanf;
using std::vswscanf;
using std::vwscanf;
using std::wcstold;
using std::wcstoll;
using std::wcstoull;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
typedef long streamoff;
typedef ptrdiff_t streamsize;
template<typename _StateT>
class fpos
{
private:
streamoff _M_off;
_StateT _M_state;
public:
fpos() ;
fpos(streamoff __off) ;
operator streamoff() const ;
void
state(_StateT __st)
;
_StateT
state() const
;
fpos&
operator+=(streamoff __off)
;
fpos&
operator-=(streamoff __off)
;
fpos
operator+(streamoff __off) const
;
fpos
operator-(streamoff __off) const
;
streamoff
operator-(const fpos& __other) const
;
};
template<typename _StateT>
bool
operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
;
template<typename _StateT>
bool
operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
;
typedef fpos<mbstate_t> streampos;
typedef fpos<mbstate_t> wstreampos;
typedef fpos<mbstate_t> u16streampos;
typedef fpos<mbstate_t> u32streampos;
}
#undef __need_mbstate_t
#undef __need_wint_t
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
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;
};
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)
;
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()); }
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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)
{ 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)
{ 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)
{ return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n)); }
static char_type*
copy(char_type* __s1, const char_type* __s2, size_t __n)
{ return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n)); }
static char_type*
assign(char_type* __s, size_t __n, char_type __a)
{ return static_cast<char_type*>(__builtin_memset(__s, __a, __n)); }
static constexpr char_type
to_char_type(const int_type& __c) noexcept
{ return static_cast<char_type>(__c); }
static constexpr int_type
to_int_type(const char_type& __c) noexcept
{ return static_cast<int_type>(static_cast<unsigned char>(__c)); }
static constexpr bool
eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
{ return __c1 == __c2; }
static constexpr int_type
eof() noexcept
{ return static_cast<int_type>(-1); }
static constexpr int_type
not_eof(const int_type& __c) noexcept
{ return (__c == eof()) ? 0 : __c; }
};
template<>
struct char_traits<wchar_t>
{
typedef wchar_t char_type;
typedef wint_t int_type;
typedef streamoff off_type;
typedef wstreampos pos_type;
typedef mbstate_t state_type;
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)
{ 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)
{ return wmemchr(__s, __a, __n); }
static char_type*
move(char_type* __s1, const char_type* __s2, size_t __n)
{ return wmemmove(__s1, __s2, __n); }
static char_type*
copy(char_type* __s1, const char_type* __s2, size_t __n)
{ return wmemcpy(__s1, __s2, __n); }
static char_type*
assign(char_type* __s, size_t __n, char_type __a)
{ return wmemset(__s, __a, __n); }
static constexpr char_type
to_char_type(const int_type& __c) noexcept
{ return char_type(__c); }
static constexpr int_type
to_int_type(const char_type& __c) noexcept
{ return int_type(__c); }
static constexpr bool
eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
{ return __c1 == __c2; }
static constexpr int_type
eof() noexcept
{ return static_cast<int_type>((0xffffffffu)); }
static constexpr int_type
not_eof(const int_type& __c) noexcept
{ return eq_int_type(__c, eof()) ? 0 : __c; }
};
}
#define _GLIBCXX_CSTDINT 1
#undef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS
#undef __STDC_CONSTANT_MACROS
#define __STDC_CONSTANT_MACROS
#define _STDINT_H 1
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
typedef unsigned char uint8_t;
typedef unsigned short int uint16_t;
typedef unsigned int uint32_t;
#define __uint32_t_defined
typedef unsigned long int uint64_t;
typedef signed char int_least8_t;
typedef short int int_least16_t;
typedef int int_least32_t;
typedef long int int_least64_t;
typedef unsigned char uint_least8_t;
typedef unsigned short int uint_least16_t;
typedef unsigned int uint_least32_t;
typedef unsigned long int uint_least64_t;
typedef signed char int_fast8_t;
typedef long int int_fast16_t;
typedef long int int_fast32_t;
typedef long int int_fast64_t;
typedef unsigned char uint_fast8_t;
typedef unsigned long int uint_fast16_t;
typedef unsigned long int uint_fast32_t;
typedef unsigned long int uint_fast64_t;
typedef unsigned long int uintptr_t;
typedef long int intmax_t;
typedef unsigned long int uintmax_t;
#define __INT64_C(c) c ## L
#define __UINT64_C(c) c ## UL
#define INT8_MIN (-128)
#define INT16_MIN (-32767-1)
#define INT32_MIN (-2147483647-1)
#define INT64_MIN (-__INT64_C(9223372036854775807)-1)
#define INT8_MAX (127)
#define INT16_MAX (32767)
#define INT32_MAX (2147483647)
#define INT64_MAX (__INT64_C(9223372036854775807))
#define UINT8_MAX (255)
#define UINT16_MAX (65535)
#define UINT32_MAX (4294967295U)
#define UINT64_MAX (__UINT64_C(18446744073709551615))
#define INT_LEAST8_MIN (-128)
#define INT_LEAST16_MIN (-32767-1)
#define INT_LEAST32_MIN (-2147483647-1)
#define INT_LEAST64_MIN (-__INT64_C(9223372036854775807)-1)
#define INT_LEAST8_MAX (127)
#define INT_LEAST16_MAX (32767)
#define INT_LEAST32_MAX (2147483647)
#define INT_LEAST64_MAX (__INT64_C(9223372036854775807))
#define UINT_LEAST8_MAX (255)
#define UINT_LEAST16_MAX (65535)
#define UINT_LEAST32_MAX (4294967295U)
#define UINT_LEAST64_MAX (__UINT64_C(18446744073709551615))
#define INT_FAST8_MIN (-128)
#define INT_FAST16_MIN (-9223372036854775807L-1)
#define INT_FAST32_MIN (-9223372036854775807L-1)
#define INT_FAST64_MIN (-__INT64_C(9223372036854775807)-1)
#define INT_FAST8_MAX (127)
#define INT_FAST16_MAX (9223372036854775807L)
#define INT_FAST32_MAX (9223372036854775807L)
#define INT_FAST64_MAX (__INT64_C(9223372036854775807))
#define UINT_FAST8_MAX (255)
#define UINT_FAST16_MAX (18446744073709551615UL)
#define UINT_FAST32_MAX (18446744073709551615UL)
#define UINT_FAST64_MAX (__UINT64_C(18446744073709551615))
#define INTPTR_MIN (-9223372036854775807L-1)
#define INTPTR_MAX (9223372036854775807L)
#define UINTPTR_MAX (18446744073709551615UL)
#define INTMAX_MIN (-__INT64_C(9223372036854775807)-1)
#define INTMAX_MAX (__INT64_C(9223372036854775807))
#define UINTMAX_MAX (__UINT64_C(18446744073709551615))
#define PTRDIFF_MIN (-9223372036854775807L-1)
#define PTRDIFF_MAX (9223372036854775807L)
#define SIG_ATOMIC_MIN (-2147483647-1)
#define SIG_ATOMIC_MAX (2147483647)
#define SIZE_MAX (18446744073709551615UL)
#define WINT_MIN (0u)
#define WINT_MAX (4294967295u)
#define INT8_C(c) c
#define INT16_C(c) c
#define INT32_C(c) c
#define INT64_C(c) c ## L
#define UINT8_C(c) c
#define UINT16_C(c) c
#define UINT32_C(c) c ## U
#define UINT64_C(c) c ## UL
#define INTMAX_C(c) c ## L
#define UINTMAX_C(c) c ## UL
#define _GCC_WRAP_STDINT_H
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;
}
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)
{
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)
{
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)
{
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)
{
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; }
};
}
#define _ALLOCATOR_H 1
#define _GLIBCXX_CXX_ALLOCATOR_H 1
#define _MT_ALLOCATOR_H 1
#define _NEW
#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 { };
extern const nothrow_t nothrow;
typedef void (*new_handler)();
new_handler set_new_handler(new_handler) throw();
new_handler get_new_handler() noexcept;
}
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__));
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 { }
}
#pragma GCC visibility pop
#define _GLIBCXX_ATOMICITY_H 1
#define _GLIBCXX_GCC_GTHR_H
#pragma GCC visibility push(default)
#define _GLIBCXX_GTHREAD_USE_WEAK 1
#define _GLIBCXX_GCC_GTHR_POSIX_H
#define __GTHREADS 1
#define __GTHREADS_CXX0X 1
#define _PTHREAD_H 1
#define _SCHED_H 1
#define __need_size_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define __need_time_t
#define __need_timespec
#undef __need_clock_t
#undef __need_time_t
#undef __clockid_time_t
#undef __need_timer_t
#undef __need_timespec
#define SCHED_OTHER 0
#define SCHED_FIFO 1
#define SCHED_RR 2
#define SCHED_BATCH 3
#define SCHED_IDLE 5
#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_NEWUTS 0x04000000
#define CLONE_NEWIPC 0x08000000
#define CLONE_NEWUSER 0x10000000
#define CLONE_NEWPID 0x20000000
#define CLONE_NEWNET 0x40000000
#define CLONE_IO 0x80000000
struct sched_param
{
int __sched_priority;
};
extern "C" {
extern int clone (int (*__fn) (void *__arg), void *__child_stack,
int __flags, void *__arg, ...) throw ();
extern int unshare (int __flags) throw ();
extern int sched_getcpu (void) throw ();
extern int setns (int __fd, int __nstype) throw ();
}
#define __defined_schedparam 1
struct __sched_param
{
int __sched_priority;
};
#undef __need_schedparam
#define __cpu_set_t_defined
#define __CPU_SETSIZE 1024
#define __NCPUBITS (8 * sizeof (__cpu_mask))
typedef unsigned long int __cpu_mask;
#define __CPUELT(cpu) ((cpu) / __NCPUBITS)
#define __CPUMASK(cpu) ((__cpu_mask) 1 << ((cpu) % __NCPUBITS))
typedef struct
{
__cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
} cpu_set_t;
#define __CPU_ZERO_S(setsize,cpusetp) do __builtin_memset (cpusetp, '\0', setsize); while (0)
#define __CPU_SET_S(cpu,setsize,cpusetp) (__extension__ ({ size_t __cpu = (cpu); __cpu / 8 < (setsize) ? (((__cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] |= __CPUMASK (__cpu)) : 0; }))
#define __CPU_CLR_S(cpu,setsize,cpusetp) (__extension__ ({ size_t __cpu = (cpu); __cpu / 8 < (setsize) ? (((__cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] &= ~__CPUMASK (__cpu)) : 0; }))
#define __CPU_ISSET_S(cpu,setsize,cpusetp) (__extension__ ({ size_t __cpu = (cpu); __cpu / 8 < (setsize) ? ((((const __cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] & __CPUMASK (__cpu))) != 0 : 0; }))
#define __CPU_COUNT_S(setsize,cpusetp) __sched_cpucount (setsize, cpusetp)
#define __CPU_EQUAL_S(setsize,cpusetp1,cpusetp2) (__builtin_memcmp (cpusetp1, cpusetp2, setsize) == 0)
#define __CPU_OP_S(setsize,destset,srcset1,srcset2,op) (__extension__ ({ cpu_set_t *__dest = (destset); const __cpu_mask *__arr1 = (srcset1)->__bits; const __cpu_mask *__arr2 = (srcset2)->__bits; size_t __imax = (setsize) / sizeof (__cpu_mask); size_t __i; for (__i = 0; __i < __imax; ++__i) ((__cpu_mask *) __dest->__bits)[__i] = __arr1[__i] op __arr2[__i]; __dest; }))
#define __CPU_ALLOC_SIZE(count) ((((count) + __NCPUBITS - 1) / __NCPUBITS) * sizeof (__cpu_mask))
#define __CPU_ALLOC(count) __sched_cpualloc (count)
#define __CPU_FREE(cpuset) __sched_cpufree (cpuset)
extern "C" {
extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
throw ();
extern cpu_set_t *__sched_cpualloc (size_t __count) throw () ;
extern void __sched_cpufree (cpu_set_t *__set) throw ();
}
#define sched_priority __sched_priority
extern "C" {
extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
throw ();
extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();
extern int sched_setscheduler (__pid_t __pid, int __policy,
const struct sched_param *__param) throw ();
extern int sched_getscheduler (__pid_t __pid) throw ();
extern int sched_yield (void) throw ();
extern int sched_get_priority_max (int __algorithm) throw ();
extern int sched_get_priority_min (int __algorithm) throw ();
extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();
#define CPU_SETSIZE __CPU_SETSIZE
#define CPU_SET(cpu,cpusetp) __CPU_SET_S (cpu, sizeof (cpu_set_t), cpusetp)
#define CPU_CLR(cpu,cpusetp) __CPU_CLR_S (cpu, sizeof (cpu_set_t), cpusetp)
#define CPU_ISSET(cpu,cpusetp) __CPU_ISSET_S (cpu, sizeof (cpu_set_t), cpusetp)
#define CPU_ZERO(cpusetp) __CPU_ZERO_S (sizeof (cpu_set_t), cpusetp)
#define CPU_COUNT(cpusetp) __CPU_COUNT_S (sizeof (cpu_set_t), cpusetp)
#define CPU_SET_S(cpu,setsize,cpusetp) __CPU_SET_S (cpu, setsize, cpusetp)
#define CPU_CLR_S(cpu,setsize,cpusetp) __CPU_CLR_S (cpu, setsize, cpusetp)
#define CPU_ISSET_S(cpu,setsize,cpusetp) __CPU_ISSET_S (cpu, setsize, cpusetp)
#define CPU_ZERO_S(setsize,cpusetp) __CPU_ZERO_S (setsize, cpusetp)
#define CPU_COUNT_S(setsize,cpusetp) __CPU_COUNT_S (setsize, cpusetp)
#define CPU_EQUAL(cpusetp1,cpusetp2) __CPU_EQUAL_S (sizeof (cpu_set_t), cpusetp1, cpusetp2)
#define CPU_EQUAL_S(setsize,cpusetp1,cpusetp2) __CPU_EQUAL_S (setsize, cpusetp1, cpusetp2)
#define CPU_AND(destset,srcset1,srcset2) __CPU_OP_S (sizeof (cpu_set_t), destset, srcset1, srcset2, &)
#define CPU_OR(destset,srcset1,srcset2) __CPU_OP_S (sizeof (cpu_set_t), destset, srcset1, srcset2, |)
#define CPU_XOR(destset,srcset1,srcset2) __CPU_OP_S (sizeof (cpu_set_t), destset, srcset1, srcset2, ^)
#define CPU_AND_S(setsize,destset,srcset1,srcset2) __CPU_OP_S (setsize, destset, srcset1, srcset2, &)
#define CPU_OR_S(setsize,destset,srcset1,srcset2) __CPU_OP_S (setsize, destset, srcset1, srcset2, |)
#define CPU_XOR_S(setsize,destset,srcset1,srcset2) __CPU_OP_S (setsize, destset, srcset1, srcset2, ^)
#define CPU_ALLOC_SIZE(count) __CPU_ALLOC_SIZE (count)
#define CPU_ALLOC(count) __CPU_ALLOC (count)
#define CPU_FREE(cpuset) __CPU_FREE (cpuset)
extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
const cpu_set_t *__cpuset) throw ();
extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
cpu_set_t *__cpuset) throw ();
}
#define _TIME_H 1
extern "C" {
#define __need_size_t
#define __need_NULL
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define _BITS_TIME_H 1
#define CLOCKS_PER_SEC 1000000l
#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 TIMER_ABSTIME 1
#define _BITS_TIMEX_H 1
struct timex
{
unsigned int modes;
__syscall_slong_t offset;
__syscall_slong_t freq;
__syscall_slong_t maxerror;
__syscall_slong_t esterror;
int status;
__syscall_slong_t constant;
__syscall_slong_t precision;
__syscall_slong_t tolerance;
struct timeval time;
__syscall_slong_t tick;
__syscall_slong_t ppsfreq;
__syscall_slong_t jitter;
int shift;
__syscall_slong_t stabil;
__syscall_slong_t jitcnt;
__syscall_slong_t calcnt;
__syscall_slong_t errcnt;
__syscall_slong_t stbcnt;
int tai;
int :32; int :32; int :32; int :32;
int :32; int :32; int :32; int :32;
int :32; int :32; int :32;
};
#define ADJ_OFFSET 0x0001
#define ADJ_FREQUENCY 0x0002
#define ADJ_MAXERROR 0x0004
#define ADJ_ESTERROR 0x0008
#define ADJ_STATUS 0x0010
#define ADJ_TIMECONST 0x0020
#define ADJ_TAI 0x0080
#define ADJ_MICRO 0x1000
#define ADJ_NANO 0x2000
#define ADJ_TICK 0x4000
#define ADJ_OFFSET_SINGLESHOT 0x8001
#define ADJ_OFFSET_SS_READ 0xa001
#define MOD_OFFSET ADJ_OFFSET
#define MOD_FREQUENCY ADJ_FREQUENCY
#define MOD_MAXERROR ADJ_MAXERROR
#define MOD_ESTERROR ADJ_ESTERROR
#define MOD_STATUS ADJ_STATUS
#define MOD_TIMECONST ADJ_TIMECONST
#define MOD_CLKB ADJ_TICK
#define MOD_CLKA ADJ_OFFSET_SINGLESHOT
#define MOD_TAI ADJ_TAI
#define MOD_MICRO ADJ_MICRO
#define MOD_NANO ADJ_NANO
#define STA_PLL 0x0001
#define STA_PPSFREQ 0x0002
#define STA_PPSTIME 0x0004
#define STA_FLL 0x0008
#define STA_INS 0x0010
#define STA_DEL 0x0020
#define STA_UNSYNC 0x0040
#define STA_FREQHOLD 0x0080
#define STA_PPSSIGNAL 0x0100
#define STA_PPSJITTER 0x0200
#define STA_PPSWANDER 0x0400
#define STA_PPSERROR 0x0800
#define STA_CLOCKERR 0x1000
#define STA_NANO 0x2000
#define STA_MODE 0x4000
#define STA_CLK 0x8000
#define STA_RONLY (STA_PPSSIGNAL | STA_PPSJITTER | STA_PPSWANDER | STA_PPSERROR | STA_CLOCKERR | STA_NANO | STA_MODE | STA_CLK)
extern "C" {
extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw ();
}
#undef __need_timeval
#undef __need_clock_t
#undef __need_time_t
#undef __clockid_time_t
#undef __need_timer_t
#undef __need_timespec
struct tm
{
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
long int tm_gmtoff;
const char *tm_zone;
};
struct itimerspec
{
struct timespec it_interval;
struct timespec it_value;
};
struct sigevent;
#define TIME_UTC 1
extern clock_t clock (void) throw ();
extern time_t time (time_t *__timer) throw ();
extern double difftime (time_t __time1, time_t __time0)
throw () __attribute__ ((__const__));
extern time_t mktime (struct tm *__tp) throw ();
extern size_t strftime (char *__restrict __s, size_t __maxsize,
const char *__restrict __format,
const struct tm *__restrict __tp) throw ();
extern char *strptime (const char *__restrict __s,
const char *__restrict __fmt, struct tm *__tp)
throw ();
extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
const char *__restrict __format,
const struct tm *__restrict __tp,
__locale_t __loc) throw ();
extern char *strptime_l (const char *__restrict __s,
const char *__restrict __fmt, struct tm *__tp,
__locale_t __loc) throw ();
extern struct tm *gmtime (const time_t *__timer) throw ();
extern struct tm *localtime (const time_t *__timer) throw ();
extern struct tm *gmtime_r (const time_t *__restrict __timer,
struct tm *__restrict __tp) throw ();
extern struct tm *localtime_r (const time_t *__restrict __timer,
struct tm *__restrict __tp) throw ();
extern char *asctime (const struct tm *__tp) throw ();
extern char *ctime (const time_t *__timer) throw ();
extern char *asctime_r (const struct tm *__restrict __tp,
char *__restrict __buf) throw ();
extern char *ctime_r (const time_t *__restrict __timer,
char *__restrict __buf) throw ();
extern char *__tzname[2];
extern int __daylight;
extern long int __timezone;
extern char *tzname[2];
extern void tzset (void) throw ();
extern int daylight;
extern long int timezone;
extern int stime (const time_t *__when) throw ();
#define __isleap(year) ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
extern time_t timegm (struct tm *__tp) throw ();
extern time_t timelocal (struct tm *__tp) throw ();
extern int dysize (int __year) throw () __attribute__ ((__const__));
extern int nanosleep (const struct timespec *__requested_time,
struct timespec *__remaining);
extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();
extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();
extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
throw ();
extern int clock_nanosleep (clockid_t __clock_id, int __flags,
const struct timespec *__req,
struct timespec *__rem);
extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();
extern int timer_create (clockid_t __clock_id,
struct sigevent *__restrict __evp,
timer_t *__restrict __timerid) throw ();
extern int timer_delete (timer_t __timerid) throw ();
extern int timer_settime (timer_t __timerid, int __flags,
const struct itimerspec *__restrict __value,
struct itimerspec *__restrict __ovalue) throw ();
extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
throw ();
extern int timer_getoverrun (timer_t __timerid) throw ();
extern int timespec_get (struct timespec *__ts, int __base)
throw () __attribute__ ((__nonnull__ (1)));
extern int getdate_err;
extern struct tm *getdate (const char *__string);
extern int getdate_r (const char *__restrict __string,
struct tm *__restrict __resbufp);
}
#define _BITS_SETJMP_H 1
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
typedef long int __jmp_buf[8];
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
enum
{
PTHREAD_CREATE_JOINABLE,
#define PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_JOINABLE
PTHREAD_CREATE_DETACHED
#define PTHREAD_CREATE_DETACHED PTHREAD_CREATE_DETACHED
};
enum
{
PTHREAD_MUTEX_TIMED_NP,
PTHREAD_MUTEX_RECURSIVE_NP,
PTHREAD_MUTEX_ERRORCHECK_NP,
PTHREAD_MUTEX_ADAPTIVE_NP
,
PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
, PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP
};
enum
{
PTHREAD_MUTEX_STALLED,
PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED,
PTHREAD_MUTEX_ROBUST,
PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST
};
enum
{
PTHREAD_PRIO_NONE,
PTHREAD_PRIO_INHERIT,
PTHREAD_PRIO_PROTECT
};
#define __PTHREAD_SPINS 0, 0
#define PTHREAD_MUTEX_INITIALIZER { { 0, 0, 0, 0, 0, __PTHREAD_SPINS, { 0, 0 } } }
#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP { { 0, 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, __PTHREAD_SPINS, { 0, 0 } } }
#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP { { 0, 0, 0, 0, PTHREAD_MUTEX_ERRORCHECK_NP, __PTHREAD_SPINS, { 0, 0 } } }
#define PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP { { 0, 0, 0, 0, PTHREAD_MUTEX_ADAPTIVE_NP, __PTHREAD_SPINS, { 0, 0 } } }
#define PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP { { 0, 0, 0, 0, PTHREAD_MUTEX_ADAPTIVE_NP, __PTHREAD_SPINS, { 0, 0 } } }
enum
{
PTHREAD_RWLOCK_PREFER_READER_NP,
PTHREAD_RWLOCK_PREFER_WRITER_NP,
PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP
};
#define PTHREAD_RWLOCK_INITIALIZER { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }
#define PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP } }
enum
{
PTHREAD_INHERIT_SCHED,
#define PTHREAD_INHERIT_SCHED PTHREAD_INHERIT_SCHED
PTHREAD_EXPLICIT_SCHED
#define PTHREAD_EXPLICIT_SCHED PTHREAD_EXPLICIT_SCHED
};
enum
{
PTHREAD_SCOPE_SYSTEM,
#define PTHREAD_SCOPE_SYSTEM PTHREAD_SCOPE_SYSTEM
PTHREAD_SCOPE_PROCESS
#define PTHREAD_SCOPE_PROCESS PTHREAD_SCOPE_PROCESS
};
enum
{
PTHREAD_PROCESS_PRIVATE,
#define PTHREAD_PROCESS_PRIVATE PTHREAD_PROCESS_PRIVATE
PTHREAD_PROCESS_SHARED
#define PTHREAD_PROCESS_SHARED PTHREAD_PROCESS_SHARED
};
#define PTHREAD_COND_INITIALIZER { { 0, 0, 0, 0, 0, (void *) 0, 0, 0 } }
struct _pthread_cleanup_buffer
{
void (*__routine) (void *);
void *__arg;
int __canceltype;
struct _pthread_cleanup_buffer *__prev;
};
enum
{
PTHREAD_CANCEL_ENABLE,
#define PTHREAD_CANCEL_ENABLE PTHREAD_CANCEL_ENABLE
PTHREAD_CANCEL_DISABLE
#define PTHREAD_CANCEL_DISABLE PTHREAD_CANCEL_DISABLE
};
enum
{
PTHREAD_CANCEL_DEFERRED,
#define PTHREAD_CANCEL_DEFERRED PTHREAD_CANCEL_DEFERRED
PTHREAD_CANCEL_ASYNCHRONOUS
#define PTHREAD_CANCEL_ASYNCHRONOUS PTHREAD_CANCEL_ASYNCHRONOUS
};
#define PTHREAD_CANCELED ((void *) -1)
#define PTHREAD_ONCE_INIT 0
#define PTHREAD_BARRIER_SERIAL_THREAD -1
extern "C" {
extern int pthread_create (pthread_t *__restrict __newthread,
const pthread_attr_t *__restrict __attr,
void *(*__start_routine) (void *),
void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3)));
extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));
extern int pthread_join (pthread_t __th, void **__thread_return);
extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();
extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
const struct timespec *__abstime);
extern int pthread_detach (pthread_t __th) throw ();
extern pthread_t pthread_self (void) throw () __attribute__ ((__const__));
extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
throw () __attribute__ ((__const__));
extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_destroy (pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
int *__detachstate)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
int __detachstate)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
size_t *__guardsize)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
size_t __guardsize)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
struct sched_param *__restrict __param)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
const struct sched_param *__restrict
__param) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
__attr, int *__restrict __policy)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
__attr, int *__restrict __inherit)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
int __inherit)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
int *__restrict __scope)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
__attr, void **__restrict __stackaddr)
throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));
extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
void *__stackaddr)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));
extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
__attr, size_t *__restrict __stacksize)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
size_t __stacksize)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
void **__restrict __stackaddr,
size_t *__restrict __stacksize)
throw () __attribute__ ((__nonnull__ (1, 2, 3)));
extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
size_t __stacksize) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
size_t __cpusetsize,
const cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
size_t __cpusetsize,
cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern int pthread_getattr_default_np (pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_setattr_default_np (const pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (2)));
extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
const struct sched_param *__param)
throw () __attribute__ ((__nonnull__ (3)));
extern int pthread_getschedparam (pthread_t __target_thread,
int *__restrict __policy,
struct sched_param *__restrict __param)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
throw ();
extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
size_t __buflen)
throw () __attribute__ ((__nonnull__ (2)));
extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
throw () __attribute__ ((__nonnull__ (2)));
extern int pthread_getconcurrency (void) throw ();
extern int pthread_setconcurrency (int __level) throw ();
extern int pthread_yield (void) throw ();
extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
const cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (3)));
extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (3)));
extern int pthread_once (pthread_once_t *__once_control,
void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_setcancelstate (int __state, int *__oldstate);
extern int pthread_setcanceltype (int __type, int *__oldtype);
extern int pthread_cancel (pthread_t __th);
extern void pthread_testcancel (void);
typedef struct
{
struct
{
__jmp_buf __cancel_jmp_buf;
int __mask_was_saved;
} __cancel_jmp_buf[1];
void *__pad[4];
} __pthread_unwind_buf_t __attribute__ ((__aligned__));
#define __cleanup_fct_attribute
struct __pthread_cleanup_frame
{
void (*__cancel_routine) (void *);
void *__cancel_arg;
int __do_it;
int __cancel_type;
};
class __pthread_cleanup_class
{
void (*__cancel_routine) (void *);
void *__cancel_arg;
int __do_it;
int __cancel_type;
public:
__pthread_cleanup_class (void (*__fct) (void *), void *__arg) ;
~__pthread_cleanup_class () ;
void __setdoit (int __newval) ;
void __defer () ;
void __restore () const ;
};
#define pthread_cleanup_push(routine,arg) do { __pthread_cleanup_class __clframe (routine, arg)
#define pthread_cleanup_pop(execute) __clframe.__setdoit (execute); } while (0)
#define pthread_cleanup_push_defer_np(routine,arg) do { __pthread_cleanup_class __clframe (routine, arg); __clframe.__defer ()
#define pthread_cleanup_pop_restore_np(execute) __clframe.__restore (); __clframe.__setdoit (execute); } while (0)
struct __jmp_buf_tag;
extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();
extern int pthread_mutex_init (pthread_mutex_t *__mutex,
const pthread_mutexattr_t *__mutexattr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
const struct timespec *__restrict
__abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
__restrict __mutex,
int *__restrict __prioceiling)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
int __prioceiling,
int *__restrict __old_ceiling)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
__attr, int *__restrict __kind)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
__restrict __attr,
int *__restrict __protocol)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
int __protocol)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
__restrict __attr,
int *__restrict __prioceiling)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
int __prioceiling)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
int *__robustness)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
int *__robustness)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
int __robustness)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
int __robustness)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
const pthread_rwlockattr_t *__restrict
__attr) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
const struct timespec *__restrict
__abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
const struct timespec *__restrict
__abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
__restrict __attr,
int *__restrict __pref)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
int __pref) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
const pthread_condattr_t *__restrict __cond_attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_destroy (pthread_cond_t *__cond)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_signal (pthread_cond_t *__cond)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_broadcast (pthread_cond_t *__cond)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
pthread_mutex_t *__restrict __mutex)
__attribute__ ((__nonnull__ (1, 2)));
extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
pthread_mutex_t *__restrict __mutex,
const struct timespec *__restrict __abstime)
__attribute__ ((__nonnull__ (1, 2, 3)));
extern int pthread_condattr_init (pthread_condattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_condattr_getpshared (const pthread_condattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
int __pshared) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_condattr_getclock (const pthread_condattr_t *
__restrict __attr,
__clockid_t *__restrict __clock_id)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
__clockid_t __clock_id)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_lock (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
const pthread_barrierattr_t *__restrict
__attr, unsigned int __count)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_key_create (pthread_key_t *__key,
void (*__destr_function) (void *))
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_key_delete (pthread_key_t __key) throw ();
extern void *pthread_getspecific (pthread_key_t __key) throw ();
extern int pthread_setspecific (pthread_key_t __key,
const void *__pointer) throw () ;
extern int pthread_getcpuclockid (pthread_t __thread_id,
__clockid_t *__clock_id)
throw () __attribute__ ((__nonnull__ (2)));
extern int pthread_atfork (void (*__prepare) (void),
void (*__parent) (void),
void (*__child) (void)) throw ();
}
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 PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
#define __GTHREAD_COND_INIT PTHREAD_COND_INITIALIZER
#define __GTHREAD_TIME_INIT {0,0}
#define __gthrw_pragma(pragma)
#define __gthrw2(name,name2,type) static __typeof(type) name __attribute__ ((__weakref__(#name2))); __gthrw_pragma(weak type)
#define __gthrw_(name) __gthrw_ ## name
#define __gthrw(name) __gthrw2(__gthrw_ ## name,name,name)
static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once")));
static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific")));
static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific")));
static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create")));
static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join")));
static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal")));
static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self")));
static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach")));
static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel")));
static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield")));
static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock")));
static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock")));
static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock")));
static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock")));
static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init")));
static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy")));
static __typeof(pthread_cond_init) __gthrw_pthread_cond_init __attribute__ ((__weakref__("pthread_cond_init")));
static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast")));
static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal")));
static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait")));
static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait")));
static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy")));
static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create")));
static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete")));
static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init")));
static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype")));
static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy")));
static __typeof(pthread_key_create) __gthrw___pthread_key_create __attribute__ ((__weakref__("__pthread_key_create")));
#define GTHR_ACTIVE_PROXY __gthrw_(__pthread_key_create)
static int
__gthread_active_p (void)
;
static int
__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
void *__args)
;
static int
__gthread_join (__gthread_t __threadid, void **__value_ptr)
;
static int
__gthread_detach (__gthread_t __threadid)
;
static int
__gthread_equal (__gthread_t __t1, __gthread_t __t2)
;
static __gthread_t
__gthread_self (void)
;
static int
__gthread_yield (void)
;
static int
__gthread_once (__gthread_once_t *__once, void (*__func) (void))
;
static int
__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
;
static int
__gthread_key_delete (__gthread_key_t __key)
;
static void *
__gthread_getspecific (__gthread_key_t __key)
;
static int
__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
;
static void
__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
;
static int
__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
;
static int
__gthread_mutex_lock (__gthread_mutex_t *__mutex)
;
static int
__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
;
static int
__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
const __gthread_time_t *__abs_timeout)
;
static int
__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
;
static int
__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
;
static int
__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
;
static int
__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
const __gthread_time_t *__abs_timeout)
;
static int
__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
;
static int
__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
;
static int
__gthread_cond_broadcast (__gthread_cond_t *__cond)
;
static int
__gthread_cond_signal (__gthread_cond_t *__cond)
;
static int
__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
;
static int
__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
const __gthread_time_t *__abs_timeout)
;
static int
__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
__gthread_recursive_mutex_t *__mutex)
;
static int
__gthread_cond_destroy (__gthread_cond_t* __cond)
;
#pragma GCC visibility pop
#define _GLIBCXX_ATOMIC_WORD_H 1
typedef int _Atomic_word;
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
static _Atomic_word
__exchange_and_add(volatile _Atomic_word* __mem, int __val)
;
static void
__atomic_add(volatile _Atomic_word* __mem, int __val)
;
static _Atomic_word
__exchange_and_add_single(_Atomic_word* __mem, int __val)
;
static void
__atomic_add_single(_Atomic_word* __mem, int __val)
;
static _Atomic_word
__attribute__ ((__unused__))
__exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
;
static void
__attribute__ ((__unused__))
__atomic_add_dispatch(_Atomic_word* __mem, int __val)
;
}
#define _GLIBCXX_READ_MEM_BARRIER __asm __volatile ("":::"memory")
#define _GLIBCXX_WRITE_MEM_BARRIER __asm __volatile ("":::"memory")
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
using std::size_t;
using std::ptrdiff_t;
typedef void (*__destroy_handler)(void*);
struct __pool_base
{
typedef unsigned short int _Binmap_type;
struct _Tune
{
enum { _S_align = 8 };
enum { _S_max_bytes = 128 };
enum { _S_min_bin = 8 };
enum { _S_chunk_size = 4096 - 4 * sizeof(void*) };
enum { _S_max_threads = 4096 };
enum { _S_freelist_headroom = 10 };
size_t _M_align;
size_t _M_max_bytes;
size_t _M_min_bin;
size_t _M_chunk_size;
size_t _M_max_threads;
size_t _M_freelist_headroom;
bool _M_force_new;
explicit
_Tune()
;
explicit
_Tune(size_t __align, size_t __maxb, size_t __minbin, size_t __chunk,
size_t __maxthreads, size_t __headroom, bool __force)
;
};
struct _Block_address
{
void* _M_initial;
_Block_address* _M_next;
};
const _Tune&
_M_get_options() const
;
void
_M_set_options(_Tune __t)
;
bool
_M_check_threshold(size_t __bytes)
;
size_t
_M_get_binmap(size_t __bytes)
;
size_t
_M_get_align()
;
explicit
__pool_base() ;
explicit
__pool_base(const _Tune& __options) ;
private:
explicit
__pool_base(const __pool_base&);
__pool_base&
operator=(const __pool_base&);
protected:
_Tune _M_options;
_Binmap_type* _M_binmap;
bool _M_init;
};
template<bool _Thread>
class __pool;
template<>
class __pool<false> : public __pool_base
{
public:
union _Block_record
{
_Block_record* _M_next;
};
struct _Bin_record
{
_Block_record** _M_first;
_Block_address* _M_address;
};
void
_M_initialize_once()
;
void
_M_destroy() throw();
char*
_M_reserve_block(size_t __bytes, const size_t __thread_id);
void
_M_reclaim_block(char* __p, size_t __bytes) throw ();
size_t
_M_get_thread_id() ;
const _Bin_record&
_M_get_bin(size_t __which)
;
void
_M_adjust_freelist(const _Bin_record&, _Block_record*, size_t)
;
explicit __pool() ;
explicit __pool(const __pool_base::_Tune& __tune) ;
private:
_Bin_record* _M_bin;
size_t _M_bin_size;
void
_M_initialize();
};
template<>
class __pool<true> : public __pool_base
{
public:
struct _Thread_record
{
_Thread_record* _M_next;
size_t _M_id;
};
union _Block_record
{
_Block_record* _M_next;
size_t _M_thread_id;
};
struct _Bin_record
{
_Block_record** _M_first;
_Block_address* _M_address;
size_t* _M_free;
size_t* _M_used;
__gthread_mutex_t* _M_mutex;
};
void
_M_initialize(__destroy_handler);
void
_M_initialize_once()
;
void
_M_destroy() throw();
char*
_M_reserve_block(size_t __bytes, const size_t __thread_id);
void
_M_reclaim_block(char* __p, size_t __bytes) throw ();
const _Bin_record&
_M_get_bin(size_t __which)
;
void
_M_adjust_freelist(const _Bin_record& __bin, _Block_record* __block,
size_t __thread_id)
;
__attribute__ ((__const__)) void
_M_destroy_thread_key(void*) throw ();
size_t
_M_get_thread_id();
explicit __pool()
;
explicit __pool(const __pool_base::_Tune& __tune)
;
private:
_Bin_record* _M_bin;
size_t _M_bin_size;
_Thread_record* _M_thread_freelist;
void* _M_thread_freelist_initial;
void
_M_initialize();
};
template<template <bool> class _PoolTp, bool _Thread>
struct __common_pool
{
typedef _PoolTp<_Thread> pool_type;
static pool_type&
_S_get_pool()
;
};
template<template <bool> class _PoolTp, bool _Thread>
struct __common_pool_base;
template<template <bool> class _PoolTp>
struct __common_pool_base<_PoolTp, false>
: public __common_pool<_PoolTp, false>
{
using __common_pool<_PoolTp, false>::_S_get_pool;
static void
_S_initialize_once()
;
};
template<template <bool> class _PoolTp>
struct __common_pool_base<_PoolTp, true>
: public __common_pool<_PoolTp, true>
{
using __common_pool<_PoolTp, true>::_S_get_pool;
static void
_S_initialize()
;
static void
_S_initialize_once()
;
};
template<template <bool> class _PoolTp, bool _Thread>
struct __common_pool_policy : public __common_pool_base<_PoolTp, _Thread>
{
template<typename _Tp1, template <bool> class _PoolTp1 = _PoolTp,
bool _Thread1 = _Thread>
struct _M_rebind
{ typedef __common_pool_policy<_PoolTp1, _Thread1> other; };
using __common_pool_base<_PoolTp, _Thread>::_S_get_pool;
using __common_pool_base<_PoolTp, _Thread>::_S_initialize_once;
};
template<typename _Tp, template <bool> class _PoolTp, bool _Thread>
struct __per_type_pool
{
typedef _Tp value_type;
typedef _PoolTp<_Thread> pool_type;
static pool_type&
_S_get_pool()
;
};
template<typename _Tp, template <bool> class _PoolTp, bool _Thread>
struct __per_type_pool_base;
template<typename _Tp, template <bool> class _PoolTp>
struct __per_type_pool_base<_Tp, _PoolTp, false>
: public __per_type_pool<_Tp, _PoolTp, false>
{
using __per_type_pool<_Tp, _PoolTp, false>::_S_get_pool;
static void
_S_initialize_once()
;
};
template<typename _Tp, template <bool> class _PoolTp>
struct __per_type_pool_base<_Tp, _PoolTp, true>
: public __per_type_pool<_Tp, _PoolTp, true>
{
using __per_type_pool<_Tp, _PoolTp, true>::_S_get_pool;
static void
_S_initialize()
;
static void
_S_initialize_once()
;
};
template<typename _Tp, template <bool> class _PoolTp, bool _Thread>
struct __per_type_pool_policy
: public __per_type_pool_base<_Tp, _PoolTp, _Thread>
{
template<typename _Tp1, template <bool> class _PoolTp1 = _PoolTp,
bool _Thread1 = _Thread>
struct _M_rebind
{ typedef __per_type_pool_policy<_Tp1, _PoolTp1, _Thread1> other; };
using __per_type_pool_base<_Tp, _PoolTp, _Thread>::_S_get_pool;
using __per_type_pool_base<_Tp, _PoolTp, _Thread>::_S_initialize_once;
};
template<typename _Tp>
class __mt_alloc_base
{
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;
typedef std::true_type propagate_on_container_move_assignment;
pointer
address(reference __x) const noexcept
{ return std::__addressof(__x); }
const_pointer
address(const_reference __x) const noexcept
{ return std::__addressof(__x); }
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(); }
};
#define __thread_default true
template<typename _Tp,
typename _Poolp = __common_pool_policy<__pool, true> >
class __mt_alloc : public __mt_alloc_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;
typedef _Poolp __policy_type;
typedef typename _Poolp::pool_type __pool_type;
template<typename _Tp1, typename _Poolp1 = _Poolp>
struct rebind
{
typedef typename _Poolp1::template _M_rebind<_Tp1>::other pol_type;
typedef __mt_alloc<_Tp1, pol_type> other;
};
__mt_alloc() noexcept { }
__mt_alloc(const __mt_alloc&) noexcept { }
template<typename _Tp1, typename _Poolp1>
__mt_alloc(const __mt_alloc<_Tp1, _Poolp1>&) noexcept { }
~__mt_alloc() noexcept { }
pointer
allocate(size_type __n, const void* = 0);
void
deallocate(pointer __p, size_type __n);
const __pool_base::_Tune
_M_get_options()
;
void
_M_set_options(__pool_base::_Tune __t)
;
};
template<typename _Tp, typename _Poolp>
bool
operator==(const __mt_alloc<_Tp, _Poolp>&, const __mt_alloc<_Tp, _Poolp>&)
;
template<typename _Tp, typename _Poolp>
bool
operator!=(const __mt_alloc<_Tp, _Poolp>&, const __mt_alloc<_Tp, _Poolp>&)
;
#undef __thread_default
}
namespace std
{
template<typename _Tp>
using __allocator_base = __gnu_cxx::__mt_alloc<_Tp>;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<>
class allocator<void>
{
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef void* pointer;
typedef const void* const_pointer;
typedef void value_type;
template<typename _Tp1>
struct rebind
{ typedef allocator<_Tp1> other; };
typedef true_type propagate_on_container_move_assignment;
};
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;
allocator() throw() ;
allocator(const allocator& __a) throw() ;
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&)
;
};
template<typename _Alloc>
struct __alloc_neq<_Alloc, false>
{
static bool
_S_do_it(const _Alloc& __one, const _Alloc& __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; }
}
};
}
#define _LOCALE_FWD_H 1
#define _GLIBCXX_CXX_LOCALE_H 1
#define _LOCALE_H 1
#define __need_NULL
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define _BITS_LOCALE_H 1
#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
#define __LC_PAPER 7
#define __LC_NAME 8
#define __LC_ADDRESS 9
#define __LC_TELEPHONE 10
#define __LC_MEASUREMENT 11
#define __LC_IDENTIFICATION 12
extern "C" {
#define LC_CTYPE __LC_CTYPE
#define LC_NUMERIC __LC_NUMERIC
#define LC_TIME __LC_TIME
#define LC_COLLATE __LC_COLLATE
#define LC_MONETARY __LC_MONETARY
#define LC_MESSAGES __LC_MESSAGES
#define LC_ALL __LC_ALL
#define LC_PAPER __LC_PAPER
#define LC_NAME __LC_NAME
#define LC_ADDRESS __LC_ADDRESS
#define LC_TELEPHONE __LC_TELEPHONE
#define LC_MEASUREMENT __LC_MEASUREMENT
#define LC_IDENTIFICATION __LC_IDENTIFICATION
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;
};
extern char *setlocale (int __category, const char *__locale) throw ();
extern struct lconv *localeconv (void) throw ();
extern __locale_t newlocale (int __category_mask, const char *__locale,
__locale_t __base) throw ();
#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_PAPER_MASK (1 << __LC_PAPER)
#define LC_NAME_MASK (1 << __LC_NAME)
#define LC_ADDRESS_MASK (1 << __LC_ADDRESS)
#define LC_TELEPHONE_MASK (1 << __LC_TELEPHONE)
#define LC_MEASUREMENT_MASK (1 << __LC_MEASUREMENT)
#define LC_IDENTIFICATION_MASK (1 << __LC_IDENTIFICATION)
#define LC_ALL_MASK (LC_CTYPE_MASK | LC_NUMERIC_MASK | LC_TIME_MASK | LC_COLLATE_MASK | LC_MONETARY_MASK | LC_MESSAGES_MASK | LC_PAPER_MASK | LC_NAME_MASK | LC_ADDRESS_MASK | LC_TELEPHONE_MASK | LC_MEASUREMENT_MASK | LC_IDENTIFICATION_MASK )
extern __locale_t duplocale (__locale_t __dataset) throw ();
extern void freelocale (__locale_t __dataset) throw ();
extern __locale_t uselocale (__locale_t __dataset) throw ();
#define LC_GLOBAL_LOCALE ((__locale_t) -1L)
}
#define _GLIBCXX_CLOCALE 1
#undef setlocale
#undef localeconv
namespace std
{
using ::lconv;
using ::setlocale;
using ::localeconv;
}
#define _GLIBCXX_C_LOCALE_GNU 1
#define _GLIBCXX_NUM_CATEGORIES 6
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
extern "C" __typeof(uselocale) __uselocale;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
typedef __locale_t __c_locale;
int
__convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
char* __out,
const int __size __attribute__ ((__unused__)),
const char* __fmt, ...)
;
}
#define _GLIBCXX_IOSFWD 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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;
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;
}
#define _CTYPE_H 1
extern "C" {
#define _ISbit(bit) ((bit) < 8 ? ((1 << (bit)) << 8) : ((1 << (bit)) >> 8))
enum
{
_ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
_ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
_ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
_ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
_ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
_ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
_ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
_ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
_ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
_IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
_ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
_ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
};
extern const unsigned short int **__ctype_b_loc (void)
throw () __attribute__ ((__const__));
extern const __int32_t **__ctype_tolower_loc (void)
throw () __attribute__ ((__const__));
extern const __int32_t **__ctype_toupper_loc (void)
throw () __attribute__ ((__const__));
#define __isascii(c) (((c) & ~0x7f) == 0)
#define __toascii(c) ((c) & 0x7f)
#define __exctype(name) extern int name (int) __THROW
extern int isalnum (int) throw ();
extern int isalpha (int) throw ();
extern int iscntrl (int) throw ();
extern int isdigit (int) throw ();
extern int islower (int) throw ();
extern int isgraph (int) throw ();
extern int isprint (int) throw ();
extern int ispunct (int) throw ();
extern int isspace (int) throw ();
extern int isupper (int) throw ();
extern int isxdigit (int) throw ();
extern int tolower (int __c) throw ();
extern int toupper (int __c) throw ();
extern int isblank (int) throw ();
extern int isctype (int __c, int __mask) throw ();
extern int isascii (int __c) throw ();
extern int toascii (int __c) throw ();
extern int _toupper (int) throw ();
extern int _tolower (int) throw ();
#define __tobody(c,f,a,args) (__extension__ ({ int __res; if (sizeof (c) > 1) { if (__builtin_constant_p (c)) { int __c = (c); __res = __c < -128 || __c > 255 ? __c : (a)[__c]; } else __res = f args; } else __res = (a)[(int) (c)]; __res; }))
#define __isctype_l(c,type,locale) ((locale)->__ctype_b[(int) (c)] & (unsigned short int) type)
#define __exctype_l(name) extern int name (int, __locale_t) __THROW
extern int isalnum_l (int, __locale_t) throw ();
extern int isalpha_l (int, __locale_t) throw ();
extern int iscntrl_l (int, __locale_t) throw ();
extern int isdigit_l (int, __locale_t) throw ();
extern int islower_l (int, __locale_t) throw ();
extern int isgraph_l (int, __locale_t) throw ();
extern int isprint_l (int, __locale_t) throw ();
extern int ispunct_l (int, __locale_t) throw ();
extern int isspace_l (int, __locale_t) throw ();
extern int isupper_l (int, __locale_t) throw ();
extern int isxdigit_l (int, __locale_t) throw ();
extern int isblank_l (int, __locale_t) throw ();
extern int __tolower_l (int __c, __locale_t __l) throw ();
extern int tolower_l (int __c, __locale_t __l) throw ();
extern int __toupper_l (int __c, __locale_t __l) throw ();
extern int toupper_l (int __c, __locale_t __l) throw ();
}
#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;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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>
_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;
template<typename _CharT> class numpunct;
template<typename _CharT> class numpunct_byname;
template<typename _CharT>
class collate;
template<typename _CharT> class
collate_byname;
class time_base;
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;
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class money_get;
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class money_put;
template<typename _CharT, bool _Intl = false>
class moneypunct;
template<typename _CharT, bool _Intl = false>
class moneypunct_byname;
class messages_base;
template<typename _CharT>
class messages;
template<typename _CharT>
class messages_byname;
}
#define _OSTREAM_INSERT_H 1
#define _CXXABI_FORCED_H 1
#pragma GCC visibility push(default)
namespace __cxxabiv1
{
class __forced_unwind
{
virtual ~__forced_unwind() throw();
virtual void __pure_dummy() = 0;
};
}
#pragma GCC visibility pop
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
void
__ostream_write(basic_ostream<_CharT, _Traits>& __out,
const _CharT* __s, streamsize __n)
;
template<typename _CharT, typename _Traits>
void
__ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
__ostream_insert(basic_ostream<_CharT, _Traits>& __out,
const _CharT* __s, streamsize __n)
;
extern template ostream& __ostream_insert(ostream&, const char*, streamsize);
extern template wostream& __ostream_insert(wostream&, const wchar_t*,
streamsize);
}
#define _STL_FUNCTION_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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;
};
template<typename _Tp>
struct plus : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct minus : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct multiplies : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct divides : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct modulus : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct negate : public unary_function<_Tp, _Tp>
{
_Tp
operator()(const _Tp& __x) const
;
};
template<typename _Tp>
struct equal_to : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct not_equal_to : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct greater : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct less : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct greater_equal : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct less_equal : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct logical_and : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct logical_or : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct logical_not : public unary_function<_Tp, bool>
{
bool
operator()(const _Tp& __x) const
;
};
template<typename _Tp>
struct bit_and : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct bit_or : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct bit_not : public unary_function<_Tp, _Tp>
{
_Tp
operator()(const _Tp& __x) const
;
};
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) ;
bool
operator()(const typename _Predicate::argument_type& __x) const
;
};
template<typename _Predicate>
unary_negate<_Predicate>
not1(const _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) ;
bool
operator()(const typename _Predicate::first_argument_type& __x,
const typename _Predicate::second_argument_type& __y) const
;
};
template<typename _Predicate>
binary_negate<_Predicate>
not2(const _Predicate& __pred)
;
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)) ;
_Result
operator()(_Arg __x) const
;
};
template<typename _Arg, typename _Result>
pointer_to_unary_function<_Arg, _Result>
ptr_fun(_Result (*__x)(_Arg))
;
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)) ;
_Result
operator()(_Arg1 __x, _Arg2 __y) const
;
};
template<typename _Arg1, typename _Arg2, typename _Result>
pointer_to_binary_function<_Arg1, _Arg2, _Result>
ptr_fun(_Result (*__x)(_Arg1, _Arg2))
;
template<typename _Tp>
struct _Identity
: public unary_function<_Tp,_Tp>
{
_Tp&
operator()(_Tp& __x) const
;
const _Tp&
operator()(const _Tp& __x) const
;
};
template<typename _Pair>
struct _Select1st
: public unary_function<_Pair, typename _Pair::first_type>
{
typename _Pair::first_type&
operator()(_Pair& __x) const
;
const typename _Pair::first_type&
operator()(const _Pair& __x) const
;
template<typename _Pair2>
typename _Pair2::first_type&
operator()(_Pair2& __x) const
;
template<typename _Pair2>
const typename _Pair2::first_type&
operator()(const _Pair2& __x) const
;
};
template<typename _Pair>
struct _Select2nd
: public unary_function<_Pair, typename _Pair::second_type>
{
typename _Pair::second_type&
operator()(_Pair& __x) const
;
const typename _Pair::second_type&
operator()(const _Pair& __x) const
;
};
template<typename _Ret, typename _Tp>
class mem_fun_t : public unary_function<_Tp*, _Ret>
{
public:
explicit
mem_fun_t(_Ret (_Tp::*__pf)()) ;
_Ret
operator()(_Tp* __p) const
;
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) ;
_Ret
operator()(const _Tp* __p) const
;
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)()) ;
_Ret
operator()(_Tp& __r) const
;
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) ;
_Ret
operator()(const _Tp& __r) const
;
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)) ;
_Ret
operator()(_Tp* __p, _Arg __x) const
;
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) ;
_Ret
operator()(const _Tp* __p, _Arg __x) const
;
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)) ;
_Ret
operator()(_Tp& __r, _Arg __x) const
;
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) ;
_Ret
operator()(const _Tp& __r, _Arg __x) const
;
private:
_Ret (_Tp::*_M_f)(_Arg) const;
};
template<typename _Ret, typename _Tp>
mem_fun_t<_Ret, _Tp>
mem_fun(_Ret (_Tp::*__f)())
;
template<typename _Ret, typename _Tp>
const_mem_fun_t<_Ret, _Tp>
mem_fun(_Ret (_Tp::*__f)() const)
;
template<typename _Ret, typename _Tp>
mem_fun_ref_t<_Ret, _Tp>
mem_fun_ref(_Ret (_Tp::*__f)())
;
template<typename _Ret, typename _Tp>
const_mem_fun_ref_t<_Ret, _Tp>
mem_fun_ref(_Ret (_Tp::*__f)() const)
;
template<typename _Ret, typename _Tp, typename _Arg>
mem_fun1_t<_Ret, _Tp, _Arg>
mem_fun(_Ret (_Tp::*__f)(_Arg))
;
template<typename _Ret, typename _Tp, typename _Arg>
const_mem_fun1_t<_Ret, _Tp, _Arg>
mem_fun(_Ret (_Tp::*__f)(_Arg) const)
;
template<typename _Ret, typename _Tp, typename _Arg>
mem_fun1_ref_t<_Ret, _Tp, _Arg>
mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
;
template<typename _Ret, typename _Tp, typename _Arg>
const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
;
}
#define _BACKWARD_BINDERS_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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) ;
typename _Operation::result_type
operator()(const typename _Operation::second_argument_type& __x) const
;
typename _Operation::result_type
operator()(typename _Operation::second_argument_type& __x) const
;
} __attribute__ ((__deprecated__));
template<typename _Operation, typename _Tp>
binder1st<_Operation>
bind1st(const _Operation& __fn, const _Tp& __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) ;
typename _Operation::result_type
operator()(const typename _Operation::first_argument_type& __x) const
;
typename _Operation::result_type
operator()(typename _Operation::first_argument_type& __x) const
;
} __attribute__ ((__deprecated__));
template<typename _Operation, typename _Tp>
binder2nd<_Operation>
bind2nd(const _Operation& __fn, const _Tp& __x)
;
}
#define _GLIBCXX_RANGE_ACCESS_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<class _Container>
inline auto
begin(_Container& __cont) -> decltype(__cont.begin())
{ return __cont.begin(); }
template<class _Container>
inline auto
begin(const _Container& __cont) -> decltype(__cont.begin())
{ return __cont.begin(); }
template<class _Container>
inline auto
end(_Container& __cont) -> decltype(__cont.end())
{ return __cont.end(); }
template<class _Container>
inline auto
end(const _Container& __cont) -> decltype(__cont.end())
{ return __cont.end(); }
template<class _Tp, size_t _Nm>
_Tp*
begin(_Tp (&__arr)[_Nm])
;
template<class _Tp, size_t _Nm>
_Tp*
end(_Tp (&__arr)[_Nm])
;
}
#define _BASIC_STRING_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits, typename _Alloc>
class basic_string
{
typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;
public:
typedef _Traits traits_type;
typedef typename _Traits::char_type value_type;
typedef _Alloc allocator_type;
typedef typename _CharT_alloc_type::size_type size_type;
typedef typename _CharT_alloc_type::difference_type difference_type;
typedef typename _CharT_alloc_type::reference reference;
typedef typename _CharT_alloc_type::const_reference const_reference;
typedef typename _CharT_alloc_type::pointer pointer;
typedef typename _CharT_alloc_type::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;
private:
struct _Rep_base
{
size_type _M_length;
size_type _M_capacity;
_Atomic_word _M_refcount;
};
struct _Rep : _Rep_base
{
typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
static const size_type _S_max_size;
static const _CharT _S_terminal;
static size_type _S_empty_rep_storage[];
static _Rep&
_S_empty_rep() noexcept
{
void* __p = reinterpret_cast<void*>(&_S_empty_rep_storage);
return *reinterpret_cast<_Rep*>(__p);
}
bool
_M_is_leaked() const noexcept
{ return this->_M_refcount < 0; }
bool
_M_is_shared() const noexcept
{ return this->_M_refcount > 0; }
void
_M_set_leaked() noexcept
{ this->_M_refcount = -1; }
void
_M_set_sharable() noexcept
{ this->_M_refcount = 0; }
void
_M_set_length_and_sharable(size_type __n) noexcept
{
if (__builtin_expect(this != &_S_empty_rep(), false))
{
this->_M_set_sharable();
this->_M_length = __n;
traits_type::assign(this->_M_refdata()[__n], _S_terminal);
}
}
_CharT*
_M_refdata() throw()
{ return reinterpret_cast<_CharT*>(this + 1); }
_CharT*
_M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2)
{
return (!_M_is_leaked() && __alloc1 == __alloc2)
? _M_refcopy() : _M_clone(__alloc1);
}
static _Rep*
_S_create(size_type, size_type, const _Alloc&);
void
_M_dispose(const _Alloc& __a) noexcept
{
if (__builtin_expect(this != &_S_empty_rep(), false))
{
;
if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount,
-1) <= 0)
{
;
_M_destroy(__a);
}
}
}
void
_M_destroy(const _Alloc&) throw();
_CharT*
_M_refcopy() throw()
;
_CharT*
_M_clone(const _Alloc&, size_type __res = 0);
};
struct _Alloc_hider : _Alloc
{
_Alloc_hider(_CharT* __dat, const _Alloc& __a) noexcept
: _Alloc(__a), _M_p(__dat) { }
_CharT* _M_p;
};
public:
static const size_type npos = static_cast<size_type>(-1);
private:
mutable _Alloc_hider _M_dataplus;
_CharT*
_M_data() const noexcept
{ return _M_dataplus._M_p; }
_CharT*
_M_data(_CharT* __p) noexcept
{ return (_M_dataplus._M_p = __p); }
_Rep*
_M_rep() const noexcept
{ return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }
iterator
_M_ibegin() const noexcept
{ return iterator(_M_data()); }
iterator
_M_iend() const noexcept
{ return iterator(_M_data() + this->size()); }
void
_M_leak()
{
if (!_M_rep()->_M_is_leaked())
_M_leak_hard();
}
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
_M_copy(_CharT* __d, const _CharT* __s, size_type __n) noexcept
{
if (__n == 1)
traits_type::assign(*__d, *__s);
else
traits_type::copy(__d, __s, __n);
}
static void
_M_move(_CharT* __d, const _CharT* __s, size_type __n) noexcept
{
if (__n == 1)
traits_type::assign(*__d, *__s);
else
traits_type::move(__d, __s, __n);
}
static void
_M_assign(_CharT* __d, size_type __n, _CharT __c) noexcept
{
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)
noexcept
{
for (; __k1 != __k2; ++__k1, ++__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
{ _M_copy(__p, __k1, __k2 - __k1); }
static void
_S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
noexcept
{ _M_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_mutate(size_type __pos, size_type __len1, size_type __len2);
void
_M_leak_hard();
static _Rep&
_S_empty_rep() noexcept
{ return _Rep::_S_empty_rep(); }
public:
basic_string()
: _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { }
explicit
basic_string(const _Alloc& __a);
basic_string(const basic_string& __str);
basic_string(const basic_string& __str, size_type __pos,
size_type __n = npos);
basic_string(const basic_string& __str, size_type __pos,
size_type __n, const _Alloc& __a);
basic_string(const _CharT* __s, size_type __n,
const _Alloc& __a = _Alloc());
basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc());
basic_string(basic_string&& __str)
noexcept
: _M_dataplus(__str._M_dataplus)
{
__str._M_data(_S_empty_rep()._M_refdata());
}
basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc());
template<class _InputIterator>
basic_string(_InputIterator __beg, _InputIterator __end,
const _Alloc& __a = _Alloc());
~basic_string() noexcept
{ _M_rep()->_M_dispose(this->get_allocator()); }
basic_string&
operator=(const basic_string& __str)
{ return this->assign(__str); }
basic_string&
operator=(const _CharT* __s)
{ return this->assign(__s); }
basic_string&
operator=(_CharT __c)
{
this->assign(1, __c);
return *this;
}
basic_string&
operator=(basic_string&& __str)
{
this->swap(__str);
return *this;
}
basic_string&
operator=(initializer_list<_CharT> __l)
{
this->assign(__l.begin(), __l.size());
return *this;
}
iterator
begin()
{
_M_leak();
return iterator(_M_data());
}
const_iterator
begin() const noexcept
{ return const_iterator(_M_data()); }
iterator
end()
{
_M_leak();
return iterator(_M_data() + this->size());
}
const_iterator
end() const noexcept
{ return const_iterator(_M_data() + this->size()); }
reverse_iterator
rbegin()
{ return reverse_iterator(this->end()); }
const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(this->end()); }
reverse_iterator
rend()
{ 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_rep()->_M_length; }
size_type
length() const noexcept
{ return _M_rep()->_M_length; }
size_type
max_size() const noexcept
{ return _Rep::_S_max_size; }
void
resize(size_type __n, _CharT __c);
void
resize(size_type __n)
;
void
shrink_to_fit() noexcept
{
if (capacity() > size())
{
try
{ reserve(0); }
catch(...)
{ }
}
}
size_type
capacity() const noexcept
{ return _M_rep()->_M_capacity; }
void
reserve(size_type __res_arg = 0);
void
clear()
;
bool
empty() const noexcept
{ return this->size() == 0; }
const_reference
operator[] (size_type __pos) const noexcept
{
;
return _M_data()[__pos];
}
reference
operator[](size_type __pos)
{
;
;
_M_leak();
return _M_data()[__pos];
}
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];
}
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());
_M_leak();
return _M_data()[__n];
}
reference
front()
{ return operator[](0); }
const_reference
front() const noexcept
{ return operator[](0); }
reference
back()
{ return operator[](this->size() - 1); }
const_reference
back() const noexcept
{ return operator[](this->size() - 1); }
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()); }
basic_string&
append(const basic_string& __str);
basic_string&
append(const basic_string& __str, size_type __pos, size_type __n);
basic_string&
append(const _CharT* __s, size_type __n);
basic_string&
append(const _CharT* __s)
;
basic_string&
append(size_type __n, _CharT __c);
basic_string&
append(initializer_list<_CharT> __l)
;
template<class _InputIterator>
basic_string&
append(_InputIterator __first, _InputIterator __last)
;
void
push_back(_CharT __c)
;
basic_string&
assign(const basic_string& __str);
basic_string&
assign(basic_string&& __str)
;
basic_string&
assign(const basic_string& __str, size_type __pos, size_type __n)
;
basic_string&
assign(const _CharT* __s, size_type __n);
basic_string&
assign(const _CharT* __s)
;
basic_string&
assign(size_type __n, _CharT __c)
;
template<class _InputIterator>
basic_string&
assign(_InputIterator __first, _InputIterator __last)
;
basic_string&
assign(initializer_list<_CharT> __l)
;
void
insert(iterator __p, size_type __n, _CharT __c)
;
template<class _InputIterator>
void
insert(iterator __p, _InputIterator __beg, _InputIterator __end)
;
void
insert(iterator __p, initializer_list<_CharT> __l)
;
basic_string&
insert(size_type __pos1, const basic_string& __str)
;
basic_string&
insert(size_type __pos1, const basic_string& __str,
size_type __pos2, size_type __n)
;
basic_string&
insert(size_type __pos, const _CharT* __s, size_type __n);
basic_string&
insert(size_type __pos, const _CharT* __s)
;
basic_string&
insert(size_type __pos, size_type __n, _CharT __c)
;
iterator
insert(iterator __p, _CharT __c)
;
basic_string&
erase(size_type __pos = 0, size_type __n = npos)
;
iterator
erase(iterator __position)
;
iterator
erase(iterator __first, iterator __last);
void
pop_back()
;
basic_string&
replace(size_type __pos, size_type __n, const basic_string& __str)
;
basic_string&
replace(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2)
;
basic_string&
replace(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2);
basic_string&
replace(size_type __pos, size_type __n1, const _CharT* __s)
;
basic_string&
replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
;
basic_string&
replace(iterator __i1, iterator __i2, const basic_string& __str)
;
basic_string&
replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
;
basic_string&
replace(iterator __i1, iterator __i2, const _CharT* __s)
;
basic_string&
replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
;
template<class _InputIterator>
basic_string&
replace(iterator __i1, iterator __i2,
_InputIterator __k1, _InputIterator __k2)
;
basic_string&
replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
;
basic_string&
replace(iterator __i1, iterator __i2,
const _CharT* __k1, const _CharT* __k2)
;
basic_string&
replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
;
basic_string&
replace(iterator __i1, iterator __i2,
const_iterator __k1, const_iterator __k2)
;
basic_string& replace(iterator __i1, iterator __i2,
initializer_list<_CharT> __l)
;
private:
template<class _Integer>
basic_string&
_M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n,
_Integer __val, __true_type)
;
template<class _InputIterator>
basic_string&
_M_replace_dispatch(iterator __i1, 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_safe(size_type __pos1, size_type __n1, const _CharT* __s,
size_type __n2);
template<class _InIterator>
static _CharT*
_S_construct_aux(_InIterator __beg, _InIterator __end,
const _Alloc& __a, __false_type)
;
template<class _Integer>
static _CharT*
_S_construct_aux(_Integer __beg, _Integer __end,
const _Alloc& __a, __true_type)
;
static _CharT*
_S_construct_aux_2(size_type __req, _CharT __c, const _Alloc& __a)
;
template<class _InIterator>
static _CharT*
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a)
;
template<class _InIterator>
static _CharT*
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
input_iterator_tag);
template<class _FwdIterator>
static _CharT*
_S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a,
forward_iterator_tag);
static _CharT*
_S_construct(size_type __req, _CharT __c, const _Alloc& __a);
public:
size_type
copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
void
swap(basic_string& __s);
const _CharT*
c_str() const noexcept
{ return _M_data(); }
const _CharT*
data() const noexcept
{ return _M_data(); }
allocator_type
get_allocator() const noexcept
{ return _M_dataplus; }
size_type
find(const _CharT* __s, size_type __pos, size_type __n) const;
size_type
find(const basic_string& __str, size_type __pos = 0) const
noexcept
{ return this->find(__str.data(), __pos, __str.size()); }
size_type
find(const _CharT* __s, size_type __pos = 0) const
{
;
return this->find(__s, __pos, traits_type::length(__s));
}
size_type
find(_CharT __c, size_type __pos = 0) const noexcept;
size_type
rfind(const basic_string& __str, size_type __pos = npos) const
noexcept
{ return this->rfind(__str.data(), __pos, __str.size()); }
size_type
rfind(const _CharT* __s, size_type __pos, size_type __n) const;
size_type
rfind(const _CharT* __s, size_type __pos = npos) const
;
size_type
rfind(_CharT __c, size_type __pos = npos) const noexcept;
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()); }
size_type
find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
size_type
find_first_of(const _CharT* __s, size_type __pos = 0) const
;
size_type
find_first_of(_CharT __c, size_type __pos = 0) const noexcept
{ return this->find(__c, __pos); }
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()); }
size_type
find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
size_type
find_last_of(const _CharT* __s, size_type __pos = npos) const
;
size_type
find_last_of(_CharT __c, size_type __pos = npos) const noexcept
{ return this->rfind(__c, __pos); }
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()); }
size_type
find_first_not_of(const _CharT* __s, size_type __pos,
size_type __n) const;
size_type
find_first_not_of(const _CharT* __s, size_type __pos = 0) const
;
size_type
find_first_not_of(_CharT __c, size_type __pos = 0) const
noexcept;
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()); }
size_type
find_last_not_of(const _CharT* __s, size_type __pos,
size_type __n) const;
size_type
find_last_not_of(const _CharT* __s, size_type __pos = npos) const
;
size_type
find_last_not_of(_CharT __c, size_type __pos = npos) const
noexcept;
basic_string
substr(size_type __pos = 0, size_type __n = npos) const
;
int
compare(const basic_string& __str) const
;
int
compare(size_type __pos, size_type __n, const basic_string& __str) const;
int
compare(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2) const;
int
compare(const _CharT* __s) const;
int
compare(size_type __pos, size_type __n1, const _CharT* __s) const;
int
compare(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2) const;
};
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)
;
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>
basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
basic_string<_CharT, _Traits, _Alloc>&& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
basic_string<_CharT, _Traits, _Alloc>&& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const _CharT* __lhs,
basic_string<_CharT, _Traits, _Alloc>&& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(_CharT __lhs,
basic_string<_CharT, _Traits, _Alloc>&& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
_CharT __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
operator==(const basic_string<_CharT>& __lhs,
const basic_string<_CharT>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator==(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator!=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
void
swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
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);
template<typename _CharT, typename _Traits, typename _Alloc>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os,
const basic_string<_CharT, _Traits, _Alloc>& __str)
;
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);
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Alloc>& __str)
;
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)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>&& __is,
basic_string<_CharT, _Traits, _Alloc>& __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);
}
#define _STRING_CONVERSIONS_H 1
#undef __need_mbstate_t
#undef __need_wint_t
#define _STDIO_H 1
extern "C" {
#define __need_size_t
#define __need_NULL
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define __need_FILE
#define __need___FILE
#undef __need_FILE
#undef __need___FILE
#define _STDIO_USES_IOSTREAM
#define _IO_STDIO_H
#define _G_config_h 1
#define __need_size_t
#define __need_NULL
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define __need_mbstate_t
#undef __need_mbstate_t
#undef __need_wint_t
typedef struct
{
__off_t __pos;
__mbstate_t __state;
} _G_fpos_t;
typedef struct
{
__off64_t __pos;
__mbstate_t __state;
} _G_fpos64_t;
#define _G_va_list __gnuc_va_list
#define _G_HAVE_MMAP 1
#define _G_HAVE_MREMAP 1
#define _G_IO_IO_FILE_VERSION 0x20001
#define _G_HAVE_ST_BLKSIZE defined (_STATBUF_ST_BLKSIZE)
#define _G_BUFSIZ 8192
#define _IO_fpos_t _G_fpos_t
#define _IO_fpos64_t _G_fpos64_t
#define _IO_size_t size_t
#define _IO_ssize_t __ssize_t
#define _IO_off_t __off_t
#define _IO_off64_t __off64_t
#define _IO_pid_t __pid_t
#define _IO_uid_t __uid_t
#define _IO_iconv_t _G_iconv_t
#define _IO_HAVE_ST_BLKSIZE _G_HAVE_ST_BLKSIZE
#define _IO_BUFSIZ _G_BUFSIZ
#define _IO_va_list _G_va_list
#define _IO_wint_t wint_t
#define __need___va_list
#undef __need___va_list
#undef _IO_va_list
#define _IO_va_list __gnuc_va_list
#define _IO_UNIFIED_JUMPTABLES 1
#define EOF (-1)
#define _IOS_INPUT 1
#define _IOS_OUTPUT 2
#define _IOS_ATEND 4
#define _IOS_APPEND 8
#define _IOS_TRUNC 16
#define _IOS_NOCREATE 32
#define _IOS_NOREPLACE 64
#define _IOS_BIN 128
#define _IO_MAGIC 0xFBAD0000
#define _OLD_STDIO_MAGIC 0xFABC0000
#define _IO_MAGIC_MASK 0xFFFF0000
#define _IO_USER_BUF 1
#define _IO_UNBUFFERED 2
#define _IO_NO_READS 4
#define _IO_NO_WRITES 8
#define _IO_EOF_SEEN 0x10
#define _IO_ERR_SEEN 0x20
#define _IO_DELETE_DONT_CLOSE 0x40
#define _IO_LINKED 0x80
#define _IO_IN_BACKUP 0x100
#define _IO_LINE_BUF 0x200
#define _IO_TIED_PUT_GET 0x400
#define _IO_CURRENTLY_PUTTING 0x800
#define _IO_IS_APPENDING 0x1000
#define _IO_IS_FILEBUF 0x2000
#define _IO_BAD_SEEN 0x4000
#define _IO_USER_LOCK 0x8000
#define _IO_FLAGS2_MMAP 1
#define _IO_FLAGS2_NOTCANCEL 2
#define _IO_FLAGS2_USER_WBUF 8
#define _IO_SKIPWS 01
#define _IO_LEFT 02
#define _IO_RIGHT 04
#define _IO_INTERNAL 010
#define _IO_DEC 020
#define _IO_OCT 040
#define _IO_HEX 0100
#define _IO_SHOWBASE 0200
#define _IO_SHOWPOINT 0400
#define _IO_UPPERCASE 01000
#define _IO_SHOWPOS 02000
#define _IO_SCIENTIFIC 04000
#define _IO_FIXED 010000
#define _IO_UNITBUF 020000
#define _IO_STDIO 040000
#define _IO_DONT_CLOSE 0100000
#define _IO_BOOLALPHA 0200000
struct _IO_jump_t; struct _IO_FILE;
typedef void _IO_lock_t;
struct _IO_marker {
struct _IO_marker *_next;
struct _IO_FILE *_sbuf;
int _pos;
};
enum __codecvt_result
{
__codecvt_ok,
__codecvt_partial,
__codecvt_error,
__codecvt_noconv
};
struct _IO_FILE {
int _flags;
#define _IO_file_flags _flags
char* _IO_read_ptr;
char* _IO_read_end;
char* _IO_read_base;
char* _IO_write_base;
char* _IO_write_ptr;
char* _IO_write_end;
char* _IO_buf_base;
char* _IO_buf_end;
char *_IO_save_base;
char *_IO_backup_base;
char *_IO_save_end;
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
int _flags2;
__off_t _old_offset;
#define __HAVE_COLUMN
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
_IO_lock_t *_lock;
__off64_t _offset;
void *__pad1;
void *__pad2;
void *__pad3;
void *__pad4;
size_t __pad5;
int _mode;
char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
};
struct _IO_FILE_plus;
extern struct _IO_FILE_plus _IO_2_1_stdin_;
extern struct _IO_FILE_plus _IO_2_1_stdout_;
extern struct _IO_FILE_plus _IO_2_1_stderr_;
#define _IO_stdin ((_IO_FILE*)(&_IO_2_1_stdin_))
#define _IO_stdout ((_IO_FILE*)(&_IO_2_1_stdout_))
#define _IO_stderr ((_IO_FILE*)(&_IO_2_1_stderr_))
typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
typedef __ssize_t __io_write_fn (void *__cookie, const char *__buf,
size_t __n);
typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
typedef int __io_close_fn (void *__cookie);
typedef __io_read_fn cookie_read_function_t;
typedef __io_write_fn cookie_write_function_t;
typedef __io_seek_fn cookie_seek_function_t;
typedef __io_close_fn cookie_close_function_t;
typedef struct
{
__io_read_fn *read;
__io_write_fn *write;
__io_seek_fn *seek;
__io_close_fn *close;
} _IO_cookie_io_functions_t;
typedef _IO_cookie_io_functions_t cookie_io_functions_t;
struct _IO_cookie_file;
extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
void *__cookie, _IO_cookie_io_functions_t __fns);
extern "C" {
extern int __underflow (_IO_FILE *);
extern int __uflow (_IO_FILE *);
extern int __overflow (_IO_FILE *, int);
#define _IO_BE(expr,res) __builtin_expect ((expr), res)
#define _IO_getc_unlocked(_fp) (_IO_BE ((_fp)->_IO_read_ptr >= (_fp)->_IO_read_end, 0) ? __uflow (_fp) : *(unsigned char *) (_fp)->_IO_read_ptr++)
#define _IO_peekc_unlocked(_fp) (_IO_BE ((_fp)->_IO_read_ptr >= (_fp)->_IO_read_end, 0) && __underflow (_fp) == EOF ? EOF : *(unsigned char *) (_fp)->_IO_read_ptr)
#define _IO_putc_unlocked(_ch,_fp) (_IO_BE ((_fp)->_IO_write_ptr >= (_fp)->_IO_write_end, 0) ? __overflow (_fp, (unsigned char) (_ch)) : (unsigned char) (*(_fp)->_IO_write_ptr++ = (_ch)))
#define _IO_feof_unlocked(__fp) (((__fp)->_flags & _IO_EOF_SEEN) != 0)
#define _IO_ferror_unlocked(__fp) (((__fp)->_flags & _IO_ERR_SEEN) != 0)
extern int _IO_getc (_IO_FILE *__fp);
extern int _IO_putc (int __c, _IO_FILE *__fp);
extern int _IO_feof (_IO_FILE *__fp) throw ();
extern int _IO_ferror (_IO_FILE *__fp) throw ();
extern int _IO_peekc_locked (_IO_FILE *__fp);
#define _IO_PENDING_OUTPUT_COUNT(_fp) ((_fp)->_IO_write_ptr - (_fp)->_IO_write_base)
extern void _IO_flockfile (_IO_FILE *) throw ();
extern void _IO_funlockfile (_IO_FILE *) throw ();
extern int _IO_ftrylockfile (_IO_FILE *) throw ();
#define _IO_peekc(_fp) _IO_peekc_unlocked (_fp)
#define _IO_flockfile(_fp)
#define _IO_funlockfile(_fp)
#define _IO_ftrylockfile(_fp)
#define _IO_cleanup_region_start(_fct,_fp)
#define _IO_cleanup_region_end(_Doit)
extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
__gnuc_va_list, int *__restrict);
extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
__gnuc_va_list);
extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);
extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);
extern void _IO_free_backup_area (_IO_FILE *) throw ();
}
typedef __gnuc_va_list va_list;
#define _VA_LIST_DEFINED
typedef _G_fpos_t fpos_t;
typedef _G_fpos64_t fpos64_t;
#define _IOFBF 0
#define _IOLBF 1
#define _IONBF 2
#define BUFSIZ _IO_BUFSIZ
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2
#define SEEK_DATA 3
#define SEEK_HOLE 4
#define P_tmpdir "/tmp"
#define L_tmpnam 20
#define TMP_MAX 238328
#define FILENAME_MAX 4096
#define L_ctermid 9
#define L_cuserid 9
#undef FOPEN_MAX
#define FOPEN_MAX 16
extern struct _IO_FILE *stdin;
extern struct _IO_FILE *stdout;
extern struct _IO_FILE *stderr;
#define stdin stdin
#define stdout stdout
#define stderr stderr
extern int remove (const char *__filename) throw ();
extern int rename (const char *__old, const char *__new) throw ();
extern int renameat (int __oldfd, const char *__old, int __newfd,
const char *__new) throw ();
extern FILE *tmpfile (void) ;
extern FILE *tmpfile64 (void) ;
extern char *tmpnam (char *__s) throw () ;
extern char *tmpnam_r (char *__s) throw () ;
extern char *tempnam (const char *__dir, const char *__pfx)
throw () __attribute__ ((__malloc__)) ;
extern int fclose (FILE *__stream);
extern int fflush (FILE *__stream);
extern int fflush_unlocked (FILE *__stream);
extern int fcloseall (void);
extern FILE *fopen (const char *__restrict __filename,
const char *__restrict __modes) ;
extern FILE *freopen (const char *__restrict __filename,
const char *__restrict __modes,
FILE *__restrict __stream) ;
extern FILE *fopen64 (const char *__restrict __filename,
const char *__restrict __modes) ;
extern FILE *freopen64 (const char *__restrict __filename,
const char *__restrict __modes,
FILE *__restrict __stream) ;
extern FILE *fdopen (int __fd, const char *__modes) throw () ;
extern FILE *fopencookie (void *__restrict __magic_cookie,
const char *__restrict __modes,
_IO_cookie_io_functions_t __io_funcs) throw () ;
extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
throw () ;
extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ;
extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();
extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
int __modes, size_t __n) throw ();
extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
size_t __size) throw ();
extern void setlinebuf (FILE *__stream) throw ();
extern int fprintf (FILE *__restrict __stream,
const char *__restrict __format, ...);
extern int printf (const char *__restrict __format, ...);
extern int sprintf (char *__restrict __s,
const char *__restrict __format, ...) throw ();
extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg);
extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
extern int vsprintf (char *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg) throw ();
extern int snprintf (char *__restrict __s, size_t __maxlen,
const char *__restrict __format, ...)
throw () __attribute__ ((__format__ (__printf__, 3, 4)));
extern int vsnprintf (char *__restrict __s, size_t __maxlen,
const char *__restrict __format, __gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__printf__, 3, 0)));
extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
__gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__printf__, 2, 0))) ;
extern int __asprintf (char **__restrict __ptr,
const char *__restrict __fmt, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
extern int asprintf (char **__restrict __ptr,
const char *__restrict __fmt, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
extern int vdprintf (int __fd, const char *__restrict __fmt,
__gnuc_va_list __arg)
__attribute__ ((__format__ (__printf__, 2, 0)));
extern int dprintf (int __fd, const char *__restrict __fmt, ...)
__attribute__ ((__format__ (__printf__, 2, 3)));
extern int fscanf (FILE *__restrict __stream,
const char *__restrict __format, ...) ;
extern int scanf (const char *__restrict __format, ...) ;
extern int sscanf (const char *__restrict __s,
const char *__restrict __format, ...) throw ();
extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg)
__attribute__ ((__format__ (__scanf__, 2, 0))) ;
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
__attribute__ ((__format__ (__scanf__, 1, 0))) ;
extern int vsscanf (const char *__restrict __s,
const char *__restrict __format, __gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
extern int fgetc (FILE *__stream);
extern int getc (FILE *__stream);
extern int getchar (void);
#define getc(_fp) _IO_getc (_fp)
extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
extern int fgetc_unlocked (FILE *__stream);
extern int fputc (int __c, FILE *__stream);
extern int putc (int __c, FILE *__stream);
extern int putchar (int __c);
#define putc(_ch,_fp) _IO_putc (_ch, _fp)
extern int fputc_unlocked (int __c, FILE *__stream);
extern int putc_unlocked (int __c, FILE *__stream);
extern int putchar_unlocked (int __c);
extern int getw (FILE *__stream);
extern int putw (int __w, FILE *__stream);
extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
;
extern char *gets (char *__s) __attribute__ ((__deprecated__));
extern char *fgets_unlocked (char *__restrict __s, int __n,
FILE *__restrict __stream) ;
extern __ssize_t __getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) ;
extern __ssize_t getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) ;
extern __ssize_t getline (char **__restrict __lineptr,
size_t *__restrict __n,
FILE *__restrict __stream) ;
extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
extern int puts (const char *__s);
extern int ungetc (int __c, FILE *__stream);
extern size_t fread (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite (const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __s);
extern int fputs_unlocked (const char *__restrict __s,
FILE *__restrict __stream);
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream);
extern int fseek (FILE *__stream, long int __off, int __whence);
extern long int ftell (FILE *__stream) ;
extern void rewind (FILE *__stream);
extern int fseeko (FILE *__stream, __off_t __off, int __whence);
extern __off_t ftello (FILE *__stream) ;
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
extern int fsetpos (FILE *__stream, const fpos_t *__pos);
extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
extern __off64_t ftello64 (FILE *__stream) ;
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos);
extern void clearerr (FILE *__stream) throw ();
extern int feof (FILE *__stream) throw () ;
extern int ferror (FILE *__stream) throw () ;
extern void clearerr_unlocked (FILE *__stream) throw ();
extern int feof_unlocked (FILE *__stream) throw () ;
extern int ferror_unlocked (FILE *__stream) throw () ;
extern void perror (const char *__s);
extern int sys_nerr;
extern const char *const sys_errlist[];
extern int _sys_nerr;
extern const char *const _sys_errlist[];
extern int fileno (FILE *__stream) throw () ;
extern int fileno_unlocked (FILE *__stream) throw () ;
extern FILE *popen (const char *__command, const char *__modes) ;
extern int pclose (FILE *__stream);
extern char *ctermid (char *__s) throw ();
extern char *cuserid (char *__s);
struct obstack;
extern int obstack_printf (struct obstack *__restrict __obstack,
const char *__restrict __format, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3)));
extern int obstack_vprintf (struct obstack *__restrict __obstack,
const char *__restrict __format,
__gnuc_va_list __args)
throw () __attribute__ ((__format__ (__printf__, 2, 0)));
extern void flockfile (FILE *__stream) throw ();
extern int ftrylockfile (FILE *__stream) throw () ;
extern void funlockfile (FILE *__stream) throw ();
}
#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
{
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;
}
#define _ERRNO_H 1
extern "C" {
#undef EDOM
#undef EILSEQ
#undef ERANGE
#define _ASM_GENERIC_ERRNO_H
#define _ASM_GENERIC_ERRNO_BASE_H
#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 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
#define ENOTSUP EOPNOTSUPP
extern int *__errno_location (void) throw () __attribute__ ((__const__));
#define errno (*__errno_location ())
#undef __need_Emath
extern char *program_invocation_name, *program_invocation_short_name;
}
typedef int error_t;
#define __error_t_defined 1
#undef __need_error_t
#define _GLIBCXX_CERRNO 1
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)
;
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, ...)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
int
stoi(const string& __str, size_t* __idx = 0, int __base = 10)
;
long
stol(const string& __str, size_t* __idx = 0, int __base = 10)
;
unsigned long
stoul(const string& __str, size_t* __idx = 0, int __base = 10)
;
long long
stoll(const string& __str, size_t* __idx = 0, int __base = 10)
;
unsigned long long
stoull(const string& __str, size_t* __idx = 0, int __base = 10)
;
float
stof(const string& __str, size_t* __idx = 0)
;
double
stod(const string& __str, size_t* __idx = 0)
;
long double
stold(const string& __str, size_t* __idx = 0)
;
string
to_string(int __val)
;
string
to_string(unsigned __val)
;
string
to_string(long __val)
;
string
to_string(unsigned long __val)
;
string
to_string(long long __val)
;
string
to_string(unsigned long long __val)
;
string
to_string(float __val)
;
string
to_string(double __val)
;
string
to_string(long double __val)
;
int
stoi(const wstring& __str, size_t* __idx = 0, int __base = 10)
;
long
stol(const wstring& __str, size_t* __idx = 0, int __base = 10)
;
unsigned long
stoul(const wstring& __str, size_t* __idx = 0, int __base = 10)
;
long long
stoll(const wstring& __str, size_t* __idx = 0, int __base = 10)
;
unsigned long long
stoull(const wstring& __str, size_t* __idx = 0, int __base = 10)
;
float
stof(const wstring& __str, size_t* __idx = 0)
;
double
stod(const wstring& __str, size_t* __idx = 0)
;
long double
stold(const wstring& __str, size_t* __idx = 0)
;
wstring
to_wstring(int __val)
;
wstring
to_wstring(unsigned __val)
;
wstring
to_wstring(long __val)
;
wstring
to_wstring(unsigned long __val)
;
wstring
to_wstring(long long __val)
;
wstring
to_wstring(unsigned long long __val)
;
wstring
to_wstring(float __val)
;
wstring
to_wstring(double __val)
;
wstring
to_wstring(long double __val)
;
}
#define _FUNCTIONAL_HASH_H 1
#define _HASH_BYTES_H 1
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);
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Result, typename _Arg>
struct __hash_base
{
typedef _Result result_type;
typedef _Arg argument_type;
};
template<typename _Tp>
struct hash;
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); } };
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); } };
#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))
;
template<typename _Tp>
static size_t
hash(const _Tp& __val)
;
template<typename _Tp>
static size_t
__hash_combine(const _Tp& __val, size_t __hash)
;
};
struct _Fnv_hash_impl
{
static size_t
hash(const void* __ptr, size_t __clength,
size_t __seed = static_cast<size_t>(2166136261UL))
;
template<typename _Tp>
static size_t
hash(const _Tp& __val)
;
template<typename _Tp>
static size_t
__hash_combine(const _Tp& __val, size_t __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
{ };
}
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
{ };
}
#define _BASIC_STRING_TCC 1
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>::
_Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4;
template<typename _CharT, typename _Traits, typename _Alloc>
const _CharT
basic_string<_CharT, _Traits, _Alloc>::
_Rep::_S_terminal = _CharT();
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>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[
(sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) /
sizeof(size_type)];
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>
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
{
;
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
{
;
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
{
;
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
{
;
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
{
;
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
{
;
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&);
}
namespace std __attribute__ ((__visibility__ ("default")))
{
class logic_error : public exception
{
string _M_msg;
public:
explicit
logic_error(const string& __arg);
virtual ~logic_error() noexcept;
virtual const char*
what() const noexcept;
};
class domain_error : public logic_error
{
public:
explicit domain_error(const string& __arg);
virtual ~domain_error() noexcept;
};
class invalid_argument : public logic_error
{
public:
explicit invalid_argument(const string& __arg);
virtual ~invalid_argument() noexcept;
};
class length_error : public logic_error
{
public:
explicit length_error(const string& __arg);
virtual ~length_error() noexcept;
};
class out_of_range : public logic_error
{
public:
explicit out_of_range(const string& __arg);
virtual ~out_of_range() noexcept;
};
class runtime_error : public exception
{
string _M_msg;
public:
explicit
runtime_error(const string& __arg);
virtual ~runtime_error() noexcept;
virtual const char*
what() const noexcept;
};
class range_error : public runtime_error
{
public:
explicit range_error(const string& __arg);
virtual ~range_error() noexcept;
};
class overflow_error : public runtime_error
{
public:
explicit overflow_error(const string& __arg);
virtual ~overflow_error() noexcept;
};
class underflow_error : public runtime_error
{
public:
explicit underflow_error(const string& __arg);
virtual ~underflow_error() noexcept;
};
}
#define _TYPEINFO
#pragma GCC visibility push(default)
extern "C++" {
namespace __cxxabiv1
{
class __class_type_info;
}
#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; }
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));
}
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) ;
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
#define BOOST_ASIO_DETAIL_NONCOPYABLE_HPP
namespace boost {
namespace asio {
namespace detail {
class noncopyable
{
protected:
noncopyable() ;
~noncopyable() ;
private:
noncopyable(const noncopyable&);
const noncopyable& operator=(const noncopyable&);
};
}
using boost::asio::detail::noncopyable;
}
}
#define BOOST_ASIO_DETAIL_WRAPPED_HANDLER_HPP
#define BOOST_ASIO_DETAIL_BIND_HANDLER_HPP
#define BOOST_ASIO_DETAIL_HANDLER_ALLOC_HELPERS_HPP
#define BOOST_ASIO_DETAIL_ADDRESSOF_HPP
#define _GLIBCXX_MEMORY 1
#define _STL_CONSTRUCT_H 1
#define _EXT_ALLOC_TRAITS_H 1
#define _ALLOC_TRAITS_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc, typename _Tp>
class __alloctr_rebind_helper
{
template<typename _Alloc2, typename _Tp2>
static constexpr true_type
_S_chk(typename _Alloc2::template rebind<_Tp2>::other*);
template<typename, typename>
static constexpr false_type
_S_chk(...);
public:
using __type = decltype(_S_chk<_Alloc, _Tp>(nullptr));
};
template<typename _Alloc, typename _Tp,
bool = __alloctr_rebind_helper<_Alloc, _Tp>::__type::value>
struct __alloctr_rebind;
template<typename _Alloc, typename _Tp>
struct __alloctr_rebind<_Alloc, _Tp, true>
{
typedef typename _Alloc::template rebind<_Tp>::other __type;
};
template<template<typename, typename...> class _Alloc, typename _Tp,
typename _Up, typename... _Args>
struct __alloctr_rebind<_Alloc<_Up, _Args...>, _Tp, false>
{
typedef _Alloc<_Tp, _Args...> __type;
};
template<typename _Ptr, typename _Tp>
using __alloc_rebind = typename __alloctr_rebind<_Ptr, _Tp>::__type;
template<typename _Alloc>
struct allocator_traits
{
typedef _Alloc allocator_type;
typedef typename _Alloc::value_type value_type;
#define _GLIBCXX_ALLOC_TR_NESTED_TYPE(_NTYPE,_ALT) private: template<typename _Tp> static typename _Tp::_NTYPE _S_ ##_NTYPE ##_helper(_Tp*); static _ALT _S_ ##_NTYPE ##_helper(...); typedef decltype(_S_ ##_NTYPE ##_helper((_Alloc*)0)) __ ##_NTYPE; public:
private: template<typename _Tp> static typename _Tp::pointer _S_pointer_helper(_Tp*); static value_type* _S_pointer_helper(...); typedef decltype(_S_pointer_helper((_Alloc*)0)) __pointer; public:
typedef __pointer pointer;
private: template<typename _Tp> static typename _Tp::const_pointer _S_const_pointer_helper(_Tp*); static typename pointer_traits<pointer>::template rebind<const value_type> _S_const_pointer_helper(...); typedef decltype(_S_const_pointer_helper((_Alloc*)0)) __const_pointer; public:
typedef __const_pointer const_pointer;
private: template<typename _Tp> static typename _Tp::void_pointer _S_void_pointer_helper(_Tp*); static typename pointer_traits<pointer>::template rebind<void> _S_void_pointer_helper(...); typedef decltype(_S_void_pointer_helper((_Alloc*)0)) __void_pointer; public:
typedef __void_pointer void_pointer;
private: template<typename _Tp> static typename _Tp::const_void_pointer _S_const_void_pointer_helper(_Tp*); static typename pointer_traits<pointer>::template rebind<const void> _S_const_void_pointer_helper(...); typedef decltype(_S_const_void_pointer_helper((_Alloc*)0)) __const_void_pointer; public:
typedef __const_void_pointer const_void_pointer;
private: template<typename _Tp> static typename _Tp::difference_type _S_difference_type_helper(_Tp*); static typename pointer_traits<pointer>::difference_type _S_difference_type_helper(...); typedef decltype(_S_difference_type_helper((_Alloc*)0)) __difference_type; public:
typedef __difference_type difference_type;
private: template<typename _Tp> static typename _Tp::size_type _S_size_type_helper(_Tp*); static typename make_unsigned<difference_type>::type _S_size_type_helper(...); typedef decltype(_S_size_type_helper((_Alloc*)0)) __size_type; public:
typedef __size_type size_type;
private: template<typename _Tp> static typename _Tp::propagate_on_container_copy_assignment _S_propagate_on_container_copy_assignment_helper(_Tp*); static false_type _S_propagate_on_container_copy_assignment_helper(...); typedef decltype(_S_propagate_on_container_copy_assignment_helper((_Alloc*)0)) __propagate_on_container_copy_assignment; public:
typedef __propagate_on_container_copy_assignment
propagate_on_container_copy_assignment;
private: template<typename _Tp> static typename _Tp::propagate_on_container_move_assignment _S_propagate_on_container_move_assignment_helper(_Tp*); static false_type _S_propagate_on_container_move_assignment_helper(...); typedef decltype(_S_propagate_on_container_move_assignment_helper((_Alloc*)0)) __propagate_on_container_move_assignment; public:
typedef __propagate_on_container_move_assignment
propagate_on_container_move_assignment;
private: template<typename _Tp> static typename _Tp::propagate_on_container_swap _S_propagate_on_container_swap_helper(_Tp*); static false_type _S_propagate_on_container_swap_helper(...); typedef decltype(_S_propagate_on_container_swap_helper((_Alloc*)0)) __propagate_on_container_swap; public:
typedef __propagate_on_container_swap propagate_on_container_swap;
#undef _GLIBCXX_ALLOC_TR_NESTED_TYPE
template<typename _Tp>
using rebind_alloc = typename __alloctr_rebind<_Alloc, _Tp>::__type;
template<typename _Tp>
using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;
private:
template<typename _Alloc2>
struct __allocate_helper
{
template<typename _Alloc3,
typename = decltype(std::declval<_Alloc3*>()->allocate(
std::declval<size_type>(),
std::declval<const_void_pointer>()))>
static true_type __test(int);
template<typename>
static false_type __test(...);
using type = decltype(__test<_Alloc>(0));
};
template<typename _Alloc2>
using __has_allocate = typename __allocate_helper<_Alloc2>::type;
template<typename _Alloc2,
typename = _Require<__has_allocate<_Alloc2>>>
static pointer
_S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint)
;
template<typename _Alloc2, typename _UnusedHint,
typename = _Require<__not_<__has_allocate<_Alloc2>>>>
static pointer
_S_allocate(_Alloc2& __a, size_type __n, _UnusedHint)
;
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)
;
template<typename _Tp, typename... _Args>
static
_Require<__and_<__not_<__has_construct<_Tp, _Args...>>,
is_constructible<_Tp, _Args...>>>
_S_construct(_Alloc&, _Tp* __p, _Args&&... __args)
;
template<typename _Tp>
struct __destroy_helper
{
template<typename _Alloc2,
typename = decltype(std::declval<_Alloc2*>()->destroy(
std::declval<_Tp*>()))>
static true_type __test(int);
template<typename>
static false_type __test(...);
using type = decltype(__test<_Alloc>(0));
};
template<typename _Tp>
using __has_destroy = typename __destroy_helper<_Tp>::type;
template<typename _Tp>
static _Require<__has_destroy<_Tp>>
_S_destroy(_Alloc& __a, _Tp* __p)
;
template<typename _Tp>
static _Require<__not_<__has_destroy<_Tp>>>
_S_destroy(_Alloc&, _Tp* __p)
;
template<typename _Alloc2>
struct __maxsize_helper
{
template<typename _Alloc3,
typename = decltype(std::declval<_Alloc3*>()->max_size())>
static true_type __test(int);
template<typename>
static false_type __test(...);
using type = decltype(__test<_Alloc2>(0));
};
template<typename _Alloc2>
using __has_max_size = typename __maxsize_helper<_Alloc2>::type;
template<typename _Alloc2,
typename = _Require<__has_max_size<_Alloc2>>>
static size_type
_S_max_size(_Alloc2& __a, int)
;
template<typename _Alloc2,
typename = _Require<__not_<__has_max_size<_Alloc2>>>>
static size_type
_S_max_size(_Alloc2&, ...)
;
template<typename _Alloc2>
struct __select_helper
{
template<typename _Alloc3, typename
= decltype(std::declval<_Alloc3*>()
->select_on_container_copy_construction())>
static true_type __test(int);
template<typename>
static false_type __test(...);
using type = decltype(__test<_Alloc2>(0));
};
template<typename _Alloc2>
using __has_soccc = typename __select_helper<_Alloc2>::type;
template<typename _Alloc2,
typename = _Require<__has_soccc<_Alloc2>>>
static _Alloc2
_S_select(_Alloc2& __a, int)
;
template<typename _Alloc2,
typename = _Require<__not_<__has_soccc<_Alloc2>>>>
static _Alloc2
_S_select(_Alloc2& __a, ...)
;
public:
static pointer
allocate(_Alloc& __a, size_type __n)
;
static pointer
allocate(_Alloc& __a, size_type __n, const_void_pointer __hint)
;
static void deallocate(_Alloc& __a, pointer __p, size_type __n)
;
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)...); }
template <class _Tp>
static void destroy(_Alloc& __a, _Tp* __p)
{ _S_destroy(__a, __p); }
static size_type max_size(const _Alloc& __a) noexcept
{ return _S_max_size(__a, 0); }
static _Alloc
select_on_container_copy_construction(const _Alloc& __rhs)
{ return _S_select(__rhs, 0); }
};
template<typename _Alloc>
void
__do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type)
;
template<typename _Alloc>
void
__do_alloc_on_copy(_Alloc&, const _Alloc&, false_type)
;
template<typename _Alloc>
void __alloc_on_copy(_Alloc& __one, const _Alloc& __two)
;
template<typename _Alloc>
_Alloc __alloc_on_copy(const _Alloc& __a)
;
template<typename _Alloc>
void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type)
;
template<typename _Alloc>
void __do_alloc_on_move(_Alloc&, _Alloc&, false_type)
;
template<typename _Alloc>
void __alloc_on_move(_Alloc& __one, _Alloc& __two)
;
template<typename _Alloc>
void __do_alloc_on_swap(_Alloc& __one, _Alloc& __two, true_type)
;
template<typename _Alloc>
void __do_alloc_on_swap(_Alloc&, _Alloc&, false_type)
;
template<typename _Alloc>
void __alloc_on_swap(_Alloc& __one, _Alloc& __two)
;
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>
{ };
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc>
struct __allocator_always_compares_equal : std::false_type { };
template<typename _Tp>
struct __allocator_always_compares_equal<std::allocator<_Tp>>
: std::true_type { };
template<typename, typename> struct array_allocator;
template<typename _Tp, typename _Array>
struct __allocator_always_compares_equal<array_allocator<_Tp, _Array>>
: std::true_type { };
template<typename> struct bitmap_allocator;
template<typename _Tp>
struct __allocator_always_compares_equal<bitmap_allocator<_Tp>>
: std::true_type { };
template<typename> struct malloc_allocator;
template<typename _Tp>
struct __allocator_always_compares_equal<malloc_allocator<_Tp>>
: std::true_type { };
template<typename> struct mt_allocator;
template<typename _Tp>
struct __allocator_always_compares_equal<mt_allocator<_Tp>>
: std::true_type { };
template<typename> struct new_allocator;
template<typename _Tp>
struct __allocator_always_compares_equal<new_allocator<_Tp>>
: std::true_type { };
template<typename> struct pool_allocator;
template<typename _Tp>
struct __allocator_always_compares_equal<pool_allocator<_Tp>>
: std::true_type { };
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)
;
template<typename _Ptr>
static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
destroy(_Alloc& __a, _Ptr __p)
;
static _Alloc _S_select_on_copy(const _Alloc& __a)
;
static void _S_on_swap(_Alloc& __a, _Alloc& __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 __allocator_always_compares_equal<_Alloc>::value; }
static constexpr bool _S_nothrow_move()
{ return _S_propagate_on_move_assign() || _S_always_equal(); }
static constexpr bool _S_nothrow_swap()
{
using std::swap;
return !_S_propagate_on_swap()
|| noexcept(swap(std::declval<_Alloc&>(), std::declval<_Alloc&>()));
}
template<typename _Tp>
struct rebind
{ typedef typename _Base_type::template rebind_alloc<_Tp> other; };
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _T1, typename... _Args>
void
_Construct(_T1* __p, _Args&&... __args)
;
template<typename _Tp>
void
_Destroy(_Tp* __pointer)
;
template<bool>
struct _Destroy_aux
{
template<typename _ForwardIterator>
static void
__destroy(_ForwardIterator __first, _ForwardIterator __last)
;
};
template<>
struct _Destroy_aux<true>
{
template<typename _ForwardIterator>
static void
__destroy(_ForwardIterator, _ForwardIterator) ;
};
template<typename _ForwardIterator>
void
_Destroy(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Allocator>
void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
_Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Tp>
void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
allocator<_Tp>&)
;
}
#define _STL_UNINITIALIZED_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<bool _TrivialValueTypes>
struct __uninitialized_copy
{
template<typename _InputIterator, typename _ForwardIterator>
static _ForwardIterator
__uninit_copy(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result)
;
};
template<>
struct __uninitialized_copy<true>
{
template<typename _InputIterator, typename _ForwardIterator>
static _ForwardIterator
__uninit_copy(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result)
;
};
template<typename _InputIterator, typename _ForwardIterator>
_ForwardIterator
uninitialized_copy(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result)
;
template<bool _TrivialValueType>
struct __uninitialized_fill
{
template<typename _ForwardIterator, typename _Tp>
static void
__uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x)
;
};
template<>
struct __uninitialized_fill<true>
{
template<typename _ForwardIterator, typename _Tp>
static void
__uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x)
;
};
template<typename _ForwardIterator, typename _Tp>
void
uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x)
;
template<bool _TrivialValueType>
struct __uninitialized_fill_n
{
template<typename _ForwardIterator, typename _Size, typename _Tp>
static _ForwardIterator
__uninit_fill_n(_ForwardIterator __first, _Size __n,
const _Tp& __x)
;
};
template<>
struct __uninitialized_fill_n<true>
{
template<typename _ForwardIterator, typename _Size, typename _Tp>
static _ForwardIterator
__uninit_fill_n(_ForwardIterator __first, _Size __n,
const _Tp& __x)
;
};
template<typename _ForwardIterator, typename _Size, typename _Tp>
_ForwardIterator
uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
;
template<typename _InputIterator, typename _ForwardIterator,
typename _Allocator>
_ForwardIterator
__uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
;
template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
_ForwardIterator
__uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, allocator<_Tp>&)
;
template<typename _InputIterator, typename _ForwardIterator,
typename _Allocator>
_ForwardIterator
__uninitialized_move_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
;
template<typename _InputIterator, typename _ForwardIterator,
typename _Allocator>
_ForwardIterator
__uninitialized_move_if_noexcept_a(_InputIterator __first,
_InputIterator __last,
_ForwardIterator __result,
_Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Tp, typename _Allocator>
void
__uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x, _Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Tp, typename _Tp2>
void
__uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x, allocator<_Tp2>&)
;
template<typename _ForwardIterator, typename _Size, typename _Tp,
typename _Allocator>
_ForwardIterator
__uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
const _Tp& __x, _Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Size, typename _Tp,
typename _Tp2>
_ForwardIterator
__uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
const _Tp& __x, allocator<_Tp2>&)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _ForwardIterator, typename _Allocator>
_ForwardIterator
__uninitialized_copy_move(_InputIterator1 __first1,
_InputIterator1 __last1,
_InputIterator2 __first2,
_InputIterator2 __last2,
_ForwardIterator __result,
_Allocator& __alloc)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _ForwardIterator, typename _Allocator>
_ForwardIterator
__uninitialized_move_copy(_InputIterator1 __first1,
_InputIterator1 __last1,
_InputIterator2 __first2,
_InputIterator2 __last2,
_ForwardIterator __result,
_Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
typename _Allocator>
_ForwardIterator
__uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
const _Tp& __x, _InputIterator __first,
_InputIterator __last, _Allocator& __alloc)
;
template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
typename _Allocator>
void
__uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
_ForwardIterator __first2,
_ForwardIterator __last2, const _Tp& __x,
_Allocator& __alloc)
;
template<bool _TrivialValueType>
struct __uninitialized_default_1
{
template<typename _ForwardIterator>
static void
__uninit_default(_ForwardIterator __first, _ForwardIterator __last)
;
};
template<>
struct __uninitialized_default_1<true>
{
template<typename _ForwardIterator>
static void
__uninit_default(_ForwardIterator __first, _ForwardIterator __last)
;
};
template<bool _TrivialValueType>
struct __uninitialized_default_n_1
{
template<typename _ForwardIterator, typename _Size>
static _ForwardIterator
__uninit_default_n(_ForwardIterator __first, _Size __n)
;
};
template<>
struct __uninitialized_default_n_1<true>
{
template<typename _ForwardIterator, typename _Size>
static _ForwardIterator
__uninit_default_n(_ForwardIterator __first, _Size __n)
;
};
template<typename _ForwardIterator>
void
__uninitialized_default(_ForwardIterator __first,
_ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Size>
_ForwardIterator
__uninitialized_default_n(_ForwardIterator __first, _Size __n)
;
template<typename _ForwardIterator, typename _Allocator>
void
__uninitialized_default_a(_ForwardIterator __first,
_ForwardIterator __last,
_Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Tp>
void
__uninitialized_default_a(_ForwardIterator __first,
_ForwardIterator __last,
allocator<_Tp>&)
;
template<typename _ForwardIterator, typename _Size, typename _Allocator>
_ForwardIterator
__uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
_Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Size, typename _Tp>
_ForwardIterator
__uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
allocator<_Tp>&)
;
template<typename _InputIterator, typename _Size,
typename _ForwardIterator>
_ForwardIterator
__uninitialized_copy_n(_InputIterator __first, _Size __n,
_ForwardIterator __result, input_iterator_tag)
;
template<typename _RandomAccessIterator, typename _Size,
typename _ForwardIterator>
_ForwardIterator
__uninitialized_copy_n(_RandomAccessIterator __first, _Size __n,
_ForwardIterator __result,
random_access_iterator_tag)
;
template<typename _InputIterator, typename _Size, typename _ForwardIterator>
_ForwardIterator
uninitialized_copy_n(_InputIterator __first, _Size __n,
_ForwardIterator __result)
;
}
#define _STL_TEMPBUF_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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);
}
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)
;
};
template<>
struct __uninitialized_construct_buf_dispatch<true>
{
template<typename _Pointer, typename _ForwardIterator>
static void
__ucr(_Pointer, _Pointer, _ForwardIterator) ;
};
template<typename _Pointer, typename _ForwardIterator>
void
__uninitialized_construct_buf(_Pointer __first, _Pointer __last,
_ForwardIterator __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;
}
}
}
#define _STL_RAW_STORAGE_ITERATOR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template <class _OutputIterator, class _Tp>
class raw_storage_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
protected:
_OutputIterator _M_iter;
public:
explicit
raw_storage_iterator(_OutputIterator __x) ;
raw_storage_iterator&
operator*() ;
raw_storage_iterator&
operator=(const _Tp& __element)
;
raw_storage_iterator<_OutputIterator, _Tp>&
operator++()
;
raw_storage_iterator<_OutputIterator, _Tp>
operator++(int)
;
};
}
#define _CONCURRENCE_H 1
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
enum _Lock_policy { _S_single, _S_mutex, _S_atomic };
static const _Lock_policy __default_lock_policy =
_S_atomic;
class __concurrence_lock_error : public std::exception
{
public:
virtual char const*
what() const throw()
;
};
class __concurrence_unlock_error : public std::exception
{
public:
virtual char const*
what() const throw()
;
};
class __concurrence_broadcast_error : public std::exception
{
public:
virtual char const*
what() const throw()
;
};
class __concurrence_wait_error : public std::exception
{
public:
virtual char const*
what() const throw()
;
};
void
__throw_concurrence_lock_error()
;
void
__throw_concurrence_unlock_error()
;
void
__throw_concurrence_broadcast_error()
;
void
__throw_concurrence_wait_error()
;
class __mutex
{
private:
__gthread_mutex_t _M_mutex = { { 0, 0, 0, 0, 0, 0, 0, { 0, 0 } } };
__mutex(const __mutex&);
__mutex& operator=(const __mutex&);
public:
__mutex()
;
void lock()
;
void unlock()
;
__gthread_mutex_t* gthread_mutex(void)
;
};
class __recursive_mutex
{
private:
__gthread_recursive_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, 0, 0, { 0, 0 } } };
__recursive_mutex(const __recursive_mutex&);
__recursive_mutex& operator=(const __recursive_mutex&);
public:
__recursive_mutex()
;
void lock()
;
void unlock()
;
__gthread_recursive_mutex_t* gthread_recursive_mutex(void)
;
};
class __scoped_lock
{
public:
typedef __mutex __mutex_type;
private:
__mutex_type& _M_device;
__scoped_lock(const __scoped_lock&);
__scoped_lock& operator=(const __scoped_lock&);
public:
explicit __scoped_lock(__mutex_type& __name)
;
~__scoped_lock() throw()
;
};
class __cond
{
private:
__gthread_cond_t _M_cond = { { 0, 0, 0, 0, 0, (void *) 0, 0, 0 } };
__cond(const __cond&);
__cond& operator=(const __cond&);
public:
__cond()
;
void broadcast()
;
void wait(__mutex *mutex)
;
void wait_recursive(__recursive_mutex *mutex)
;
};
}
#define _USES_ALLOCATOR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
struct allocator_arg_t { };
constexpr allocator_arg_t allocator_arg = allocator_arg_t();
template<typename _Tp> class __has_allocator_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::allocator_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_allocator_type : public __has_allocator_type_helper <typename remove_cv<_Tp>::type>::type { };
template<typename _Tp, typename _Alloc,
bool = __has_allocator_type<_Tp>::value>
struct __uses_allocator_helper
: false_type { };
template<typename _Tp, typename _Alloc>
struct __uses_allocator_helper<_Tp, _Alloc, true>
: is_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
{ };
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>
__uses_alloc_t<_Tp, _Alloc, _Args...>
__use_alloc(const _Alloc& __a)
;
}
#define _GLIBCXX_FUNCTIONAL 1
#define _GLIBCXX_TUPLE 1
#define _GLIBCXX_ARRAY 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp, std::size_t _Nm>
struct __array_traits
{
typedef _Tp _Type[_Nm];
static constexpr _Tp&
_S_ref(const _Type& __t, std::size_t __n) noexcept
{ return const_cast<_Tp&>(__t[__n]); }
};
template<typename _Tp>
struct __array_traits<_Tp, 0>
{
struct _Type { };
static constexpr _Tp&
_S_ref(const _Type&, std::size_t) noexcept
{ return *static_cast<_Tp*>(nullptr); }
};
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)
;
void
swap(array& __other)
noexcept(noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())))
{ 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 std::__addressof(_AT_Type::_S_ref(_M_elems, 0)); }
const_pointer
data() const noexcept
{ return std::__addressof(_AT_Type::_S_ref(_M_elems, 0)); }
};
template<typename _Tp, std::size_t _Nm>
bool
operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
;
template<typename _Tp, std::size_t _Nm>
bool
operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
;
template<typename _Tp, std::size_t _Nm>
bool
operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
;
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 void
swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
noexcept(noexcept(__one.swap(__two)))
{ __one.swap(__two); }
template<std::size_t _Int, typename _Tp, std::size_t _Nm>
constexpr _Tp&
get(array<_Tp, _Nm>& __arr) noexcept
{
static_assert(_Int < _Nm, "index is out of 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, "index is out of 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, "index is out of 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;
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<std::size_t _Idx, typename _Head, bool _IsEmptyNotFinal>
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;
};
template<std::size_t _Idx, typename... _Elements>
struct _Tuple_impl;
template<std::size_t _Idx>
struct _Tuple_impl<_Idx>
{
template<std::size_t, typename...> friend class _Tuple_impl;
_Tuple_impl() = default;
template<typename _Alloc>
_Tuple_impl(allocator_arg_t, const _Alloc&) { }
template<typename _Alloc>
_Tuple_impl(allocator_arg_t, const _Alloc&, const _Tuple_impl&) { }
template<typename _Alloc>
_Tuple_impl(allocator_arg_t, const _Alloc&, _Tuple_impl&&) { }
protected:
void _M_swap(_Tuple_impl&) noexcept { }
};
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, typename... _Tail>
struct _Tuple_impl<_Idx, _Head, _Tail...>
: public _Tuple_impl<_Idx + 1, _Tail...>,
private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value>
{
template<std::size_t, typename...> friend class _Tuple_impl;
typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _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(noexcept(swap(std::declval<_Head&>(),
std::declval<_Head&>()))
&& 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<typename... _Elements>
class tuple : public _Tuple_impl<0, _Elements...>
{
typedef _Tuple_impl<0, _Elements...> _Inherited;
public:
constexpr tuple()
: _Inherited() { }
explicit
constexpr tuple(const _Elements&... __elements)
: _Inherited(__elements...) { }
template<typename... _UElements, typename = typename
enable_if<__and_<is_convertible<_UElements,
_Elements>...>::value>::type>
explicit
constexpr tuple(_UElements&&... __elements)
: _Inherited(std::forward<_UElements>(__elements)...) { }
constexpr tuple(const tuple&) = default;
constexpr tuple(tuple&&) = default;
template<typename... _UElements, typename = typename
enable_if<__and_<is_convertible<const _UElements&,
_Elements>...>::value>::type>
constexpr tuple(const tuple<_UElements...>& __in)
: _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
{ }
template<typename... _UElements, typename = typename
enable_if<__and_<is_convertible<_UElements,
_Elements>...>::value>::type>
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>
tuple(allocator_arg_t __tag, const _Alloc& __a,
const _Elements&... __elements)
: _Inherited(__tag, __a, __elements...) { }
template<typename _Alloc, typename... _UElements, typename = typename
enable_if<sizeof...(_UElements)
== sizeof...(_Elements)>::type>
tuple(allocator_arg_t __tag, const _Alloc& __a,
_UElements&&... __elements)
: _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
{ }
template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
: _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
: _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
template<typename _Alloc, typename... _UElements, typename = typename
enable_if<sizeof...(_UElements)
== sizeof...(_Elements)>::type>
tuple(allocator_arg_t __tag, const _Alloc& __a,
const tuple<_UElements...>& __in)
: _Inherited(__tag, __a,
static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
{ }
template<typename _Alloc, typename... _UElements, typename = typename
enable_if<sizeof...(_UElements)
== sizeof...(_Elements)>::type>
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 = typename
enable_if<sizeof...(_UElements)
== sizeof...(_Elements)>::type>
tuple&
operator=(const tuple<_UElements...>& __in)
{
static_cast<_Inherited&>(*this) = __in;
return *this;
}
template<typename... _UElements, typename = typename
enable_if<sizeof...(_UElements)
== sizeof...(_Elements)>::type>
tuple&
operator=(tuple<_UElements...>&& __in)
{
static_cast<_Inherited&>(*this) = std::move(__in);
return *this;
}
void
swap(tuple& __in)
noexcept(noexcept(__in._M_swap(__in)))
{ _Inherited::_M_swap(__in); }
};
template<>
class tuple<>
{
public:
void swap(tuple&) noexcept { }
};
template<typename _T1, typename _T2>
class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
{
typedef _Tuple_impl<0, _T1, _T2> _Inherited;
public:
constexpr tuple()
: _Inherited() { }
explicit
constexpr tuple(const _T1& __a1, const _T2& __a2)
: _Inherited(__a1, __a2) { }
template<typename _U1, typename _U2, typename = typename
enable_if<__and_<is_convertible<_U1, _T1>,
is_convertible<_U2, _T2>>::value>::type>
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 = typename
enable_if<__and_<is_convertible<const _U1&, _T1>,
is_convertible<const _U2&, _T2>>::value>::type>
constexpr tuple(const tuple<_U1, _U2>& __in)
: _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
template<typename _U1, typename _U2, typename = typename
enable_if<__and_<is_convertible<_U1, _T1>,
is_convertible<_U2, _T2>>::value>::type>
constexpr tuple(tuple<_U1, _U2>&& __in)
: _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
template<typename _U1, typename _U2, typename = typename
enable_if<__and_<is_convertible<const _U1&, _T1>,
is_convertible<const _U2&, _T2>>::value>::type>
constexpr tuple(const pair<_U1, _U2>& __in)
: _Inherited(__in.first, __in.second) { }
template<typename _U1, typename _U2, typename = typename
enable_if<__and_<is_convertible<_U1, _T1>,
is_convertible<_U2, _T2>>::value>::type>
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>
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>
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>
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>
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>
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>
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)
;
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<std::size_t __i, typename _Tp>
struct tuple_element;
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<std::size_t __i, typename _Tp>
using __tuple_element_t = typename tuple_element<__i, _Tp>::type;
template<std::size_t __i, typename _Tp>
struct tuple_element<__i, const _Tp>
{
typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type;
};
template<std::size_t __i, typename _Tp>
struct tuple_element<__i, volatile _Tp>
{
typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type;
};
template<std::size_t __i, typename _Tp>
struct tuple_element<__i, const volatile _Tp>
{
typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type;
};
template<typename _Tp>
struct tuple_size;
template<typename _Tp>
struct tuple_size<const _Tp>
: integral_constant<size_t, tuple_size<_Tp>::value> { };
template<typename _Tp>
struct tuple_size<volatile _Tp>
: integral_constant<size_t, tuple_size<_Tp>::value> { };
template<typename _Tp>
struct tuple_size<const volatile _Tp>
: integral_constant<size_t, tuple_size<_Tp>::value> { };
template<typename... _Elements>
struct tuple_size<tuple<_Elements...>>
: public integral_constant<std::size_t, sizeof...(_Elements)> { };
template<std::size_t __i, typename _Head, typename... _Tail>
constexpr _Head&
__get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
{ return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
template<std::size_t __i, typename _Head, typename... _Tail>
constexpr const _Head&
__get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
{ return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
template<std::size_t __i, typename... _Elements>
constexpr __tuple_element_t<__i, tuple<_Elements...>>&
get(tuple<_Elements...>& __t) noexcept
{ return std::__get_helper<__i>(__t); }
template<std::size_t __i, typename... _Elements>
constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
get(const tuple<_Elements...>& __t) noexcept
{ return std::__get_helper<__i>(__t); }
template<std::size_t __i, typename... _Elements>
constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
get(tuple<_Elements...>&& __t) noexcept
{
typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
return std::forward<__element_type&&>(std::get<__i>(__t));
}
template<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>
tuple<_Elements&&...>
forward_as_tuple(_Elements&&... __args) noexcept
{ return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
template<typename>
struct __is_tuple_like_impl : false_type
{ };
template<typename... _Tps>
struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
{ };
template<typename _T1, typename _T2>
struct __is_tuple_like_impl<pair<_T1, _T2>> : true_type
{ };
template<typename _Tp, std::size_t _Nm>
struct __is_tuple_like_impl<array<_Tp, _Nm>> : true_type
{ };
template<typename _Tp>
struct __is_tuple_like
: public __is_tuple_like_impl<typename std::remove_cv
<typename std::remove_reference<_Tp>::type>::type>::type
{ };
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>
inline tuple<_Elements&...>
tie(_Elements&... __args) noexcept
{ return tuple<_Elements&...>(__args...); }
template<typename... _Elements>
inline void
swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
struct _Swallow_assign
{
template<class _Tp>
const _Swallow_assign&
operator=(const _Tp&) const
{ return *this; }
};
const _Swallow_assign ignore{};
template<typename... _Types, typename _Alloc>
struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _MemberPointer>
class _Mem_fn;
template<typename _Tp, typename _Class>
_Mem_fn<_Tp _Class::*>
mem_fn(_Tp _Class::*) noexcept;
template<typename _Tp> class __has_result_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::result_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_result_type : public __has_result_type_helper <typename remove_cv<_Tp>::type>::type { };
template<bool _Has_result_type, typename _Functor>
struct _Maybe_get_result_type
{ };
template<typename _Functor>
struct _Maybe_get_result_type<true, _Functor>
{ typedef typename _Functor::result_type result_type; };
template<typename _Functor>
struct _Weak_result_type_impl
: _Maybe_get_result_type<__has_result_type<_Functor>::value, _Functor>
{ };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...)>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......)>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...) const>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......) const>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)
const volatile>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)
const volatile>
{ typedef _Res result_type; };
template<typename _Functor>
struct _Weak_result_type
: _Weak_result_type_impl<typename remove_cv<_Functor>::type>
{ };
template<typename _Functor, typename... _Args>
typename enable_if<
(!is_member_pointer<_Functor>::value
&& !is_function<_Functor>::value
&& !is_function<typename remove_pointer<_Functor>::type>::value),
typename result_of<_Functor&(_Args&&...)>::type
>::type
__invoke(_Functor& __f, _Args&&... __args)
;
template<typename _Functor, typename... _Args>
typename enable_if<
(is_member_pointer<_Functor>::value
&& !is_function<_Functor>::value
&& !is_function<typename remove_pointer<_Functor>::type>::value),
typename result_of<_Functor(_Args&&...)>::type
>::type
__invoke(_Functor& __f, _Args&&... __args)
;
template<typename _Functor, typename... _Args>
typename enable_if<
(is_pointer<_Functor>::value
&& is_function<typename remove_pointer<_Functor>::type>::value),
typename result_of<_Functor(_Args&&...)>::type
>::type
__invoke(_Functor __f, _Args&&... __args)
;
template<bool _Unary, bool _Binary, typename _Tp>
struct _Reference_wrapper_base_impl;
template<typename _Tp>
struct _Reference_wrapper_base_impl<false, false, _Tp>
: _Weak_result_type<_Tp>
{ };
template<typename _Tp>
struct _Reference_wrapper_base_impl<true, false, _Tp>
: _Weak_result_type<_Tp>
{
typedef typename _Tp::argument_type argument_type;
};
template<typename _Tp>
struct _Reference_wrapper_base_impl<false, true, _Tp>
: _Weak_result_type<_Tp>
{
typedef typename _Tp::first_argument_type first_argument_type;
typedef typename _Tp::second_argument_type second_argument_type;
};
template<typename _Tp>
struct _Reference_wrapper_base_impl<true, true, _Tp>
: _Weak_result_type<_Tp>
{
typedef typename _Tp::argument_type argument_type;
typedef typename _Tp::first_argument_type first_argument_type;
typedef typename _Tp::second_argument_type second_argument_type;
};
template<typename _Tp> class __has_argument_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::argument_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_argument_type : public __has_argument_type_helper <typename remove_cv<_Tp>::type>::type { };
template<typename _Tp> class __has_first_argument_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::first_argument_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_first_argument_type : public __has_first_argument_type_helper <typename remove_cv<_Tp>::type>::type { };
template<typename _Tp> class __has_second_argument_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::second_argument_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_second_argument_type : public __has_second_argument_type_helper <typename remove_cv<_Tp>::type>::type { };
template<typename _Tp>
struct _Reference_wrapper_base
: _Reference_wrapper_base_impl<
__has_argument_type<_Tp>::value,
__has_first_argument_type<_Tp>::value
&& __has_second_argument_type<_Tp>::value,
_Tp>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1)>
: unary_function<_T1, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1) const>
: unary_function<_T1, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1) volatile>
: unary_function<_T1, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1) const volatile>
: unary_function<_T1, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2)>
: binary_function<_T1, _T2, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2) const>
: binary_function<_T1, _T2, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
: binary_function<_T1, _T2, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
: binary_function<_T1, _T2, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(*)(_T1)>
: unary_function<_T1, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
: binary_function<_T1, _T2, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)()>
: unary_function<_T1*, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
: binary_function<_T1*, _T2, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)() const>
: unary_function<const _T1*, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
: binary_function<const _T1*, _T2, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
: unary_function<volatile _T1*, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
: binary_function<volatile _T1*, _T2, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
: unary_function<const volatile _T1*, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
: binary_function<const volatile _T1*, _T2, _Res>
{ };
template<typename _Tp>
class reference_wrapper
: public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
{
_Tp* _M_data;
public:
typedef _Tp type;
reference_wrapper(_Tp& __indata) noexcept
: _M_data(std::__addressof(__indata))
{ }
reference_wrapper(_Tp&&) = delete;
reference_wrapper(const reference_wrapper<_Tp>& __inref) noexcept
: _M_data(__inref._M_data)
{ }
reference_wrapper&
operator=(const reference_wrapper<_Tp>& __inref) noexcept
{
_M_data = __inref._M_data;
return *this;
}
operator _Tp&() const noexcept
{ return this->get(); }
_Tp&
get() const noexcept
{ return *_M_data; }
template<typename... _Args>
typename result_of<_Tp&(_Args&&...)>::type
operator()(_Args&&... __args) const
{
return __invoke(get(), std::forward<_Args>(__args)...);
}
};
template<typename _Tp>
inline reference_wrapper<_Tp>
ref(_Tp& __t) noexcept
{ return reference_wrapper<_Tp>(__t); }
template<typename _Tp>
inline reference_wrapper<const _Tp>
cref(const _Tp& __t) noexcept
{ return reference_wrapper<const _Tp>(__t); }
template<typename _Tp>
void ref(const _Tp&&) = delete;
template<typename _Tp>
void cref(const _Tp&&) = delete;
template<typename _Tp>
inline reference_wrapper<_Tp>
ref(reference_wrapper<_Tp> __t) noexcept
{ return ref(__t.get()); }
template<typename _Tp>
inline reference_wrapper<const _Tp>
cref(reference_wrapper<_Tp> __t) noexcept
{ return cref(__t.get()); }
template<typename... _Types>
struct _Pack : integral_constant<size_t, sizeof...(_Types)>
{ };
template<typename _From, typename _To, bool = _From::value == _To::value>
struct _AllConvertible : false_type
{ };
template<typename... _From, typename... _To>
struct _AllConvertible<_Pack<_From...>, _Pack<_To...>, true>
: __and_<is_convertible<_From, _To>...>
{ };
template<typename _Tp1, typename _Tp2>
using _NotSame = __not_<is_same<typename std::decay<_Tp1>::type,
typename std::decay<_Tp2>::type>>;
template<typename _Res, typename... _ArgTypes>
struct _Maybe_unary_or_binary_function { };
template<typename _Res, typename _T1>
struct _Maybe_unary_or_binary_function<_Res, _T1>
: std::unary_function<_T1, _Res> { };
template<typename _Res, typename _T1, typename _T2>
struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
: std::binary_function<_T1, _T2, _Res> { };
template<typename _Res, typename _Class, typename... _ArgTypes>
class _Mem_fn<_Res (_Class::*)(_ArgTypes...)>
: public _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>
{
typedef _Res (_Class::*_Functor)(_ArgTypes...);
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __object, const volatile _Class *,
_Args&&... __args) const
;
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
;
template<typename... _Args>
using _RequireValidArgs
= _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs2
= _Require<_NotSame<_Class, _Tp>, _NotSame<_Class*, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs3
= _Require<is_base_of<_Class, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
public:
typedef _Res result_type;
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(_Class& __object, _Args&&... __args) const
{ return (__object.*__pmf)(std::forward<_Args>(__args)...); }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(_Class&& __object, _Args&&... __args) const
{
return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
}
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(_Class* __object, _Args&&... __args) const
{ return (__object->*__pmf)(std::forward<_Args>(__args)...); }
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs2<_Tp, _Args...>>
_Res
operator()(_Tp&& __object, _Args&&... __args) const
{
return _M_call(std::forward<_Tp>(__object), &__object,
std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs3<_Tp, _Args...>>
_Res
operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
{ return operator()(__ref.get(), std::forward<_Args>(__args)...); }
private:
_Functor __pmf;
};
template<typename _Res, typename _Class, typename... _ArgTypes>
class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const>
: public _Maybe_unary_or_binary_function<_Res, const _Class*,
_ArgTypes...>
{
typedef _Res (_Class::*_Functor)(_ArgTypes...) const;
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __object, const volatile _Class *,
_Args&&... __args) const
{
return (std::forward<_Tp>(__object).*__pmf)
(std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
{ return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }
template<typename... _Args>
using _RequireValidArgs
= _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs2
= _Require<_NotSame<_Class, _Tp>, _NotSame<const _Class*, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs3
= _Require<is_base_of<_Class, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
public:
typedef _Res result_type;
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(const _Class& __object, _Args&&... __args) const
{ return (__object.*__pmf)(std::forward<_Args>(__args)...); }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(const _Class&& __object, _Args&&... __args) const
{
return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
}
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(const _Class* __object, _Args&&... __args) const
{ return (__object->*__pmf)(std::forward<_Args>(__args)...); }
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs2<_Tp, _Args...>>
_Res operator()(_Tp&& __object, _Args&&... __args) const
{
return _M_call(std::forward<_Tp>(__object), &__object,
std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs3<_Tp, _Args...>>
_Res
operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
{ return operator()(__ref.get(), std::forward<_Args>(__args)...); }
private:
_Functor __pmf;
};
template<typename _Res, typename _Class, typename... _ArgTypes>
class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile>
: public _Maybe_unary_or_binary_function<_Res, volatile _Class*,
_ArgTypes...>
{
typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile;
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __object, const volatile _Class *,
_Args&&... __args) const
{
return (std::forward<_Tp>(__object).*__pmf)
(std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
{ return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }
template<typename... _Args>
using _RequireValidArgs
= _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs2
= _Require<_NotSame<_Class, _Tp>, _NotSame<volatile _Class*, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs3
= _Require<is_base_of<_Class, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
public:
typedef _Res result_type;
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(volatile _Class& __object, _Args&&... __args) const
{ return (__object.*__pmf)(std::forward<_Args>(__args)...); }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(volatile _Class&& __object, _Args&&... __args) const
{
return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
}
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(volatile _Class* __object, _Args&&... __args) const
{ return (__object->*__pmf)(std::forward<_Args>(__args)...); }
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs2<_Tp, _Args...>>
_Res
operator()(_Tp&& __object, _Args&&... __args) const
{
return _M_call(std::forward<_Tp>(__object), &__object,
std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs3<_Tp, _Args...>>
_Res
operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
{ return operator()(__ref.get(), std::forward<_Args>(__args)...); }
private:
_Functor __pmf;
};
template<typename _Res, typename _Class, typename... _ArgTypes>
class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile>
: public _Maybe_unary_or_binary_function<_Res, const volatile _Class*,
_ArgTypes...>
{
typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile;
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __object, const volatile _Class *,
_Args&&... __args) const
{
return (std::forward<_Tp>(__object).*__pmf)
(std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
{ return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }
template<typename... _Args>
using _RequireValidArgs
= _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs2
= _Require<_NotSame<_Class, _Tp>,
_NotSame<const volatile _Class*, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs3
= _Require<is_base_of<_Class, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
public:
typedef _Res result_type;
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(const volatile _Class& __object, _Args&&... __args) const
{ return (__object.*__pmf)(std::forward<_Args>(__args)...); }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(const volatile _Class&& __object, _Args&&... __args) const
{
return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
}
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(const volatile _Class* __object, _Args&&... __args) const
{ return (__object->*__pmf)(std::forward<_Args>(__args)...); }
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs2<_Tp, _Args...>>
_Res operator()(_Tp&& __object, _Args&&... __args) const
{
return _M_call(std::forward<_Tp>(__object), &__object,
std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs3<_Tp, _Args...>>
_Res
operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
{ return operator()(__ref.get(), std::forward<_Args>(__args)...); }
private:
_Functor __pmf;
};
template<typename _Tp, bool>
struct _Mem_fn_const_or_non
{
typedef const _Tp& type;
};
template<typename _Tp>
struct _Mem_fn_const_or_non<_Tp, false>
{
typedef _Tp& type;
};
template<typename _Res, typename _Class>
class _Mem_fn<_Res _Class::*>
{
using __pm_type = _Res _Class::*;
template<typename _Tp>
auto
_M_call(_Tp&& __object, const _Class *) const noexcept
-> decltype(std::forward<_Tp>(__object).*std::declval<__pm_type&>())
{ return std::forward<_Tp>(__object).*__pm; }
template<typename _Tp, typename _Up>
auto
_M_call(_Tp&& __object, _Up * const *) const noexcept
-> decltype((*std::forward<_Tp>(__object)).*std::declval<__pm_type&>())
{ return (*std::forward<_Tp>(__object)).*__pm; }
template<typename _Tp>
auto
_M_call(_Tp&& __ptr, const volatile void*) const
noexcept(noexcept((*__ptr).*std::declval<__pm_type&>()))
-> decltype((*__ptr).*std::declval<__pm_type&>())
{ return (*__ptr).*__pm; }
public:
explicit
_Mem_fn(_Res _Class::*__pm) noexcept : __pm(__pm) { }
_Res&
operator()(_Class& __object) const noexcept
{ return __object.*__pm; }
const _Res&
operator()(const _Class& __object) const noexcept
{ return __object.*__pm; }
_Res&&
operator()(_Class&& __object) const noexcept
{ return std::forward<_Class>(__object).*__pm; }
const _Res&&
operator()(const _Class&& __object) const noexcept
{ return std::forward<const _Class>(__object).*__pm; }
_Res&
operator()(_Class* __object) const noexcept
{ return __object->*__pm; }
const _Res&
operator()(const _Class* __object) const noexcept
{ return __object->*__pm; }
template<typename _Tp, typename _Req = _Require<_NotSame<_Class*, _Tp>>>
auto
operator()(_Tp&& __unknown) const
noexcept(noexcept(std::declval<_Mem_fn*>()->_M_call
(std::forward<_Tp>(__unknown), &__unknown)))
-> decltype(this->_M_call(std::forward<_Tp>(__unknown), &__unknown))
{ return _M_call(std::forward<_Tp>(__unknown), &__unknown); }
template<typename _Tp, typename _Req = _Require<is_base_of<_Class, _Tp>>>
auto
operator()(reference_wrapper<_Tp> __ref) const
noexcept(noexcept(std::declval<_Mem_fn&>()(__ref.get())))
-> decltype((*this)(__ref.get()))
{ return (*this)(__ref.get()); }
private:
_Res _Class::*__pm;
};
template<typename _Tp, typename _Class>
inline _Mem_fn<_Tp _Class::*>
mem_fn(_Tp _Class::* __pm) noexcept
{
return _Mem_fn<_Tp _Class::*>(__pm);
}
template<typename _Tp>
struct is_bind_expression
: public false_type { };
template<typename _Tp>
struct is_placeholder
: public integral_constant<int, 0>
{ };
template<int _Num> struct _Placeholder { };
namespace placeholders
{
extern const _Placeholder<1> _1;
extern const _Placeholder<2> _2;
extern const _Placeholder<3> _3;
extern const _Placeholder<4> _4;
extern const _Placeholder<5> _5;
extern const _Placeholder<6> _6;
extern const _Placeholder<7> _7;
extern const _Placeholder<8> _8;
extern const _Placeholder<9> _9;
extern const _Placeholder<10> _10;
extern const _Placeholder<11> _11;
extern const _Placeholder<12> _12;
extern const _Placeholder<13> _13;
extern const _Placeholder<14> _14;
extern const _Placeholder<15> _15;
extern const _Placeholder<16> _16;
extern const _Placeholder<17> _17;
extern const _Placeholder<18> _18;
extern const _Placeholder<19> _19;
extern const _Placeholder<20> _20;
extern const _Placeholder<21> _21;
extern const _Placeholder<22> _22;
extern const _Placeholder<23> _23;
extern const _Placeholder<24> _24;
extern const _Placeholder<25> _25;
extern const _Placeholder<26> _26;
extern const _Placeholder<27> _27;
extern const _Placeholder<28> _28;
extern const _Placeholder<29> _29;
}
template<int _Num>
struct is_placeholder<_Placeholder<_Num> >
: public integral_constant<int, _Num>
{ };
template<int _Num>
struct is_placeholder<const _Placeholder<_Num> >
: public integral_constant<int, _Num>
{ };
struct _No_tuple_element;
template<std::size_t __i, typename _Tuple, bool _IsSafe>
struct _Safe_tuple_element_impl
: tuple_element<__i, _Tuple> { };
template<std::size_t __i, typename _Tuple>
struct _Safe_tuple_element_impl<__i, _Tuple, false>
{
typedef _No_tuple_element type;
};
template<std::size_t __i, typename _Tuple>
struct _Safe_tuple_element
: _Safe_tuple_element_impl<__i, _Tuple,
(__i < tuple_size<_Tuple>::value)>
{ };
template<typename _Arg,
bool _IsBindExp = is_bind_expression<_Arg>::value,
bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
class _Mu;
template<typename _Tp>
class _Mu<reference_wrapper<_Tp>, false, false>
{
public:
typedef _Tp& result_type;
template<typename _CVRef, typename _Tuple>
result_type
operator()(_CVRef& __arg, _Tuple&) const volatile
{ return __arg.get(); }
};
template<typename _Arg>
class _Mu<_Arg, true, false>
{
public:
template<typename _CVArg, typename... _Args>
auto
operator()(_CVArg& __arg,
tuple<_Args...>& __tuple) const volatile
-> decltype(__arg(declval<_Args>()...))
{
typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
_Indexes;
return this->__call(__arg, __tuple, _Indexes());
}
private:
template<typename _CVArg, typename... _Args, std::size_t... _Indexes>
auto
__call(_CVArg& __arg, tuple<_Args...>& __tuple,
const _Index_tuple<_Indexes...>&) const volatile
-> decltype(__arg(declval<_Args>()...))
{
return __arg(std::forward<_Args>(std::get<_Indexes>(__tuple))...);
}
};
template<typename _Arg>
class _Mu<_Arg, false, true>
{
public:
template<typename _Signature> class result;
template<typename _CVMu, typename _CVArg, typename _Tuple>
class result<_CVMu(_CVArg, _Tuple)>
{
typedef typename _Safe_tuple_element<(is_placeholder<_Arg>::value
- 1), _Tuple>::type
__base_type;
public:
typedef typename add_rvalue_reference<__base_type>::type type;
};
template<typename _Tuple>
typename result<_Mu(_Arg, _Tuple)>::type
operator()(const volatile _Arg&, _Tuple& __tuple) const volatile
{
return std::forward<typename result<_Mu(_Arg, _Tuple)>::type>(
::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple));
}
};
template<typename _Arg>
class _Mu<_Arg, false, false>
{
public:
template<typename _Signature> struct result;
template<typename _CVMu, typename _CVArg, typename _Tuple>
struct result<_CVMu(_CVArg, _Tuple)>
{
typedef typename add_lvalue_reference<_CVArg>::type type;
};
template<typename _CVArg, typename _Tuple>
_CVArg&&
operator()(_CVArg&& __arg, _Tuple&) const volatile
{ return std::forward<_CVArg>(__arg); }
};
template<typename _Tp>
struct _Maybe_wrap_member_pointer
{
typedef _Tp type;
static const _Tp&
__do_wrap(const _Tp& __x)
{ return __x; }
static _Tp&&
__do_wrap(_Tp&& __x)
{ return static_cast<_Tp&&>(__x); }
};
template<typename _Tp, typename _Class>
struct _Maybe_wrap_member_pointer<_Tp _Class::*>
{
typedef _Mem_fn<_Tp _Class::*> type;
static type
__do_wrap(_Tp _Class::* __pm)
{ return type(__pm); }
};
template<>
struct _Maybe_wrap_member_pointer<void>
{
typedef void type;
};
template<std::size_t _Ind, typename... _Tp>
inline auto
__volget(volatile tuple<_Tp...>& __tuple)
-> __tuple_element_t<_Ind, tuple<_Tp...>> volatile&
{ return std::get<_Ind>(const_cast<tuple<_Tp...>&>(__tuple)); }
template<std::size_t _Ind, typename... _Tp>
inline auto
__volget(const volatile tuple<_Tp...>& __tuple)
-> __tuple_element_t<_Ind, tuple<_Tp...>> const volatile&
{ return std::get<_Ind>(const_cast<const tuple<_Tp...>&>(__tuple)); }
template<typename _Signature>
struct _Bind;
template<typename _Functor, typename... _Bound_args>
class _Bind<_Functor(_Bound_args...)>
: public _Weak_result_type<_Functor>
{
typedef _Bind __self_type;
typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
_Bound_indexes;
_Functor _M_f;
tuple<_Bound_args...> _M_bound_args;
template<typename _Result, typename... _Args, std::size_t... _Indexes>
_Result
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
{
return _M_f(_Mu<_Bound_args>()
(std::get<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Result, typename... _Args, std::size_t... _Indexes>
_Result
__call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
{
return _M_f(_Mu<_Bound_args>()
(std::get<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Result, typename... _Args, std::size_t... _Indexes>
_Result
__call_v(tuple<_Args...>&& __args,
_Index_tuple<_Indexes...>) volatile
{
return _M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Result, typename... _Args, std::size_t... _Indexes>
_Result
__call_c_v(tuple<_Args...>&& __args,
_Index_tuple<_Indexes...>) const volatile
{
return _M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
public:
template<typename... _Args>
explicit _Bind(const _Functor& __f, _Args&&... __args)
: _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
{ }
template<typename... _Args>
explicit _Bind(_Functor&& __f, _Args&&... __args)
: _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
{ }
_Bind(const _Bind&) = default;
_Bind(_Bind&& __b)
: _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
{ }
template<typename... _Args, typename _Result
= decltype( std::declval<_Functor>()(
_Mu<_Bound_args>()( std::declval<_Bound_args&>(),
std::declval<tuple<_Args...>&>() )... ) )>
_Result
operator()(_Args&&... __args)
;
template<typename... _Args, typename _Result
= decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
typename add_const<_Functor>::type>::type>()(
_Mu<_Bound_args>()( std::declval<const _Bound_args&>(),
std::declval<tuple<_Args...>&>() )... ) )>
_Result
operator()(_Args&&... __args) const
;
template<typename... _Args, typename _Result
= decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
typename add_volatile<_Functor>::type>::type>()(
_Mu<_Bound_args>()( std::declval<volatile _Bound_args&>(),
std::declval<tuple<_Args...>&>() )... ) )>
_Result
operator()(_Args&&... __args) volatile
;
template<typename... _Args, typename _Result
= decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
typename add_cv<_Functor>::type>::type>()(
_Mu<_Bound_args>()( std::declval<const volatile _Bound_args&>(),
std::declval<tuple<_Args...>&>() )... ) )>
_Result
operator()(_Args&&... __args) const volatile
;
};
template<typename _Result, typename _Signature>
struct _Bind_result;
template<typename _Result, typename _Functor, typename... _Bound_args>
class _Bind_result<_Result, _Functor(_Bound_args...)>
{
typedef _Bind_result __self_type;
typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
_Bound_indexes;
_Functor _M_f;
tuple<_Bound_args...> _M_bound_args;
template<typename _Res>
struct __enable_if_void : enable_if<is_void<_Res>::value, int> { };
template<typename _Res>
struct __disable_if_void : enable_if<!is_void<_Res>::value, int> { };
template<typename _Res, typename... _Args, std::size_t... _Indexes>
_Result
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0)
;
template<typename _Res, typename... _Args, std::size_t... _Indexes>
void
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0)
;
template<typename _Res, typename... _Args, std::size_t... _Indexes>
_Result
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0) const
;
template<typename _Res, typename... _Args, std::size_t... _Indexes>
void
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0) const
;
template<typename _Res, typename... _Args, std::size_t... _Indexes>
_Result
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0) volatile
{
return _M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Res, typename... _Args, std::size_t... _Indexes>
void
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0) volatile
{
_M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Res, typename... _Args, std::size_t... _Indexes>
_Result
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0) const volatile
{
return _M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Res, typename... _Args, std::size_t... _Indexes>
void
__call(tuple<_Args...>&& __args,
_Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0) const volatile
{
_M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
public:
typedef _Result result_type;
template<typename... _Args>
explicit _Bind_result(const _Functor& __f, _Args&&... __args)
: _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
{ }
template<typename... _Args>
explicit _Bind_result(_Functor&& __f, _Args&&... __args)
: _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
{ }
_Bind_result(const _Bind_result&) = default;
_Bind_result(_Bind_result&& __b)
: _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
{ }
template<typename... _Args>
result_type
operator()(_Args&&... __args)
{
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
template<typename... _Args>
result_type
operator()(_Args&&... __args) const
{
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
template<typename... _Args>
result_type
operator()(_Args&&... __args) volatile
{
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
template<typename... _Args>
result_type
operator()(_Args&&... __args) const volatile
{
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
};
template<typename _Signature>
struct is_bind_expression<_Bind<_Signature> >
: public true_type { };
template<typename _Signature>
struct is_bind_expression<const _Bind<_Signature> >
: public true_type { };
template<typename _Signature>
struct is_bind_expression<volatile _Bind<_Signature> >
: public true_type { };
template<typename _Signature>
struct is_bind_expression<const volatile _Bind<_Signature>>
: public true_type { };
template<typename _Result, typename _Signature>
struct is_bind_expression<_Bind_result<_Result, _Signature>>
: public true_type { };
template<typename _Result, typename _Signature>
struct is_bind_expression<const _Bind_result<_Result, _Signature>>
: public true_type { };
template<typename _Result, typename _Signature>
struct is_bind_expression<volatile _Bind_result<_Result, _Signature>>
: public true_type { };
template<typename _Result, typename _Signature>
struct is_bind_expression<const volatile _Bind_result<_Result, _Signature>>
: public true_type { };
template<typename _Tp, typename _Tp2 = typename decay<_Tp>::type>
using __is_socketlike = __or_<is_integral<_Tp2>, is_enum<_Tp2>>;
template<bool _SocketLike, typename _Func, typename... _BoundArgs>
struct _Bind_helper
{
typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
__maybe_type;
typedef typename __maybe_type::type __func_type;
typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type;
};
template<typename _Func, typename... _BoundArgs>
struct _Bind_helper<true, _Func, _BoundArgs...>
{ };
template<typename _Func, typename... _BoundArgs>
inline typename
_Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
bind(_Func&& __f, _BoundArgs&&... __args)
{
typedef _Bind_helper<false, _Func, _BoundArgs...> __helper_type;
typedef typename __helper_type::__maybe_type __maybe_type;
typedef typename __helper_type::type __result_type;
return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
std::forward<_BoundArgs>(__args)...);
}
template<typename _Result, typename _Func, typename... _BoundArgs>
struct _Bindres_helper
{
typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
__maybe_type;
typedef typename __maybe_type::type __functor_type;
typedef _Bind_result<_Result,
__functor_type(typename decay<_BoundArgs>::type...)>
type;
};
template<typename _Result, typename _Func, typename... _BoundArgs>
inline
typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type
bind(_Func&& __f, _BoundArgs&&... __args)
{
typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type;
typedef typename __helper_type::__maybe_type __maybe_type;
typedef typename __helper_type::type __result_type;
return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
std::forward<_BoundArgs>(__args)...);
}
template<typename _Signature>
struct _Bind_simple;
template<typename _Callable, typename... _Args>
struct _Bind_simple<_Callable(_Args...)>
{
typedef typename result_of<_Callable(_Args...)>::type result_type;
template<typename... _Args2, typename = typename
enable_if< sizeof...(_Args) == sizeof...(_Args2)>::type>
explicit
_Bind_simple(const _Callable& __callable, _Args2&&... __args)
: _M_bound(__callable, std::forward<_Args2>(__args)...)
{ }
template<typename... _Args2, typename = typename
enable_if< sizeof...(_Args) == sizeof...(_Args2)>::type>
explicit
_Bind_simple(_Callable&& __callable, _Args2&&... __args)
: _M_bound(std::move(__callable), std::forward<_Args2>(__args)...)
{ }
_Bind_simple(const _Bind_simple&) = default;
_Bind_simple(_Bind_simple&&) = default;
result_type
operator()()
{
typedef typename _Build_index_tuple<sizeof...(_Args)>::__type _Indices;
return _M_invoke(_Indices());
}
private:
template<std::size_t... _Indices>
typename result_of<_Callable(_Args...)>::type
_M_invoke(_Index_tuple<_Indices...>)
{
return std::forward<_Callable>(std::get<0>(_M_bound))(
std::forward<_Args>(std::get<_Indices+1>(_M_bound))...);
}
std::tuple<_Callable, _Args...> _M_bound;
};
template<typename _Func, typename... _BoundArgs>
struct _Bind_simple_helper
{
typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
__maybe_type;
typedef typename __maybe_type::type __func_type;
typedef _Bind_simple<__func_type(typename decay<_BoundArgs>::type...)>
__type;
};
template<typename _Callable, typename... _Args>
typename _Bind_simple_helper<_Callable, _Args...>::__type
__bind_simple(_Callable&& __callable, _Args&&... __args)
{
typedef _Bind_simple_helper<_Callable, _Args...> __helper_type;
typedef typename __helper_type::__maybe_type __maybe_type;
typedef typename __helper_type::__type __result_type;
return __result_type(
__maybe_type::__do_wrap( std::forward<_Callable>(__callable)),
std::forward<_Args>(__args)...);
}
class bad_function_call : public std::exception
{
public:
virtual ~bad_function_call() noexcept;
const char* what() const noexcept;
};
template<typename _Tp>
struct __is_location_invariant
: __or_<is_pointer<_Tp>, is_member_pointer<_Tp>>::type
{ };
class _Undefined_class;
union _Nocopy_types
{
void* _M_object;
const void* _M_const_object;
void (*_M_function_pointer)();
void (_Undefined_class::*_M_member_pointer)();
};
union _Any_data
{
void* _M_access() { return &_M_pod_data[0]; }
const void* _M_access() const { return &_M_pod_data[0]; }
template<typename _Tp>
_Tp&
_M_access()
{ return *static_cast<_Tp*>(_M_access()); }
template<typename _Tp>
const _Tp&
_M_access() const
;
_Nocopy_types _M_unused;
char _M_pod_data[sizeof(_Nocopy_types)];
};
enum _Manager_operation
{
__get_type_info,
__get_functor_ptr,
__clone_functor,
__destroy_functor
};
template<typename _Tp>
struct _Simple_type_wrapper
{
_Simple_type_wrapper(_Tp __value) ;
_Tp __value;
};
template<typename _Tp>
struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
: __is_location_invariant<_Tp>
{ };
template<typename _Functor>
_Functor&
__callable_functor(_Functor& __f)
;
template<typename _Member, typename _Class>
_Mem_fn<_Member _Class::*>
__callable_functor(_Member _Class::* &__p)
;
template<typename _Member, typename _Class>
_Mem_fn<_Member _Class::*>
__callable_functor(_Member _Class::* const &__p)
;
template<typename _Member, typename _Class>
_Mem_fn<_Member _Class::*>
__callable_functor(_Member _Class::* volatile &__p)
;
template<typename _Member, typename _Class>
_Mem_fn<_Member _Class::*>
__callable_functor(_Member _Class::* const volatile &__p)
;
template<typename _Signature>
class function;
class _Function_base
{
public:
static const std::size_t _M_max_size = sizeof(_Nocopy_types);
static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
template<typename _Functor>
class _Base_manager
{
protected:
static const bool __stored_locally =
(__is_location_invariant<_Functor>::value
&& sizeof(_Functor) <= _M_max_size
&& __alignof__(_Functor) <= _M_max_align
&& (_M_max_align % __alignof__(_Functor) == 0));
typedef integral_constant<bool, __stored_locally> _Local_storage;
static _Functor*
_M_get_pointer(const _Any_data& __source)
;
static void
_M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
;
static void
_M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
;
static void
_M_destroy(_Any_data& __victim, true_type)
;
static void
_M_destroy(_Any_data& __victim, false_type)
;
public:
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
_Manager_operation __op)
;
static void
_M_init_functor(_Any_data& __functor, _Functor&& __f)
;
template<typename _Signature>
static bool
_M_not_empty_function(const function<_Signature>& __f)
;
template<typename _Tp>
static bool
_M_not_empty_function(_Tp* const& __fp)
;
template<typename _Class, typename _Tp>
static bool
_M_not_empty_function(_Tp _Class::* const& __mp)
;
template<typename _Tp>
static bool
_M_not_empty_function(const _Tp&)
;
private:
static void
_M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
;
static void
_M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
;
};
template<typename _Functor>
class _Ref_manager : public _Base_manager<_Functor*>
{
typedef _Function_base::_Base_manager<_Functor*> _Base;
public:
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
_Manager_operation __op)
;
static void
_M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
;
};
_Function_base() ;
~_Function_base()
;
bool _M_empty() const ;
typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
_Manager_operation);
_Any_data _M_functor;
_Manager_type _M_manager;
};
template<typename _Signature, typename _Functor>
class _Function_handler;
template<typename _Res, typename _Functor, typename... _ArgTypes>
class _Function_handler<_Res(_ArgTypes...), _Functor>
: public _Function_base::_Base_manager<_Functor>
{
typedef _Function_base::_Base_manager<_Functor> _Base;
public:
static _Res
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
;
};
template<typename _Functor, typename... _ArgTypes>
class _Function_handler<void(_ArgTypes...), _Functor>
: public _Function_base::_Base_manager<_Functor>
{
typedef _Function_base::_Base_manager<_Functor> _Base;
public:
static void
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
;
};
template<typename _Res, typename _Functor, typename... _ArgTypes>
class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >
: public _Function_base::_Ref_manager<_Functor>
{
typedef _Function_base::_Ref_manager<_Functor> _Base;
public:
static _Res
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
;
};
template<typename _Functor, typename... _ArgTypes>
class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> >
: public _Function_base::_Ref_manager<_Functor>
{
typedef _Function_base::_Ref_manager<_Functor> _Base;
public:
static void
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
;
};
template<typename _Class, typename _Member, typename _Res,
typename... _ArgTypes>
class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
: public _Function_handler<void(_ArgTypes...), _Member _Class::*>
{
typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
_Base;
public:
static _Res
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
;
};
template<typename _Class, typename _Member, typename... _ArgTypes>
class _Function_handler<void(_ArgTypes...), _Member _Class::*>
: public _Function_base::_Base_manager<
_Simple_type_wrapper< _Member _Class::* > >
{
typedef _Member _Class::* _Functor;
typedef _Simple_type_wrapper<_Functor> _Wrapper;
typedef _Function_base::_Base_manager<_Wrapper> _Base;
public:
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
_Manager_operation __op)
;
static void
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
;
};
template<typename _From, typename _To>
using __check_func_return_type
= __or_<is_void<_To>, is_convertible<_From, _To>>;
template<typename _Res, typename... _ArgTypes>
class function<_Res(_ArgTypes...)>
: public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
private _Function_base
{
typedef _Res _Signature_type(_ArgTypes...);
template<typename _Functor>
using _Invoke = decltype(__callable_functor(std::declval<_Functor&>())
(std::declval<_ArgTypes>()...) );
template<typename _Tp>
using _NotSelf = __not_<is_same<_Tp, function>>;
template<typename _Functor>
using _Callable
= __and_<_NotSelf<_Functor>,
__check_func_return_type<_Invoke<_Functor>, _Res>>;
template<typename _Cond, typename _Tp>
using _Requires = typename enable_if<_Cond::value, _Tp>::type;
public:
typedef _Res result_type;
function() noexcept
: _Function_base() { }
function(nullptr_t) noexcept
: _Function_base() { }
function(const function& __x);
function(function&& __x)
;
template<typename _Functor,
typename = _Requires<_Callable<_Functor>, void>>
function(_Functor);
function&
operator=(const function& __x)
;
function&
operator=(function&& __x)
;
function&
operator=(nullptr_t)
;
template<typename _Functor>
_Requires<_Callable<typename decay<_Functor>::type>, function&>
operator=(_Functor&& __f)
{
function(std::forward<_Functor>(__f)).swap(*this);
return *this;
}
template<typename _Functor>
function&
operator=(reference_wrapper<_Functor> __f) noexcept
{
function(__f).swap(*this);
return *this;
}
void swap(function& __x)
{
std::swap(_M_functor, __x._M_functor);
std::swap(_M_manager, __x._M_manager);
std::swap(_M_invoker, __x._M_invoker);
}
explicit operator bool() const noexcept
{ return !_M_empty(); }
_Res operator()(_ArgTypes... __args) const;
const type_info& target_type() const noexcept;
template<typename _Functor> _Functor* target() noexcept;
template<typename _Functor> const _Functor* target() const noexcept;
private:
typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...);
_Invoker_type _M_invoker;
};
template<typename _Res, typename... _ArgTypes>
const type_info&
function<_Res(_ArgTypes...)>::
target_type() const noexcept
{
if (_M_manager)
{
_Any_data __typeinfo_result;
_M_manager(__typeinfo_result, _M_functor, __get_type_info);
return *__typeinfo_result._M_access<const type_info*>();
}
else
return typeid(void);
}
template<typename _Res, typename... _ArgTypes>
template<typename _Functor>
_Functor*
function<_Res(_ArgTypes...)>::
target() noexcept
{
if (typeid(_Functor) == target_type() && _M_manager)
{
_Any_data __ptr;
if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
&& !is_const<_Functor>::value)
return 0;
else
return __ptr._M_access<_Functor*>();
}
else
return 0;
}
template<typename _Res, typename... _ArgTypes>
template<typename _Functor>
const _Functor*
function<_Res(_ArgTypes...)>::
target() const noexcept
{
if (typeid(_Functor) == target_type() && _M_manager)
{
_Any_data __ptr;
_M_manager(__ptr, _M_functor, __get_functor_ptr);
return __ptr._M_access<const _Functor*>();
}
else
return 0;
}
template<typename _Res, typename... _Args>
inline bool
operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
{ return !static_cast<bool>(__f); }
template<typename _Res, typename... _Args>
inline bool
operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
{ return !static_cast<bool>(__f); }
template<typename _Res, typename... _Args>
inline bool
operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
{ return static_cast<bool>(__f); }
template<typename _Res, typename... _Args>
inline bool
operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
{ return static_cast<bool>(__f); }
template<typename _Res, typename... _Args>
inline void
swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y)
{ __x.swap(__y); }
}
#define _UNIQUE_PTR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename> class auto_ptr;
template<typename _Tp>
struct default_delete
{
constexpr default_delete() noexcept = default;
template<typename _Up, typename = typename
enable_if<is_convertible<_Up*, _Tp*>::value>::type>
default_delete(const default_delete<_Up>&) noexcept { }
void
operator()(_Tp* __ptr) const
{
static_assert(!is_void<_Tp>::value,
"can't delete pointer to incomplete type");
static_assert(sizeof(_Tp)>0,
"can't delete pointer to incomplete type");
delete __ptr;
}
};
template<typename _Tp>
struct default_delete<_Tp[]>
{
private:
template<typename _Up>
using __remove_cv = typename remove_cv<_Up>::type;
template<typename _Up>
using __is_derived_Tp
= __and_< is_base_of<_Tp, _Up>,
__not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
public:
constexpr default_delete() noexcept = default;
template<typename _Up, typename = typename
enable_if<!__is_derived_Tp<_Up>::value>::type>
default_delete(const default_delete<_Up[]>&) noexcept { }
void
operator()(_Tp* __ptr) const
{
static_assert(sizeof(_Tp)>0,
"can't delete pointer to incomplete type");
delete [] __ptr;
}
template<typename _Up>
typename enable_if<__is_derived_Tp<_Up>::value>::type
operator()(_Up*) const = delete;
};
template <typename _Tp, typename _Dp = default_delete<_Tp> >
class unique_ptr
{
class _Pointer
{
template<typename _Up>
static typename _Up::pointer __test(typename _Up::pointer*);
template<typename _Up>
static _Tp* __test(...);
typedef typename remove_reference<_Dp>::type _Del;
public:
typedef decltype(__test<_Del>(0)) type;
};
typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
__tuple_type _M_t;
public:
typedef typename _Pointer::type pointer;
typedef _Tp element_type;
typedef _Dp deleter_type;
constexpr unique_ptr() noexcept
: _M_t()
{ static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
explicit
unique_ptr(pointer __p) noexcept
: _M_t(__p, deleter_type())
{ static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
unique_ptr(pointer __p,
typename conditional<is_reference<deleter_type>::value,
deleter_type, const deleter_type&>::type __d) noexcept
: _M_t(__p, __d) { }
unique_ptr(pointer __p,
typename remove_reference<deleter_type>::type&& __d) noexcept
: _M_t(std::move(__p), std::move(__d))
{ static_assert(!std::is_reference<deleter_type>::value,
"rvalue deleter bound to reference"); }
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
unique_ptr(unique_ptr&& __u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
template<typename _Up, typename _Ep, typename = _Require<
is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
__not_<is_array<_Up>>,
typename conditional<is_reference<_Dp>::value,
is_same<_Ep, _Dp>,
is_convertible<_Ep, _Dp>>::type>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }
template<typename _Up, typename = _Require<
is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
unique_ptr(auto_ptr<_Up>&& __u) noexcept;
~unique_ptr() noexcept
{
auto& __ptr = std::get<0>(_M_t);
if (__ptr != nullptr)
get_deleter()(__ptr);
__ptr = pointer();
}
unique_ptr&
operator=(unique_ptr&& __u) noexcept
{
reset(__u.release());
get_deleter() = std::forward<deleter_type>(__u.get_deleter());
return *this;
}
template<typename _Up, typename _Ep>
typename enable_if< __and_<
is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
__not_<is_array<_Up>>
>::value,
unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
reset(__u.release());
get_deleter() = std::forward<_Ep>(__u.get_deleter());
return *this;
}
unique_ptr&
operator=(nullptr_t) noexcept
{
reset();
return *this;
}
typename add_lvalue_reference<element_type>::type
operator*() const
{
;
return *get();
}
pointer
operator->() const noexcept
{
;
return get();
}
pointer
get() const noexcept
{ return std::get<0>(_M_t); }
deleter_type&
get_deleter() noexcept
{ return std::get<1>(_M_t); }
const deleter_type&
get_deleter() const noexcept
{ return std::get<1>(_M_t); }
explicit operator bool() const noexcept
{ return get() == pointer() ? false : true; }
pointer
release() noexcept
{
pointer __p = get();
std::get<0>(_M_t) = pointer();
return __p;
}
void
reset(pointer __p = pointer()) noexcept
{
using std::swap;
swap(std::get<0>(_M_t), __p);
if (__p != pointer())
get_deleter()(__p);
}
void
swap(unique_ptr& __u) noexcept
{
using std::swap;
swap(_M_t, __u._M_t);
}
unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;
};
template<typename _Tp, typename _Dp>
class unique_ptr<_Tp[], _Dp>
{
class _Pointer
{
template<typename _Up>
static typename _Up::pointer __test(typename _Up::pointer*);
template<typename _Up>
static _Tp* __test(...);
typedef typename remove_reference<_Dp>::type _Del;
public:
typedef decltype(__test<_Del>(0)) type;
};
typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
__tuple_type _M_t;
template<typename _Up>
using __remove_cv = typename remove_cv<_Up>::type;
template<typename _Up>
using __is_derived_Tp
= __and_< is_base_of<_Tp, _Up>,
__not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
template<typename _Up, typename _Ep,
typename _Tp_pointer = typename _Pointer::type,
typename _Up_pointer = typename unique_ptr<_Up, _Ep>::pointer>
using __safe_conversion = __and_<
is_convertible<_Up_pointer, _Tp_pointer>,
is_array<_Up>,
__or_<__not_<is_pointer<_Up_pointer>>,
__not_<is_pointer<_Tp_pointer>>,
__not_<__is_derived_Tp<typename remove_extent<_Up>::type>>
>
>;
public:
typedef typename _Pointer::type pointer;
typedef _Tp element_type;
typedef _Dp deleter_type;
constexpr unique_ptr() noexcept
: _M_t()
{ static_assert(!std::is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
explicit
unique_ptr(pointer __p) noexcept
: _M_t(__p, deleter_type())
{ static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
template<typename _Up, typename = _Require<is_pointer<pointer>,
is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
explicit
unique_ptr(_Up* __p) = delete;
unique_ptr(pointer __p,
typename conditional<is_reference<deleter_type>::value,
deleter_type, const deleter_type&>::type __d) noexcept
: _M_t(__p, __d) { }
unique_ptr(pointer __p, typename
remove_reference<deleter_type>::type&& __d) noexcept
: _M_t(std::move(__p), std::move(__d))
{ static_assert(!is_reference<deleter_type>::value,
"rvalue deleter bound to reference"); }
unique_ptr(unique_ptr&& __u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
template<typename _Up, typename _Ep,
typename = _Require<__safe_conversion<_Up, _Ep>,
typename conditional<is_reference<_Dp>::value,
is_same<_Ep, _Dp>,
is_convertible<_Ep, _Dp>>::type
>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }
~unique_ptr()
{
auto& __ptr = std::get<0>(_M_t);
if (__ptr != nullptr)
get_deleter()(__ptr);
__ptr = pointer();
}
unique_ptr&
operator=(unique_ptr&& __u) noexcept
{
reset(__u.release());
get_deleter() = std::forward<deleter_type>(__u.get_deleter());
return *this;
}
template<typename _Up, typename _Ep>
typename
enable_if<__safe_conversion<_Up, _Ep>::value, unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
reset(__u.release());
get_deleter() = std::forward<_Ep>(__u.get_deleter());
return *this;
}
unique_ptr&
operator=(nullptr_t) noexcept
{
reset();
return *this;
}
typename std::add_lvalue_reference<element_type>::type
operator[](size_t __i) const
{
;
return get()[__i];
}
pointer
get() const noexcept
{ return std::get<0>(_M_t); }
deleter_type&
get_deleter() noexcept
{ return std::get<1>(_M_t); }
const deleter_type&
get_deleter() const noexcept
{ return std::get<1>(_M_t); }
explicit operator bool() const noexcept
{ return get() == pointer() ? false : true; }
pointer
release() noexcept
{
pointer __p = get();
std::get<0>(_M_t) = pointer();
return __p;
}
void
reset(pointer __p = pointer()) noexcept
{
using std::swap;
swap(std::get<0>(_M_t), __p);
if (__p != nullptr)
get_deleter()(__p);
}
template<typename _Up, typename = _Require<is_pointer<pointer>,
is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
void reset(_Up*) = delete;
void
swap(unique_ptr& __u) noexcept
{
using std::swap;
swap(_M_t, __u._M_t);
}
unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;
template<typename _Up, typename = _Require<is_pointer<pointer>,
is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
unique_ptr(_Up*, typename
conditional<is_reference<deleter_type>::value,
deleter_type, const deleter_type&>::type) = delete;
template<typename _Up, typename = _Require<is_pointer<pointer>,
is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
unique_ptr(_Up*, typename
remove_reference<deleter_type>::type&&) = delete;
};
template<typename _Tp, typename _Dp>
inline void
swap(unique_ptr<_Tp, _Dp>& __x,
unique_ptr<_Tp, _Dp>& __y) noexcept
{ __x.swap(__y); }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator==(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return __x.get() == __y.get(); }
template<typename _Tp, typename _Dp>
inline bool
operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
{ return !__x; }
template<typename _Tp, typename _Dp>
inline bool
operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
{ return !__x; }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator!=(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return __x.get() != __y.get(); }
template<typename _Tp, typename _Dp>
inline bool
operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
{ return (bool)__x; }
template<typename _Tp, typename _Dp>
inline bool
operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
{ return (bool)__x; }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator<(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{
typedef typename
std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
return std::less<_CT>()(__x.get(), __y.get());
}
template<typename _Tp, typename _Dp>
inline bool
operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
{ return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
nullptr); }
template<typename _Tp, typename _Dp>
inline bool
operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
{ return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
__x.get()); }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator<=(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return !(__y < __x); }
template<typename _Tp, typename _Dp>
inline bool
operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
{ return !(nullptr < __x); }
template<typename _Tp, typename _Dp>
inline bool
operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
{ return !(__x < nullptr); }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator>(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return (__y < __x); }
template<typename _Tp, typename _Dp>
inline bool
operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
{ return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
__x.get()); }
template<typename _Tp, typename _Dp>
inline bool
operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
{ return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
nullptr); }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator>=(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return !(__x < __y); }
template<typename _Tp, typename _Dp>
inline bool
operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
{ return !(__x < nullptr); }
template<typename _Tp, typename _Dp>
inline bool
operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
{ return !(nullptr < __x); }
template<typename _Tp, typename _Dp>
struct hash<unique_ptr<_Tp, _Dp>>
: public __hash_base<size_t, unique_ptr<_Tp, _Dp>>
{
size_t
operator()(const unique_ptr<_Tp, _Dp>& __u) const noexcept
{
typedef unique_ptr<_Tp, _Dp> _UP;
return std::hash<typename _UP::pointer>()(__u.get());
}
};
}
#define _SHARED_PTR_H 1
#define _SHARED_PTR_BASE_H 1
#define _ALLOCATED_PTR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc>
struct __allocated_ptr
{
using pointer = typename allocator_traits<_Alloc>::pointer;
using value_type = typename allocator_traits<_Alloc>::value_type;
__allocated_ptr(_Alloc& __a, pointer __ptr) noexcept
: _M_alloc(&__a), _M_ptr(__ptr)
{ }
template<typename _Ptr,
typename _Req = _Require<is_same<_Ptr, value_type*>>>
__allocated_ptr(_Alloc& __a, _Ptr __ptr)
: _M_alloc(&__a), _M_ptr(pointer_traits<pointer>::pointer_to(*__ptr))
{ }
__allocated_ptr(__allocated_ptr&& __gd) noexcept
: _M_alloc(__gd._M_alloc), _M_ptr(__gd._M_ptr)
{ __gd._M_ptr = nullptr; }
~__allocated_ptr()
{
if (_M_ptr != nullptr)
std::allocator_traits<_Alloc>::deallocate(*_M_alloc, _M_ptr, 1);
}
__allocated_ptr&
operator=(std::nullptr_t) noexcept
{
_M_ptr = nullptr;
return *this;
}
value_type* get() { return _S_raw_ptr(_M_ptr); }
private:
value_type* _S_raw_ptr(value_type* __ptr) { return __ptr; }
template<typename _Ptr>
auto _S_raw_ptr(_Ptr __ptr) -> decltype(_S_raw_ptr(__ptr.operator->()))
{ return _S_raw_ptr(__ptr.operator->()); }
_Alloc* _M_alloc;
pointer _M_ptr;
};
template<typename _Alloc>
__allocated_ptr<_Alloc>
__allocate_guarded(_Alloc& __a)
;
}
#define _ALIGNED_BUFFER_H 1
namespace __gnu_cxx
{
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()); }
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename> class auto_ptr;
class bad_weak_ptr : public std::exception
{
public:
virtual char const*
what() const noexcept;
virtual ~bad_weak_ptr() noexcept;
};
void
__throw_bad_weak_ptr()
;
using __gnu_cxx::_Lock_policy;
using __gnu_cxx::__default_lock_policy;
using __gnu_cxx::_S_single;
using __gnu_cxx::_S_mutex;
using __gnu_cxx::_S_atomic;
template<_Lock_policy _Lp>
class _Mutex_base
{
protected:
enum { _S_need_barriers = 0 };
};
template<>
class _Mutex_base<_S_mutex>
: public __gnu_cxx::__mutex
{
protected:
enum { _S_need_barriers = 1 };
};
template<_Lock_policy _Lp = __default_lock_policy>
class _Sp_counted_base
: public _Mutex_base<_Lp>
{
public:
_Sp_counted_base() noexcept
: _M_use_count(1), _M_weak_count(1) { }
virtual
~_Sp_counted_base() noexcept
{ }
virtual void
_M_dispose() noexcept = 0;
virtual void
_M_destroy() noexcept
{ delete this; }
virtual void*
_M_get_deleter(const std::type_info&) noexcept = 0;
void
_M_add_ref_copy()
;
void
_M_add_ref_lock();
bool
_M_add_ref_lock_nothrow();
void
_M_release() noexcept
{
;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
{
;
_M_dispose();
if (_Mutex_base<_Lp>::_S_need_barriers)
{
__asm __volatile ("":::"memory");
__asm __volatile ("":::"memory");
}
;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
-1) == 1)
{
;
_M_destroy();
}
}
}
void
_M_weak_add_ref() noexcept
{ __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }
void
_M_weak_release() noexcept
{
;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
{
;
if (_Mutex_base<_Lp>::_S_need_barriers)
{
__asm __volatile ("":::"memory");
__asm __volatile ("":::"memory");
}
_M_destroy();
}
}
long
_M_get_use_count() const noexcept
{
return __atomic_load_n(&_M_use_count, 0);
}
private:
_Sp_counted_base(_Sp_counted_base const&) = delete;
_Sp_counted_base& operator=(_Sp_counted_base const&) = delete;
_Atomic_word _M_use_count;
_Atomic_word _M_weak_count;
};
template<>
inline void
_Sp_counted_base<_S_single>::_M_release() noexcept
{
if (--_M_use_count == 0)
{
_M_dispose();
if (--_M_weak_count == 0)
_M_destroy();
}
}
template<>
inline void
_Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept
{ ++_M_weak_count; }
template<>
inline void
_Sp_counted_base<_S_single>::_M_weak_release() noexcept
{
if (--_M_weak_count == 0)
_M_destroy();
}
template<>
inline long
_Sp_counted_base<_S_single>::_M_get_use_count() const noexcept
{ return _M_use_count; }
template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
class __shared_ptr;
template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
class __weak_ptr;
template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
class __enable_shared_from_this;
template<typename _Tp>
class shared_ptr;
template<typename _Tp>
class weak_ptr;
template<typename _Tp>
struct owner_less;
template<typename _Tp>
class enable_shared_from_this;
template<_Lock_policy _Lp = __default_lock_policy>
class __weak_count;
template<_Lock_policy _Lp = __default_lock_policy>
class __shared_count;
template<typename _Ptr, _Lock_policy _Lp>
class _Sp_counted_ptr final : public _Sp_counted_base<_Lp>
{
public:
explicit
_Sp_counted_ptr(_Ptr __p) noexcept
: _M_ptr(__p) { }
virtual void
_M_dispose() noexcept
{ delete _M_ptr; }
virtual void
_M_destroy() noexcept
{ delete this; }
virtual void*
_M_get_deleter(const std::type_info&) noexcept
{ return nullptr; }
_Sp_counted_ptr(const _Sp_counted_ptr&) = delete;
_Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete;
private:
_Ptr _M_ptr;
};
template<>
inline void
_Sp_counted_ptr<nullptr_t, _S_single>::_M_dispose() noexcept { }
template<>
inline void
_Sp_counted_ptr<nullptr_t, _S_mutex>::_M_dispose() noexcept { }
template<>
inline void
_Sp_counted_ptr<nullptr_t, _S_atomic>::_M_dispose() noexcept { }
template<int _Nm, typename _Tp,
bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
struct _Sp_ebo_helper;
template<int _Nm, typename _Tp>
struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp
{
explicit _Sp_ebo_helper(const _Tp& __tp) ;
static _Tp&
_S_get(_Sp_ebo_helper& __eboh) ;
};
template<int _Nm, typename _Tp>
struct _Sp_ebo_helper<_Nm, _Tp, false>
{
explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { }
static _Tp&
_S_get(_Sp_ebo_helper& __eboh)
{ return __eboh._M_tp; }
private:
_Tp _M_tp;
};
template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
class _Sp_counted_deleter final : public _Sp_counted_base<_Lp>
{
class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc>
{
typedef _Sp_ebo_helper<0, _Deleter> _Del_base;
typedef _Sp_ebo_helper<1, _Alloc> _Alloc_base;
public:
_Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
: _M_ptr(__p), _Del_base(__d), _Alloc_base(__a)
{ }
_Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); }
_Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); }
_Ptr _M_ptr;
};
public:
using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_deleter>;
_Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept
: _M_impl(__p, __d, _Alloc()) { }
_Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
: _M_impl(__p, __d, __a) { }
~_Sp_counted_deleter() noexcept { }
virtual void
_M_dispose() noexcept
{ _M_impl._M_del()(_M_impl._M_ptr); }
virtual void
_M_destroy() noexcept
{
__allocator_type __a(_M_impl._M_alloc());
__allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
this->~_Sp_counted_deleter();
}
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept
{
return __ti == typeid(_Deleter) ? &_M_impl._M_del() : nullptr;
}
private:
_Impl _M_impl;
};
struct _Sp_make_shared_tag { };
template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp>
{
class _Impl : _Sp_ebo_helper<0, _Alloc>
{
typedef _Sp_ebo_helper<0, _Alloc> _A_base;
public:
explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { }
_Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); }
__gnu_cxx::__aligned_buffer<_Tp> _M_storage;
};
public:
using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>;
template<typename... _Args>
_Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
: _M_impl(__a)
{
allocator_traits<_Alloc>::construct(__a, _M_ptr(),
std::forward<_Args>(__args)...);
}
~_Sp_counted_ptr_inplace() noexcept { }
virtual void
_M_dispose() noexcept
{
allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
}
virtual void
_M_destroy() noexcept
{
__allocator_type __a(_M_impl._M_alloc());
__allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
this->~_Sp_counted_ptr_inplace();
}
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept
{
if (__ti == typeid(_Sp_make_shared_tag))
return const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
return nullptr;
}
private:
_Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); }
_Impl _M_impl;
};
template<_Lock_policy _Lp>
class __shared_count
{
public:
constexpr __shared_count() noexcept : _M_pi(0)
{ }
template<typename _Ptr>
explicit
__shared_count(_Ptr __p) : _M_pi(0)
{
try
{
_M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
}
catch(...)
{
delete __p;
throw;
}
}
template<typename _Ptr, typename _Deleter>
__shared_count(_Ptr __p, _Deleter __d)
: __shared_count(__p, std::move(__d), allocator<void>())
{ }
template<typename _Ptr, typename _Deleter, typename _Alloc>
__shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
{
typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
try
{
typename _Sp_cd_type::__allocator_type __a2(__a);
auto __guard = std::__allocate_guarded(__a2);
_Sp_cd_type* __mem = __guard.get();
::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a));
_M_pi = __mem;
__guard = nullptr;
}
catch(...)
{
__d(__p);
throw;
}
}
template<typename _Tp, typename _Alloc, typename... _Args>
__shared_count(_Sp_make_shared_tag, _Tp*, const _Alloc& __a,
_Args&&... __args)
: _M_pi(0)
{
typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
typename _Sp_cp_type::__allocator_type __a2(__a);
auto __guard = std::__allocate_guarded(__a2);
_Sp_cp_type* __mem = __guard.get();
::new (__mem) _Sp_cp_type(std::move(__a),
std::forward<_Args>(__args)...);
_M_pi = __mem;
__guard = nullptr;
}
template<typename _Tp>
explicit
__shared_count(std::auto_ptr<_Tp>&& __r);
template<typename _Tp, typename _Del>
explicit
__shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0)
{
using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
using _Del2 = typename conditional<is_reference<_Del>::value,
reference_wrapper<typename remove_reference<_Del>::type>,
_Del>::type;
using _Sp_cd_type
= _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
using _Alloc = allocator<_Sp_cd_type>;
using _Alloc_traits = allocator_traits<_Alloc>;
_Alloc __a;
_Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1);
_Alloc_traits::construct(__a, __mem, __r.release(),
__r.get_deleter());
_M_pi = __mem;
}
explicit __shared_count(const __weak_count<_Lp>& __r);
explicit __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t);
~__shared_count() noexcept
{
if (_M_pi != nullptr)
_M_pi->_M_release();
}
__shared_count(const __shared_count& __r) noexcept
: _M_pi(__r._M_pi)
{
if (_M_pi != 0)
_M_pi->_M_add_ref_copy();
}
__shared_count&
operator=(const __shared_count& __r) noexcept
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != _M_pi)
{
if (__tmp != 0)
__tmp->_M_add_ref_copy();
if (_M_pi != 0)
_M_pi->_M_release();
_M_pi = __tmp;
}
return *this;
}
void
_M_swap(__shared_count& __r) noexcept
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
}
long
_M_get_use_count() const noexcept
{ return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
bool
_M_unique() const noexcept
{ return this->_M_get_use_count() == 1; }
void*
_M_get_deleter(const std::type_info& __ti) const noexcept
{ return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; }
bool
_M_less(const __shared_count& __rhs) const noexcept
{ return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
bool
_M_less(const __weak_count<_Lp>& __rhs) const noexcept
{ return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
friend inline bool
operator==(const __shared_count& __a, const __shared_count& __b) noexcept
{ return __a._M_pi == __b._M_pi; }
private:
friend class __weak_count<_Lp>;
_Sp_counted_base<_Lp>* _M_pi;
};
template<_Lock_policy _Lp>
class __weak_count
{
public:
constexpr __weak_count() noexcept : _M_pi(0)
{ }
__weak_count(const __shared_count<_Lp>& __r) noexcept
: _M_pi(__r._M_pi)
{
if (_M_pi != 0)
_M_pi->_M_weak_add_ref();
}
__weak_count(const __weak_count<_Lp>& __r) noexcept
: _M_pi(__r._M_pi)
{
if (_M_pi != 0)
_M_pi->_M_weak_add_ref();
}
~__weak_count() noexcept
{
if (_M_pi != 0)
_M_pi->_M_weak_release();
}
__weak_count<_Lp>&
operator=(const __shared_count<_Lp>& __r) noexcept
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != 0)
__tmp->_M_weak_add_ref();
if (_M_pi != 0)
_M_pi->_M_weak_release();
_M_pi = __tmp;
return *this;
}
__weak_count<_Lp>&
operator=(const __weak_count<_Lp>& __r) noexcept
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != 0)
__tmp->_M_weak_add_ref();
if (_M_pi != 0)
_M_pi->_M_weak_release();
_M_pi = __tmp;
return *this;
}
void
_M_swap(__weak_count<_Lp>& __r) noexcept
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
}
long
_M_get_use_count() const noexcept
{ return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
bool
_M_less(const __weak_count& __rhs) const noexcept
{ return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
bool
_M_less(const __shared_count<_Lp>& __rhs) const noexcept
{ return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
friend inline bool
operator==(const __weak_count& __a, const __weak_count& __b) noexcept
{ return __a._M_pi == __b._M_pi; }
private:
friend class __shared_count<_Lp>;
_Sp_counted_base<_Lp>* _M_pi;
};
template<_Lock_policy _Lp>
inline
__shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r)
: _M_pi(__r._M_pi)
{
if (_M_pi != nullptr)
_M_pi->_M_add_ref_lock();
else
__throw_bad_weak_ptr();
}
template<_Lock_policy _Lp>
inline
__shared_count<_Lp>::
__shared_count(const __weak_count<_Lp>& __r, std::nothrow_t)
: _M_pi(__r._M_pi)
{
if (_M_pi != nullptr)
if (!_M_pi->_M_add_ref_lock_nothrow())
_M_pi = nullptr;
}
template<_Lock_policy _Lp, typename _Tp1, typename _Tp2>
void
__enable_shared_from_this_helper(const __shared_count<_Lp>&,
const __enable_shared_from_this<_Tp1,
_Lp>*, const _Tp2*) noexcept;
template<typename _Tp1, typename _Tp2>
void
__enable_shared_from_this_helper(const __shared_count<>&,
const enable_shared_from_this<_Tp1>*,
const _Tp2*) noexcept;
template<_Lock_policy _Lp>
inline void
__enable_shared_from_this_helper(const __shared_count<_Lp>&, ...) noexcept
{ }
template<typename _Tp, _Lock_policy _Lp>
class __shared_ptr
{
public:
typedef _Tp element_type;
constexpr __shared_ptr() noexcept
: _M_ptr(0), _M_refcount()
{ }
template<typename _Tp1>
explicit __shared_ptr(_Tp1* __p)
: _M_ptr(__p), _M_refcount(__p)
{
static_assert( !is_void<_Tp1>::value, "incomplete type" );
static_assert( sizeof(_Tp1) > 0, "incomplete type" );
__enable_shared_from_this_helper(_M_refcount, __p, __p);
}
template<typename _Tp1, typename _Deleter>
__shared_ptr(_Tp1* __p, _Deleter __d)
: _M_ptr(__p), _M_refcount(__p, __d)
{
__enable_shared_from_this_helper(_M_refcount, __p, __p);
}
template<typename _Tp1, typename _Deleter, typename _Alloc>
__shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)
: _M_ptr(__p), _M_refcount(__p, __d, std::move(__a))
{
__enable_shared_from_this_helper(_M_refcount, __p, __p);
}
template<typename _Deleter>
__shared_ptr(nullptr_t __p, _Deleter __d)
: _M_ptr(0), _M_refcount(__p, __d)
{ }
template<typename _Deleter, typename _Alloc>
__shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
: _M_ptr(0), _M_refcount(__p, __d, std::move(__a))
{ }
template<typename _Tp1>
__shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, _Tp* __p) noexcept
: _M_ptr(__p), _M_refcount(__r._M_refcount)
{ }
__shared_ptr(const __shared_ptr&) noexcept = default;
__shared_ptr& operator=(const __shared_ptr&) noexcept = default;
~__shared_ptr() = default;
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
__shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
{ }
__shared_ptr(__shared_ptr&& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount()
{
_M_refcount._M_swap(__r._M_refcount);
__r._M_ptr = 0;
}
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
__shared_ptr(__shared_ptr<_Tp1, _Lp>&& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount()
{
_M_refcount._M_swap(__r._M_refcount);
__r._M_ptr = 0;
}
template<typename _Tp1>
explicit __shared_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
: _M_refcount(__r._M_refcount)
{
_M_ptr = __r._M_ptr;
}
template<typename _Tp1, typename _Del>
__shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r)
: _M_ptr(__r.get()), _M_refcount()
{
auto __raw = _S_raw_ptr(__r.get());
_M_refcount = __shared_count<_Lp>(std::move(__r));
__enable_shared_from_this_helper(_M_refcount, __raw, __raw);
}
template<typename _Tp1>
__shared_ptr(std::auto_ptr<_Tp1>&& __r);
constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { }
template<typename _Tp1>
__shared_ptr&
operator=(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
{
_M_ptr = __r._M_ptr;
_M_refcount = __r._M_refcount;
return *this;
}
template<typename _Tp1>
__shared_ptr&
operator=(std::auto_ptr<_Tp1>&& __r)
{
__shared_ptr(std::move(__r)).swap(*this);
return *this;
}
__shared_ptr&
operator=(__shared_ptr&& __r) noexcept
{
__shared_ptr(std::move(__r)).swap(*this);
return *this;
}
template<class _Tp1>
__shared_ptr&
operator=(__shared_ptr<_Tp1, _Lp>&& __r) noexcept
{
__shared_ptr(std::move(__r)).swap(*this);
return *this;
}
template<typename _Tp1, typename _Del>
__shared_ptr&
operator=(std::unique_ptr<_Tp1, _Del>&& __r)
{
__shared_ptr(std::move(__r)).swap(*this);
return *this;
}
void
reset() noexcept
{ __shared_ptr().swap(*this); }
template<typename _Tp1>
void
reset(_Tp1* __p)
{
;
__shared_ptr(__p).swap(*this);
}
template<typename _Tp1, typename _Deleter>
void
reset(_Tp1* __p, _Deleter __d)
{ __shared_ptr(__p, __d).swap(*this); }
template<typename _Tp1, typename _Deleter, typename _Alloc>
void
reset(_Tp1* __p, _Deleter __d, _Alloc __a)
{ __shared_ptr(__p, __d, std::move(__a)).swap(*this); }
typename std::add_lvalue_reference<_Tp>::type
operator*() const noexcept
{
;
return *_M_ptr;
}
_Tp*
operator->() const noexcept
{
;
return _M_ptr;
}
_Tp*
get() const noexcept
{ return _M_ptr; }
explicit operator bool() const
{ return _M_ptr == 0 ? false : true; }
bool
unique() const noexcept
{ return _M_refcount._M_unique(); }
long
use_count() const noexcept
{ return _M_refcount._M_get_use_count(); }
void
swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
{
std::swap(_M_ptr, __other._M_ptr);
_M_refcount._M_swap(__other._M_refcount);
}
template<typename _Tp1>
bool
owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const
{ return _M_refcount._M_less(__rhs._M_refcount); }
template<typename _Tp1>
bool
owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const
{ return _M_refcount._M_less(__rhs._M_refcount); }
protected:
template<typename _Alloc, typename... _Args>
__shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
_Args&&... __args)
: _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a,
std::forward<_Args>(__args)...)
{
void* __p = _M_refcount._M_get_deleter(typeid(__tag));
_M_ptr = static_cast<_Tp*>(__p);
__enable_shared_from_this_helper(_M_refcount, _M_ptr, _M_ptr);
}
template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
typename... _Args>
friend __shared_ptr<_Tp1, _Lp1>
__allocate_shared(const _Alloc& __a, _Args&&... __args);
__shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t)
: _M_refcount(__r._M_refcount, std::nothrow)
{
_M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr;
}
friend class __weak_ptr<_Tp, _Lp>;
private:
void*
_M_get_deleter(const std::type_info& __ti) const noexcept
{ return _M_refcount._M_get_deleter(__ti); }
template<typename _Tp1>
static _Tp1*
_S_raw_ptr(_Tp1* __ptr)
{ return __ptr; }
template<typename _Tp1>
static auto
_S_raw_ptr(_Tp1 __ptr) -> decltype(std::__addressof(*__ptr))
{ return std::__addressof(*__ptr); }
template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept;
_Tp* _M_ptr;
__shared_count<_Lp> _M_refcount;
};
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool
operator==(const __shared_ptr<_Tp1, _Lp>& __a,
const __shared_ptr<_Tp2, _Lp>& __b) noexcept
{ return __a.get() == __b.get(); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
{ return !__a; }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
{ return !__a; }
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool
operator!=(const __shared_ptr<_Tp1, _Lp>& __a,
const __shared_ptr<_Tp2, _Lp>& __b) noexcept
{ return __a.get() != __b.get(); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
{ return (bool)__a; }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
{ return (bool)__a; }
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool
operator<(const __shared_ptr<_Tp1, _Lp>& __a,
const __shared_ptr<_Tp2, _Lp>& __b) noexcept
{
typedef typename std::common_type<_Tp1*, _Tp2*>::type _CT;
return std::less<_CT>()(__a.get(), __b.get());
}
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
{ return std::less<_Tp*>()(__a.get(), nullptr); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
{ return std::less<_Tp*>()(nullptr, __a.get()); }
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool
operator<=(const __shared_ptr<_Tp1, _Lp>& __a,
const __shared_ptr<_Tp2, _Lp>& __b) noexcept
{ return !(__b < __a); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
{ return !(nullptr < __a); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
{ return !(__a < nullptr); }
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool
operator>(const __shared_ptr<_Tp1, _Lp>& __a,
const __shared_ptr<_Tp2, _Lp>& __b) noexcept
{ return (__b < __a); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
{ return std::less<_Tp*>()(nullptr, __a.get()); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
{ return std::less<_Tp*>()(__a.get(), nullptr); }
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool
operator>=(const __shared_ptr<_Tp1, _Lp>& __a,
const __shared_ptr<_Tp2, _Lp>& __b) noexcept
{ return !(__a < __b); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
{ return !(__a < nullptr); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
{ return !(nullptr < __a); }
template<typename _Sp>
struct _Sp_less : public binary_function<_Sp, _Sp, bool>
{
bool
operator()(const _Sp& __lhs, const _Sp& __rhs) const noexcept
{
typedef typename _Sp::element_type element_type;
return std::less<element_type*>()(__lhs.get(), __rhs.get());
}
};
template<typename _Tp, _Lock_policy _Lp>
struct less<__shared_ptr<_Tp, _Lp>>
: public _Sp_less<__shared_ptr<_Tp, _Lp>>
{ };
template<typename _Tp, _Lock_policy _Lp>
inline void
swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept
{ __a.swap(__b); }
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
inline __shared_ptr<_Tp, _Lp>
static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
{ return __shared_ptr<_Tp, _Lp>(__r, static_cast<_Tp*>(__r.get())); }
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
inline __shared_ptr<_Tp, _Lp>
const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
{ return __shared_ptr<_Tp, _Lp>(__r, const_cast<_Tp*>(__r.get())); }
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
inline __shared_ptr<_Tp, _Lp>
dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
{
if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
return __shared_ptr<_Tp, _Lp>(__r, __p);
return __shared_ptr<_Tp, _Lp>();
}
template<typename _Tp, _Lock_policy _Lp>
class __weak_ptr
{
public:
typedef _Tp element_type;
constexpr __weak_ptr() noexcept
: _M_ptr(0), _M_refcount()
{ }
__weak_ptr(const __weak_ptr&) noexcept = default;
__weak_ptr& operator=(const __weak_ptr&) noexcept = default;
~__weak_ptr() = default;
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
__weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r) noexcept
: _M_refcount(__r._M_refcount)
{ _M_ptr = __r.lock().get(); }
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
__weak_ptr(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
{ }
template<typename _Tp1>
__weak_ptr&
operator=(const __weak_ptr<_Tp1, _Lp>& __r) noexcept
{
_M_ptr = __r.lock().get();
_M_refcount = __r._M_refcount;
return *this;
}
template<typename _Tp1>
__weak_ptr&
operator=(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
{
_M_ptr = __r._M_ptr;
_M_refcount = __r._M_refcount;
return *this;
}
__shared_ptr<_Tp, _Lp>
lock() const noexcept
{ return __shared_ptr<element_type, _Lp>(*this, std::nothrow); }
long
use_count() const noexcept
{ return _M_refcount._M_get_use_count(); }
bool
expired() const noexcept
{ return _M_refcount._M_get_use_count() == 0; }
template<typename _Tp1>
bool
owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const
{ return _M_refcount._M_less(__rhs._M_refcount); }
template<typename _Tp1>
bool
owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const
{ return _M_refcount._M_less(__rhs._M_refcount); }
void
reset() noexcept
{ __weak_ptr().swap(*this); }
void
swap(__weak_ptr& __s) noexcept
{
std::swap(_M_ptr, __s._M_ptr);
_M_refcount._M_swap(__s._M_refcount);
}
private:
void
_M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept
{
_M_ptr = __ptr;
_M_refcount = __refcount;
}
template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
friend class __enable_shared_from_this<_Tp, _Lp>;
friend class enable_shared_from_this<_Tp>;
_Tp* _M_ptr;
__weak_count<_Lp> _M_refcount;
};
template<typename _Tp, _Lock_policy _Lp>
inline void
swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept
{ __a.swap(__b); }
template<typename _Tp, typename _Tp1>
struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __lhs, const _Tp& __rhs) const
{ return __lhs.owner_before(__rhs); }
bool
operator()(const _Tp& __lhs, const _Tp1& __rhs) const
{ return __lhs.owner_before(__rhs); }
bool
operator()(const _Tp1& __lhs, const _Tp& __rhs) const
{ return __lhs.owner_before(__rhs); }
};
template<typename _Tp, _Lock_policy _Lp>
struct owner_less<__shared_ptr<_Tp, _Lp>>
: public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
{ };
template<typename _Tp, _Lock_policy _Lp>
struct owner_less<__weak_ptr<_Tp, _Lp>>
: public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
{ };
template<typename _Tp, _Lock_policy _Lp>
class __enable_shared_from_this
{
protected:
constexpr __enable_shared_from_this() noexcept { }
__enable_shared_from_this(const __enable_shared_from_this&) noexcept { }
__enable_shared_from_this&
operator=(const __enable_shared_from_this&) noexcept
{ return *this; }
~__enable_shared_from_this() { }
public:
__shared_ptr<_Tp, _Lp>
shared_from_this()
{ return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }
__shared_ptr<const _Tp, _Lp>
shared_from_this() const
{ return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }
private:
template<typename _Tp1>
void
_M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept
{ _M_weak_this._M_assign(__p, __n); }
template<typename _Tp1>
friend void
__enable_shared_from_this_helper(const __shared_count<_Lp>& __pn,
const __enable_shared_from_this* __pe,
const _Tp1* __px) noexcept
{
if (__pe != 0)
__pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
}
mutable __weak_ptr<_Tp, _Lp> _M_weak_this;
};
template<typename _Tp, _Lock_policy _Lp, typename _Alloc, typename... _Args>
inline __shared_ptr<_Tp, _Lp>
__allocate_shared(const _Alloc& __a, _Args&&... __args)
{
return __shared_ptr<_Tp, _Lp>(_Sp_make_shared_tag(), __a,
std::forward<_Args>(__args)...);
}
template<typename _Tp, _Lock_policy _Lp, typename... _Args>
inline __shared_ptr<_Tp, _Lp>
__make_shared(_Args&&... __args)
{
typedef typename std::remove_const<_Tp>::type _Tp_nc;
return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
std::forward<_Args>(__args)...);
}
template<typename _Tp, _Lock_policy _Lp>
struct hash<__shared_ptr<_Tp, _Lp>>
: public __hash_base<size_t, __shared_ptr<_Tp, _Lp>>
{
size_t
operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept
{ return std::hash<_Tp*>()(__s.get()); }
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
inline std::basic_ostream<_Ch, _Tr>&
operator<<(std::basic_ostream<_Ch, _Tr>& __os,
const __shared_ptr<_Tp, _Lp>& __p)
{
__os << __p.get();
return __os;
}
template<typename _Del, typename _Tp, _Lock_policy _Lp>
inline _Del*
get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept
{
return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
}
template<typename _Tp>
class shared_ptr : public __shared_ptr<_Tp>
{
public:
constexpr shared_ptr() noexcept
: __shared_ptr<_Tp>() { }
shared_ptr(const shared_ptr&) noexcept = default;
template<typename _Tp1>
explicit shared_ptr(_Tp1* __p)
: __shared_ptr<_Tp>(__p) { }
template<typename _Tp1, typename _Deleter>
shared_ptr(_Tp1* __p, _Deleter __d)
: __shared_ptr<_Tp>(__p, __d) { }
template<typename _Deleter>
shared_ptr(nullptr_t __p, _Deleter __d)
: __shared_ptr<_Tp>(__p, __d) { }
template<typename _Tp1, typename _Deleter, typename _Alloc>
shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)
: __shared_ptr<_Tp>(__p, __d, std::move(__a)) { }
template<typename _Deleter, typename _Alloc>
shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
: __shared_ptr<_Tp>(__p, __d, std::move(__a)) { }
template<typename _Tp1>
shared_ptr(const shared_ptr<_Tp1>& __r, _Tp* __p) noexcept
: __shared_ptr<_Tp>(__r, __p) { }
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
shared_ptr(const shared_ptr<_Tp1>& __r) noexcept
: __shared_ptr<_Tp>(__r) { }
shared_ptr(shared_ptr&& __r) noexcept
: __shared_ptr<_Tp>(std::move(__r)) { }
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
shared_ptr(shared_ptr<_Tp1>&& __r) noexcept
: __shared_ptr<_Tp>(std::move(__r)) { }
template<typename _Tp1>
explicit shared_ptr(const weak_ptr<_Tp1>& __r)
: __shared_ptr<_Tp>(__r) { }
template<typename _Tp1>
shared_ptr(std::auto_ptr<_Tp1>&& __r);
template<typename _Tp1, typename _Del>
shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r)
: __shared_ptr<_Tp>(std::move(__r)) { }
constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }
shared_ptr& operator=(const shared_ptr&) noexcept = default;
template<typename _Tp1>
shared_ptr&
operator=(const shared_ptr<_Tp1>& __r) noexcept
{
this->__shared_ptr<_Tp>::operator=(__r);
return *this;
}
template<typename _Tp1>
shared_ptr&
operator=(std::auto_ptr<_Tp1>&& __r)
{
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
}
shared_ptr&
operator=(shared_ptr&& __r) noexcept
{
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
}
template<class _Tp1>
shared_ptr&
operator=(shared_ptr<_Tp1>&& __r) noexcept
{
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
}
template<typename _Tp1, typename _Del>
shared_ptr&
operator=(std::unique_ptr<_Tp1, _Del>&& __r)
{
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
}
private:
template<typename _Alloc, typename... _Args>
shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
_Args&&... __args)
: __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...)
{ }
template<typename _Tp1, typename _Alloc, typename... _Args>
friend shared_ptr<_Tp1>
allocate_shared(const _Alloc& __a, _Args&&... __args);
shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t)
: __shared_ptr<_Tp>(__r, std::nothrow) { }
friend class weak_ptr<_Tp>;
};
template<typename _Tp1, typename _Tp2>
inline bool
operator==(const shared_ptr<_Tp1>& __a,
const shared_ptr<_Tp2>& __b) noexcept
{ return __a.get() == __b.get(); }
template<typename _Tp>
inline bool
operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
{ return !__a; }
template<typename _Tp>
inline bool
operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
{ return !__a; }
template<typename _Tp1, typename _Tp2>
inline bool
operator!=(const shared_ptr<_Tp1>& __a,
const shared_ptr<_Tp2>& __b) noexcept
{ return __a.get() != __b.get(); }
template<typename _Tp>
inline bool
operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
{ return (bool)__a; }
template<typename _Tp>
inline bool
operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
{ return (bool)__a; }
template<typename _Tp1, typename _Tp2>
inline bool
operator<(const shared_ptr<_Tp1>& __a,
const shared_ptr<_Tp2>& __b) noexcept
{
typedef typename std::common_type<_Tp1*, _Tp2*>::type _CT;
return std::less<_CT>()(__a.get(), __b.get());
}
template<typename _Tp>
inline bool
operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
{ return std::less<_Tp*>()(__a.get(), nullptr); }
template<typename _Tp>
inline bool
operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
{ return std::less<_Tp*>()(nullptr, __a.get()); }
template<typename _Tp1, typename _Tp2>
inline bool
operator<=(const shared_ptr<_Tp1>& __a,
const shared_ptr<_Tp2>& __b) noexcept
{ return !(__b < __a); }
template<typename _Tp>
inline bool
operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
{ return !(nullptr < __a); }
template<typename _Tp>
inline bool
operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
{ return !(__a < nullptr); }
template<typename _Tp1, typename _Tp2>
inline bool
operator>(const shared_ptr<_Tp1>& __a,
const shared_ptr<_Tp2>& __b) noexcept
{ return (__b < __a); }
template<typename _Tp>
inline bool
operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
{ return std::less<_Tp*>()(nullptr, __a.get()); }
template<typename _Tp>
inline bool
operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
{ return std::less<_Tp*>()(__a.get(), nullptr); }
template<typename _Tp1, typename _Tp2>
inline bool
operator>=(const shared_ptr<_Tp1>& __a,
const shared_ptr<_Tp2>& __b) noexcept
{ return !(__a < __b); }
template<typename _Tp>
inline bool
operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
{ return !(__a < nullptr); }
template<typename _Tp>
inline bool
operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
{ return !(nullptr < __a); }
template<typename _Tp>
struct less<shared_ptr<_Tp>> : public _Sp_less<shared_ptr<_Tp>>
{ };
template<typename _Tp>
inline void
swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept
{ __a.swap(__b); }
template<typename _Tp, typename _Tp1>
inline shared_ptr<_Tp>
static_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept
{ return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get())); }
template<typename _Tp, typename _Tp1>
inline shared_ptr<_Tp>
const_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept
{ return shared_ptr<_Tp>(__r, const_cast<_Tp*>(__r.get())); }
template<typename _Tp, typename _Tp1>
inline shared_ptr<_Tp>
dynamic_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept
{
if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
return shared_ptr<_Tp>(__r, __p);
return shared_ptr<_Tp>();
}
template<typename _Tp>
class weak_ptr : public __weak_ptr<_Tp>
{
public:
constexpr weak_ptr() noexcept
: __weak_ptr<_Tp>() { }
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
weak_ptr(const weak_ptr<_Tp1>& __r) noexcept
: __weak_ptr<_Tp>(__r) { }
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
weak_ptr(const shared_ptr<_Tp1>& __r) noexcept
: __weak_ptr<_Tp>(__r) { }
template<typename _Tp1>
weak_ptr&
operator=(const weak_ptr<_Tp1>& __r) noexcept
{
this->__weak_ptr<_Tp>::operator=(__r);
return *this;
}
template<typename _Tp1>
weak_ptr&
operator=(const shared_ptr<_Tp1>& __r) noexcept
{
this->__weak_ptr<_Tp>::operator=(__r);
return *this;
}
shared_ptr<_Tp>
lock() const noexcept
{ return shared_ptr<_Tp>(*this, std::nothrow); }
};
template<typename _Tp>
inline void
swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept
{ __a.swap(__b); }
template<typename _Tp>
struct owner_less;
template<typename _Tp>
struct owner_less<shared_ptr<_Tp>>
: public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
{ };
template<typename _Tp>
struct owner_less<weak_ptr<_Tp>>
: public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
{ };
template<typename _Tp>
class enable_shared_from_this
{
protected:
constexpr enable_shared_from_this() noexcept { }
enable_shared_from_this(const enable_shared_from_this&) noexcept { }
enable_shared_from_this&
operator=(const enable_shared_from_this&) noexcept
{ return *this; }
~enable_shared_from_this() { }
public:
shared_ptr<_Tp>
shared_from_this()
{ return shared_ptr<_Tp>(this->_M_weak_this); }
shared_ptr<const _Tp>
shared_from_this() const
{ return shared_ptr<const _Tp>(this->_M_weak_this); }
private:
template<typename _Tp1>
void
_M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept
{ _M_weak_this._M_assign(__p, __n); }
template<typename _Tp1>
friend void
__enable_shared_from_this_helper(const __shared_count<>& __pn,
const enable_shared_from_this* __pe,
const _Tp1* __px) noexcept
{
if (__pe != 0)
__pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
}
mutable weak_ptr<_Tp> _M_weak_this;
};
template<typename _Tp, typename _Alloc, typename... _Args>
inline shared_ptr<_Tp>
allocate_shared(const _Alloc& __a, _Args&&... __args)
{
return shared_ptr<_Tp>(_Sp_make_shared_tag(), __a,
std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args>
inline shared_ptr<_Tp>
make_shared(_Args&&... __args)
{
typedef typename std::remove_const<_Tp>::type _Tp_nc;
return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
std::forward<_Args>(__args)...);
}
template<typename _Tp>
struct hash<shared_ptr<_Tp>>
: public __hash_base<size_t, shared_ptr<_Tp>>
{
size_t
operator()(const shared_ptr<_Tp>& __s) const noexcept
{ return std::hash<_Tp*>()(__s.get()); }
};
}
#define _BACKWARD_AUTO_PTR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp1>
struct auto_ptr_ref
{
_Tp1* _M_ptr;
explicit
auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
} __attribute__ ((__deprecated__));
template<typename _Tp>
class auto_ptr
{
private:
_Tp* _M_ptr;
public:
typedef _Tp element_type;
explicit
auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
auto_ptr(auto_ptr& __a) throw() ;
template<typename _Tp1>
auto_ptr(auto_ptr<_Tp1>& __a) throw() ;
auto_ptr&
operator=(auto_ptr& __a) throw()
;
template<typename _Tp1>
auto_ptr&
operator=(auto_ptr<_Tp1>& __a) throw()
;
~auto_ptr() ;
element_type&
operator*() const throw()
;
element_type*
operator->() const throw()
;
element_type*
get() const throw() ;
element_type*
release() throw()
;
void
reset(element_type* __p = 0) throw()
;
auto_ptr(auto_ptr_ref<element_type> __ref) throw() ;
auto_ptr&
operator=(auto_ptr_ref<element_type> __ref) throw()
;
template<typename _Tp1>
operator auto_ptr_ref<_Tp1>() throw()
;
template<typename _Tp1>
operator auto_ptr<_Tp1>() throw()
;
} __attribute__ ((__deprecated__));
template<>
class auto_ptr<void>
{
public:
typedef void element_type;
} __attribute__ ((__deprecated__));
template<typename _Tp, _Lock_policy _Lp>
template<typename _Tp1>
inline
__shared_ptr<_Tp, _Lp>::__shared_ptr(std::auto_ptr<_Tp1>&& __r)
: _M_ptr(__r.get()), _M_refcount()
{
static_assert( sizeof(_Tp1) > 0, "incomplete type" );
_Tp1* __tmp = __r.get();
_M_refcount = __shared_count<_Lp>(std::move(__r));
__enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
}
template<typename _Tp>
template<typename _Tp1>
inline
shared_ptr<_Tp>::shared_ptr(std::auto_ptr<_Tp1>&& __r)
: __shared_ptr<_Tp>(std::move(__r)) { }
template<typename _Tp, typename _Dp>
template<typename _Up, typename>
inline
unique_ptr<_Tp, _Dp>::unique_ptr(auto_ptr<_Up>&& __u) noexcept
: _M_t(__u.release(), deleter_type()) { }
}
namespace boost {
namespace asio {
namespace detail {
using std::addressof;
}
}
}
#define BOOST_ASIO_HANDLER_ALLOC_HOOK_HPP
namespace boost {
namespace asio {
inline void* asio_handler_allocate(
std::size_t size, ...);
inline void asio_handler_deallocate(
void* pointer, std::size_t size, ...);
}
}
#define BOOST_ASIO_IMPL_HANDLER_ALLOC_HOOK_IPP
#define BOOST_ASIO_DETAIL_CALL_STACK_HPP
#define BOOST_ASIO_DETAIL_TSS_PTR_HPP
#define BOOST_ASIO_DETAIL_KEYWORD_TSS_PTR_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename T>
class keyword_tss_ptr
: private noncopyable
{
public:
keyword_tss_ptr()
;
~keyword_tss_ptr()
;
operator T*() const
;
void operator=(T* value)
;
private:
static __thread T* value_;
};
template <typename T>
__thread T* keyword_tss_ptr<T>::value_;
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename T>
class tss_ptr
: public keyword_tss_ptr<T>
{
public:
void operator=(T* value)
;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Key, typename Value = unsigned char>
class call_stack
{
public:
class context
: private noncopyable
{
public:
explicit context(Key* k)
;
context(Key* k, Value& v)
;
~context()
;
Value* next_by_key() const
;
private:
friend class call_stack<Key, Value>;
Key* key_;
Value* value_;
context* next_;
};
friend class context;
static Value* contains(Key* k)
;
static Value* top()
;
private:
static tss_ptr<context> top_;
};
template <typename Key, typename Value>
tss_ptr<typename call_stack<Key, Value>::context>
call_stack<Key, Value>::top_;
}
}
}
#define BOOST_ASIO_DETAIL_TASK_IO_SERVICE_THREAD_INFO_HPP
#define BOOST_ASIO_DETAIL_EVENT_HPP
#define BOOST_ASIO_DETAIL_POSIX_EVENT_HPP
#define BOOST_ASIO_DETAIL_ASSERT_HPP
#undef BOOST_ASSERT
#define _ASSERT_H 1
#define __ASSERT_VOID_CAST static_cast<void>
#define assert(expr) (__ASSERT_VOID_CAST (0))
#define assert_perror(errnum) (__ASSERT_VOID_CAST (0))
#define BOOST_ASSERT(expr) assert(expr)
#undef BOOST_ASSERT_MSG
#define BOOST_ASSERT_MSG(expr,msg) ((void)0)
#undef BOOST_VERIFY
#define BOOST_VERIFY(expr) ((void)(expr))
#define BOOST_ASIO_ASSERT(expr) BOOST_ASSERT(expr)
namespace boost {
namespace asio {
namespace detail {
class posix_event
: private noncopyable
{
public:
inline posix_event();
~posix_event()
;
template <typename Lock>
void signal(Lock& lock)
;
template <typename Lock>
void signal_and_unlock(Lock& lock)
;
template <typename Lock>
void clear(Lock& lock)
;
template <typename Lock>
void wait(Lock& lock)
;
private:
::pthread_cond_t cond_;
bool signalled_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_POSIX_EVENT_IPP
#define BOOST_ASIO_DETAIL_THROW_ERROR_HPP
#define BOOST_ERROR_CODE_HPP
#define BOOST_SYSTEM_CONFIG_HPP
#define BOOST_SYSTEM_API_CONFIG_HPP
#define BOOST_POSIX_API
#define BOOST_SYSTEM_STATIC_LINK
#define BOOST_SYSTEM_DECL
#define BOOST_LIB_NAME boost_system
#undef BOOST_LIB_NAME
#define BOOST_CSTDINT_HPP
namespace boost
{
using ::int8_t;
using ::int_least8_t;
using ::int_fast8_t;
using ::uint8_t;
using ::uint_least8_t;
using ::uint_fast8_t;
using ::int16_t;
using ::int_least16_t;
using ::int_fast16_t;
using ::uint16_t;
using ::uint_least16_t;
using ::uint_fast16_t;
using ::int32_t;
using ::int_least32_t;
using ::int_fast32_t;
using ::uint32_t;
using ::uint_least32_t;
using ::uint_fast32_t;
using ::int64_t;
using ::int_least64_t;
using ::int_fast64_t;
using ::uint64_t;
using ::uint_least64_t;
using ::uint_fast64_t;
using ::intmax_t;
using ::uintmax_t;
}
namespace boost {
using ::intptr_t;
using ::uintptr_t;
}
#define BOOST_HAS_INTPTR_T
#undef BOOST_ASSERT
#undef _ASSERT_H
#undef assert
#undef __ASSERT_VOID_CAST
#undef assert_perror
#define _ASSERT_H 1
#define __ASSERT_VOID_CAST static_cast<void>
#define assert(expr) (__ASSERT_VOID_CAST (0))
#define assert_perror(errnum) (__ASSERT_VOID_CAST (0))
#define BOOST_ASSERT(expr) assert(expr)
#undef BOOST_ASSERT_MSG
#define BOOST_ASSERT_MSG(expr,msg) ((void)0)
#undef BOOST_VERIFY
#define BOOST_VERIFY(expr) ((void)(expr))
#define BOOST_OPERATORS_HPP
#define BOOST_ITERATOR_HPP
#define _GLIBCXX_ITERATOR 1
#define _GLIBCXX_OSTREAM 1
#define _GLIBCXX_IOS 1
#define _IOS_BASE_H 1
#define _LOCALE_CLASSES_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
class locale
{
public:
typedef int category;
class facet;
class id;
class _Impl;
friend class facet;
friend class _Impl;
template<typename _Facet>
friend bool
has_facet(const locale&) throw();
template<typename _Facet>
friend const _Facet&
use_facet(const locale&);
template<typename _Cache>
friend struct __use_cache;
static const category none = 0;
static const category ctype = 1L << 0;
static const category numeric = 1L << 1;
static const category collate = 1L << 2;
static const category time = 1L << 3;
static const category monetary = 1L << 4;
static const category messages = 1L << 5;
static const category all = (ctype | numeric | collate |
time | monetary | messages);
locale() throw();
locale(const locale& __other) throw();
explicit
locale(const char* __s);
locale(const locale& __base, const char* __s, category __cat);
locale(const locale& __base, const locale& __add, category __cat);
template<typename _Facet>
locale(const locale& __other, _Facet* __f);
~locale() throw();
const locale&
operator=(const locale& __other) throw();
template<typename _Facet>
locale
combine(const locale& __other) const;
string
name() const;
bool
operator==(const locale& __other) const throw();
bool
operator!=(const locale& __other) const throw()
;
template<typename _Char, typename _Traits, typename _Alloc>
bool
operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
const basic_string<_Char, _Traits, _Alloc>& __s2) const;
static locale
global(const locale& __loc);
static const locale&
classic();
private:
_Impl* _M_impl;
static _Impl* _S_classic;
static _Impl* _S_global;
static const char* const* const _S_categories;
enum { _S_categories_size = 6 + 6 };
static __gthread_once_t _S_once;
explicit
locale(_Impl*) throw();
static void
_S_initialize();
static void
_S_initialize_once() throw();
static category
_S_normalize_category(category);
void
_M_coalesce(const locale& __base, const locale& __add, category __cat);
};
class locale::facet
{
private:
friend class locale;
friend class locale::_Impl;
mutable _Atomic_word _M_refcount;
static __c_locale _S_c_locale;
static const char _S_c_name[2];
static __gthread_once_t _S_once;
static void
_S_initialize_once();
protected:
explicit
facet(size_t __refs = 0) throw()
;
virtual
~facet();
static void
_S_create_c_locale(__c_locale& __cloc, const char* __s,
__c_locale __old = 0);
static __c_locale
_S_clone_c_locale(__c_locale& __cloc) throw();
static void
_S_destroy_c_locale(__c_locale& __cloc);
static __c_locale
_S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);
static __c_locale
_S_get_c_locale();
__attribute__ ((__const__)) static const char*
_S_get_c_name() throw();
private:
void
_M_add_reference() const throw()
;
void
_M_remove_reference() const throw()
;
facet(const facet&);
facet&
operator=(const facet&);
};
class locale::id
{
private:
friend class locale;
friend class locale::_Impl;
template<typename _Facet>
friend const _Facet&
use_facet(const locale&);
template<typename _Facet>
friend bool
has_facet(const locale&) throw();
mutable size_t _M_index;
static _Atomic_word _S_refcount;
void
operator=(const id&);
id(const id&);
public:
id() ;
size_t
_M_id() const throw();
};
class locale::_Impl
{
public:
friend class locale;
friend class locale::facet;
template<typename _Facet>
friend bool
has_facet(const locale&) throw();
template<typename _Facet>
friend const _Facet&
use_facet(const locale&);
template<typename _Cache>
friend struct __use_cache;
private:
_Atomic_word _M_refcount;
const facet** _M_facets;
size_t _M_facets_size;
const facet** _M_caches;
char** _M_names;
static const locale::id* const _S_id_ctype[];
static const locale::id* const _S_id_numeric[];
static const locale::id* const _S_id_collate[];
static const locale::id* const _S_id_time[];
static const locale::id* const _S_id_monetary[];
static const locale::id* const _S_id_messages[];
static const locale::id* const* const _S_facet_categories[];
void
_M_add_reference() throw()
;
void
_M_remove_reference() throw()
;
_Impl(const _Impl&, size_t);
_Impl(const char*, size_t);
_Impl(size_t) throw();
~_Impl() throw();
_Impl(const _Impl&);
void
operator=(const _Impl&);
bool
_M_check_same_name()
;
void
_M_replace_categories(const _Impl*, category);
void
_M_replace_category(const _Impl*, const locale::id* const*);
void
_M_replace_facet(const _Impl*, const locale::id*);
void
_M_install_facet(const locale::id*, const facet*);
template<typename _Facet>
void
_M_init_facet(_Facet* __facet)
;
void
_M_install_cache(const facet*, size_t);
};
template<typename _CharT>
class collate : public locale::facet
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
protected:
__c_locale _M_c_locale_collate;
public:
static locale::id id;
explicit
collate(size_t __refs = 0)
;
explicit
collate(__c_locale __cloc, size_t __refs = 0)
;
int
compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const
;
string_type
transform(const _CharT* __lo, const _CharT* __hi) const
;
long
hash(const _CharT* __lo, const _CharT* __hi) const
;
int
_M_compare(const _CharT*, const _CharT*) const throw();
size_t
_M_transform(_CharT*, const _CharT*, size_t) const throw();
protected:
virtual
~collate()
;
virtual int
do_compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const;
virtual string_type
do_transform(const _CharT* __lo, const _CharT* __hi) const;
virtual long
do_hash(const _CharT* __lo, const _CharT* __hi) const;
};
template<typename _CharT>
locale::id collate<_CharT>::id;
template<>
int
collate<char>::_M_compare(const char*, const char*) const throw();
template<>
size_t
collate<char>::_M_transform(char*, const char*, size_t) const throw();
template<>
int
collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();
template<>
size_t
collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();
template<typename _CharT>
class collate_byname : public collate<_CharT>
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
explicit
collate_byname(const char* __s, size_t __refs = 0)
;
protected:
virtual
~collate_byname() ;
};
}
#define _LOCALE_CLASSES_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Facet>
bool
has_facet(const locale& __loc) throw()
;
template<typename _Facet>
const _Facet&
use_facet(const locale& __loc)
;
extern template class collate<char>;
extern template class collate_byname<char>;
extern template
const collate<char>&
use_facet<collate<char> >(const locale&);
extern template
bool
has_facet<collate<char> >(const locale&);
extern template class collate<wchar_t>;
extern template class collate_byname<wchar_t>;
extern template
const collate<wchar_t>&
use_facet<collate<wchar_t> >(const locale&);
extern template
bool
has_facet<collate<wchar_t> >(const locale&);
}
namespace std __attribute__ ((__visibility__ ("default")))
{
enum _Ios_Fmtflags
{
_S_boolalpha = 1L << 0,
_S_dec = 1L << 1,
_S_fixed = 1L << 2,
_S_hex = 1L << 3,
_S_internal = 1L << 4,
_S_left = 1L << 5,
_S_oct = 1L << 6,
_S_right = 1L << 7,
_S_scientific = 1L << 8,
_S_showbase = 1L << 9,
_S_showpoint = 1L << 10,
_S_showpos = 1L << 11,
_S_skipws = 1L << 12,
_S_unitbuf = 1L << 13,
_S_uppercase = 1L << 14,
_S_adjustfield = _S_left | _S_right | _S_internal,
_S_basefield = _S_dec | _S_oct | _S_hex,
_S_floatfield = _S_scientific | _S_fixed,
_S_ios_fmtflags_end = 1L << 16
};
inline constexpr _Ios_Fmtflags
operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
inline constexpr _Ios_Fmtflags
operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
inline constexpr _Ios_Fmtflags
operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
inline constexpr _Ios_Fmtflags
operator~(_Ios_Fmtflags __a)
{ return _Ios_Fmtflags(~static_cast<int>(__a)); }
inline const _Ios_Fmtflags&
operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
{ return __a = __a | __b; }
inline const _Ios_Fmtflags&
operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
{ return __a = __a & __b; }
inline const _Ios_Fmtflags&
operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
{ return __a = __a ^ __b; }
enum _Ios_Openmode
{
_S_app = 1L << 0,
_S_ate = 1L << 1,
_S_bin = 1L << 2,
_S_in = 1L << 3,
_S_out = 1L << 4,
_S_trunc = 1L << 5,
_S_ios_openmode_end = 1L << 16
};
inline constexpr _Ios_Openmode
operator&(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
inline constexpr _Ios_Openmode
operator|(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
inline constexpr _Ios_Openmode
operator^(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
inline constexpr _Ios_Openmode
operator~(_Ios_Openmode __a)
{ return _Ios_Openmode(~static_cast<int>(__a)); }
inline const _Ios_Openmode&
operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
{ return __a = __a | __b; }
inline const _Ios_Openmode&
operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
{ return __a = __a & __b; }
inline const _Ios_Openmode&
operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
{ return __a = __a ^ __b; }
enum _Ios_Iostate
{
_S_goodbit = 0,
_S_badbit = 1L << 0,
_S_eofbit = 1L << 1,
_S_failbit = 1L << 2,
_S_ios_iostate_end = 1L << 16
};
inline constexpr _Ios_Iostate
operator&(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
inline constexpr _Ios_Iostate
operator|(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
inline constexpr _Ios_Iostate
operator^(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
inline constexpr _Ios_Iostate
operator~(_Ios_Iostate __a)
{ return _Ios_Iostate(~static_cast<int>(__a)); }
inline const _Ios_Iostate&
operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
{ return __a = __a | __b; }
inline const _Ios_Iostate&
operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
{ return __a = __a & __b; }
inline const _Ios_Iostate&
operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
{ return __a = __a ^ __b; }
enum _Ios_Seekdir
{
_S_beg = 0,
_S_cur = 1,
_S_end = 2,
_S_ios_seekdir_end = 1L << 16
};
class ios_base
{
public:
class failure : public exception
{
public:
explicit
failure(const string& __str) throw();
virtual
~failure() throw();
virtual const char*
what() const throw();
private:
string _M_msg;
};
typedef _Ios_Fmtflags fmtflags;
static const fmtflags boolalpha = _S_boolalpha;
static const fmtflags dec = _S_dec;
static const fmtflags fixed = _S_fixed;
static const fmtflags hex = _S_hex;
static const fmtflags internal = _S_internal;
static const fmtflags left = _S_left;
static const fmtflags oct = _S_oct;
static const fmtflags right = _S_right;
static const fmtflags scientific = _S_scientific;
static const fmtflags showbase = _S_showbase;
static const fmtflags showpoint = _S_showpoint;
static const fmtflags showpos = _S_showpos;
static const fmtflags skipws = _S_skipws;
static const fmtflags unitbuf = _S_unitbuf;
static const fmtflags uppercase = _S_uppercase;
static const fmtflags adjustfield = _S_adjustfield;
static const fmtflags basefield = _S_basefield;
static const fmtflags floatfield = _S_floatfield;
typedef _Ios_Iostate iostate;
static const iostate badbit = _S_badbit;
static const iostate eofbit = _S_eofbit;
static const iostate failbit = _S_failbit;
static const iostate goodbit = _S_goodbit;
typedef _Ios_Openmode openmode;
static const openmode app = _S_app;
static const openmode ate = _S_ate;
static const openmode binary = _S_bin;
static const openmode in = _S_in;
static const openmode out = _S_out;
static const openmode trunc = _S_trunc;
typedef _Ios_Seekdir seekdir;
static const seekdir beg = _S_beg;
static const seekdir cur = _S_cur;
static const seekdir end = _S_end;
typedef int io_state;
typedef int open_mode;
typedef int seek_dir;
typedef std::streampos streampos;
typedef std::streamoff streamoff;
enum event
{
erase_event,
imbue_event,
copyfmt_event
};
typedef void (*event_callback) (event __e, ios_base& __b, int __i);
void
register_callback(event_callback __fn, int __index);
protected:
streamsize _M_precision;
streamsize _M_width;
fmtflags _M_flags;
iostate _M_exception;
iostate _M_streambuf_state;
struct _Callback_list
{
_Callback_list* _M_next;
ios_base::event_callback _M_fn;
int _M_index;
_Atomic_word _M_refcount;
_Callback_list(ios_base::event_callback __fn, int __index,
_Callback_list* __cb) ;
void
_M_add_reference() ;
int
_M_remove_reference()
;
};
_Callback_list* _M_callbacks;
void
_M_call_callbacks(event __ev) throw();
void
_M_dispose_callbacks(void) throw();
struct _Words
{
void* _M_pword;
long _M_iword;
_Words() ;
};
_Words _M_word_zero;
enum { _S_local_word_size = 8 };
_Words _M_local_word[_S_local_word_size];
int _M_word_size;
_Words* _M_word;
_Words&
_M_grow_words(int __index, bool __iword);
locale _M_ios_locale;
void
_M_init() throw();
public:
class Init
{
friend class ios_base;
public:
Init();
~Init();
private:
static _Atomic_word _S_refcount;
static bool _S_synced_with_stdio;
};
fmtflags
flags() const
;
fmtflags
flags(fmtflags __fmtfl)
;
fmtflags
setf(fmtflags __fmtfl)
;
fmtflags
setf(fmtflags __fmtfl, fmtflags __mask)
;
void
unsetf(fmtflags __mask)
;
streamsize
precision() const
;
streamsize
precision(streamsize __prec)
;
streamsize
width() const
;
streamsize
width(streamsize __wide)
;
static bool
sync_with_stdio(bool __sync = true);
locale
imbue(const locale& __loc) throw();
locale
getloc() const
;
const locale&
_M_getloc() const
;
static int
xalloc() throw();
long&
iword(int __ix)
;
void*&
pword(int __ix)
;
virtual ~ios_base();
protected:
ios_base() throw ();
public:
ios_base(const ios_base&) = delete;
ios_base&
operator=(const ios_base&) = delete;
protected:
void
_M_move(ios_base&) noexcept;
void
_M_swap(ios_base& __rhs) noexcept;
};
ios_base&
boolalpha(ios_base& __base)
;
ios_base&
noboolalpha(ios_base& __base)
;
ios_base&
showbase(ios_base& __base)
;
ios_base&
noshowbase(ios_base& __base)
;
ios_base&
showpoint(ios_base& __base)
;
ios_base&
noshowpoint(ios_base& __base)
;
ios_base&
showpos(ios_base& __base)
;
ios_base&
noshowpos(ios_base& __base)
;
ios_base&
skipws(ios_base& __base)
;
ios_base&
noskipws(ios_base& __base)
;
ios_base&
uppercase(ios_base& __base)
;
ios_base&
nouppercase(ios_base& __base)
;
ios_base&
unitbuf(ios_base& __base)
;
ios_base&
nounitbuf(ios_base& __base)
;
ios_base&
internal(ios_base& __base)
;
ios_base&
left(ios_base& __base)
;
ios_base&
right(ios_base& __base)
;
ios_base&
dec(ios_base& __base)
;
ios_base&
hex(ios_base& __base)
;
ios_base&
oct(ios_base& __base)
;
ios_base&
fixed(ios_base& __base)
;
ios_base&
scientific(ios_base& __base)
;
}
#define _GLIBXX_STREAMBUF 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
streamsize
__copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
basic_streambuf<_CharT, _Traits>*, bool&);
template<typename _CharT, typename _Traits>
class basic_streambuf
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef basic_streambuf<char_type, traits_type> __streambuf_type;
friend class basic_ios<char_type, traits_type>;
friend class basic_istream<char_type, traits_type>;
friend class basic_ostream<char_type, traits_type>;
friend class istreambuf_iterator<char_type, traits_type>;
friend class ostreambuf_iterator<char_type, traits_type>;
friend streamsize
__copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&);
template<bool _IsMove, typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
_CharT2*>::__type
__copy_move_a2(istreambuf_iterator<_CharT2>,
istreambuf_iterator<_CharT2>, _CharT2*);
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
istreambuf_iterator<_CharT2> >::__type
find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
const _CharT2&);
template<typename _CharT2, typename _Traits2>
friend basic_istream<_CharT2, _Traits2>&
operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
template<typename _CharT2, typename _Traits2, typename _Alloc>
friend basic_istream<_CharT2, _Traits2>&
operator>>(basic_istream<_CharT2, _Traits2>&,
basic_string<_CharT2, _Traits2, _Alloc>&);
template<typename _CharT2, typename _Traits2, typename _Alloc>
friend basic_istream<_CharT2, _Traits2>&
getline(basic_istream<_CharT2, _Traits2>&,
basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);
protected:
char_type* _M_in_beg;
char_type* _M_in_cur;
char_type* _M_in_end;
char_type* _M_out_beg;
char_type* _M_out_cur;
char_type* _M_out_end;
locale _M_buf_locale;
public:
virtual
~basic_streambuf()
;
locale
pubimbue(const locale& __loc)
;
locale
getloc() const
;
basic_streambuf*
pubsetbuf(char_type* __s, streamsize __n)
;
pos_type
pubseekoff(off_type __off, ios_base::seekdir __way,
ios_base::openmode __mode = ios_base::in | ios_base::out)
;
pos_type
pubseekpos(pos_type __sp,
ios_base::openmode __mode = ios_base::in | ios_base::out)
;
int
pubsync() ;
streamsize
in_avail()
;
int_type
snextc()
;
int_type
sbumpc()
;
int_type
sgetc()
;
streamsize
sgetn(char_type* __s, streamsize __n)
;
int_type
sputbackc(char_type __c)
;
int_type
sungetc()
;
int_type
sputc(char_type __c)
;
streamsize
sputn(const char_type* __s, streamsize __n)
;
protected:
basic_streambuf()
;
char_type*
eback() const ;
char_type*
gptr() const ;
char_type*
egptr() const ;
void
gbump(int __n) ;
void
setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
;
char_type*
pbase() const ;
char_type*
pptr() const ;
char_type*
epptr() const ;
void
pbump(int __n) ;
void
setp(char_type* __pbeg, char_type* __pend)
;
virtual void
imbue(const locale& __loc)
;
virtual basic_streambuf<char_type,_Traits>*
setbuf(char_type*, streamsize)
;
virtual pos_type
seekoff(off_type, ios_base::seekdir,
ios_base::openmode = ios_base::in | ios_base::out)
;
virtual pos_type
seekpos(pos_type,
ios_base::openmode = ios_base::in | ios_base::out)
;
virtual int
sync() ;
virtual streamsize
showmanyc() ;
virtual streamsize
xsgetn(char_type* __s, streamsize __n);
virtual int_type
underflow()
;
virtual int_type
uflow()
;
virtual int_type
pbackfail(int_type __c = traits_type::eof())
;
virtual streamsize
xsputn(const char_type* __s, streamsize __n);
virtual int_type
overflow(int_type __c = traits_type::eof())
;
public:
void
stossc()
;
void
__safe_gbump(streamsize __n) ;
void
__safe_pbump(streamsize __n) ;
protected:
basic_streambuf(const basic_streambuf&);
basic_streambuf&
operator=(const basic_streambuf&);
void
swap(basic_streambuf& __sb)
;
};
template<typename _CharT, typename _Traits>
std::basic_streambuf<_CharT, _Traits>::
basic_streambuf(const basic_streambuf&) = default;
template<typename _CharT, typename _Traits>
std::basic_streambuf<_CharT, _Traits>&
std::basic_streambuf<_CharT, _Traits>::
operator=(const basic_streambuf&) = default;
template<>
streamsize
__copy_streambufs_eof(basic_streambuf<char>* __sbin,
basic_streambuf<char>* __sbout, bool& __ineof);
template<>
streamsize
__copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
basic_streambuf<wchar_t>* __sbout, bool& __ineof);
}
#define _STREAMBUF_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
streamsize
__copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
basic_streambuf<_CharT, _Traits>* __sbout,
bool& __ineof)
;
template<typename _CharT, typename _Traits>
streamsize
__copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
basic_streambuf<_CharT, _Traits>* __sbout)
;
extern template class basic_streambuf<char>;
extern template
streamsize
__copy_streambufs(basic_streambuf<char>*,
basic_streambuf<char>*);
extern template
streamsize
__copy_streambufs_eof(basic_streambuf<char>*,
basic_streambuf<char>*, bool&);
extern template class basic_streambuf<wchar_t>;
extern template
streamsize
__copy_streambufs(basic_streambuf<wchar_t>*,
basic_streambuf<wchar_t>*);
extern template
streamsize
__copy_streambufs_eof(basic_streambuf<wchar_t>*,
basic_streambuf<wchar_t>*, bool&);
}
#define _BASIC_IOS_H 1
#define _LOCALE_FACETS_H 1
#define _WCTYPE_H 1
#define __need_wint_t
#undef __need_mbstate_t
#undef __need_wint_t
#undef __need_iswxxx
#define __iswxxx_defined 1
typedef unsigned long int wctype_t;
#define _ISwbit(bit) ((bit) < 8 ? (int) ((1UL << (bit)) << 24) : ((bit) < 16 ? (int) ((1UL << (bit)) << 8) : ((bit) < 24 ? (int) ((1UL << (bit)) >> 8) : (int) ((1UL << (bit)) >> 24))))
enum
{
__ISwupper = 0,
__ISwlower = 1,
__ISwalpha = 2,
__ISwdigit = 3,
__ISwxdigit = 4,
__ISwspace = 5,
__ISwprint = 6,
__ISwgraph = 7,
__ISwblank = 8,
__ISwcntrl = 9,
__ISwpunct = 10,
__ISwalnum = 11,
_ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))),
_ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))),
_ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))),
_ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))),
_ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))),
_ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))),
_ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))),
_ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))),
_ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))),
_ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))),
_ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))),
_ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24))))
};
extern "C" {
extern int iswalnum (wint_t __wc) throw ();
extern int iswalpha (wint_t __wc) throw ();
extern int iswcntrl (wint_t __wc) throw ();
extern int iswdigit (wint_t __wc) throw ();
extern int iswgraph (wint_t __wc) throw ();
extern int iswlower (wint_t __wc) throw ();
extern int iswprint (wint_t __wc) throw ();
extern int iswpunct (wint_t __wc) throw ();
extern int iswspace (wint_t __wc) throw ();
extern int iswupper (wint_t __wc) throw ();
extern int iswxdigit (wint_t __wc) throw ();
extern int iswblank (wint_t __wc) throw ();
extern wctype_t wctype (const char *__property) throw ();
extern int iswctype (wint_t __wc, wctype_t __desc) throw ();
typedef const __int32_t *wctrans_t;
extern wint_t towlower (wint_t __wc) throw ();
extern wint_t towupper (wint_t __wc) throw ();
}
extern "C" {
extern wctrans_t wctrans (const char *__property) throw ();
extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();
extern int iswalnum_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswalpha_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswcntrl_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswdigit_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswgraph_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswlower_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswprint_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswpunct_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswspace_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswupper_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswxdigit_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswblank_l (wint_t __wc, __locale_t __locale) throw ();
extern wctype_t wctype_l (const char *__property, __locale_t __locale)
throw ();
extern int iswctype_l (wint_t __wc, wctype_t __desc, __locale_t __locale)
throw ();
extern wint_t towlower_l (wint_t __wc, __locale_t __locale) throw ();
extern wint_t towupper_l (wint_t __wc, __locale_t __locale) throw ();
extern wctrans_t wctrans_l (const char *__property, __locale_t __locale)
throw ();
extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
__locale_t __locale) throw ();
}
#define _GLIBCXX_CWCTYPE 1
#undef iswalnum
#undef iswalpha
#undef iswblank
#undef iswcntrl
#undef iswctype
#undef iswdigit
#undef iswgraph
#undef iswlower
#undef iswprint
#undef iswpunct
#undef iswspace
#undef iswupper
#undef iswxdigit
#undef towctrans
#undef towlower
#undef towupper
#undef wctrans
#undef wctype
namespace std
{
using ::wctrans_t;
using ::wctype_t;
using ::wint_t;
using ::iswalnum;
using ::iswalpha;
using ::iswblank;
using ::iswcntrl;
using ::iswctype;
using ::iswdigit;
using ::iswgraph;
using ::iswlower;
using ::iswprint;
using ::iswpunct;
using ::iswspace;
using ::iswupper;
using ::iswxdigit;
using ::towctrans;
using ::towlower;
using ::towupper;
using ::wctrans;
using ::wctype;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
struct ctype_base
{
typedef const int* __to_type;
typedef unsigned short mask;
static const mask upper = _ISupper;
static const mask lower = _ISlower;
static const mask alpha = _ISalpha;
static const mask digit = _ISdigit;
static const mask xdigit = _ISxdigit;
static const mask space = _ISspace;
static const mask print = _ISprint;
static const mask graph = _ISalpha | _ISdigit | _ISpunct;
static const mask cntrl = _IScntrl;
static const mask punct = _ISpunct;
static const mask alnum = _ISalpha | _ISdigit;
};
}
#define _STREAMBUF_ITERATOR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
class istreambuf_iterator
: public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
_CharT*,
_CharT>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef typename _Traits::int_type int_type;
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
typedef basic_istream<_CharT, _Traits> istream_type;
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
ostreambuf_iterator<_CharT2> >::__type
copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
ostreambuf_iterator<_CharT2>);
template<bool _IsMove, typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
_CharT2*>::__type
__copy_move_a2(istreambuf_iterator<_CharT2>,
istreambuf_iterator<_CharT2>, _CharT2*);
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
istreambuf_iterator<_CharT2> >::__type
find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
const _CharT2&);
private:
mutable streambuf_type* _M_sbuf;
mutable int_type _M_c;
public:
constexpr istreambuf_iterator() noexcept
: _M_sbuf(0), _M_c(traits_type::eof()) { }
istreambuf_iterator(const istreambuf_iterator&) noexcept = default;
~istreambuf_iterator() = default;
istreambuf_iterator(istream_type& __s) noexcept
: _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
istreambuf_iterator(streambuf_type* __s) noexcept
: _M_sbuf(__s), _M_c(traits_type::eof()) { }
char_type
operator*() const
{
return traits_type::to_char_type(_M_get());
}
istreambuf_iterator&
operator++()
{
;
if (_M_sbuf)
{
_M_sbuf->sbumpc();
_M_c = traits_type::eof();
}
return *this;
}
istreambuf_iterator
operator++(int)
{
;
istreambuf_iterator __old = *this;
if (_M_sbuf)
{
__old._M_c = _M_sbuf->sbumpc();
_M_c = traits_type::eof();
}
return __old;
}
bool
equal(const istreambuf_iterator& __b) const
{ return _M_at_eof() == __b._M_at_eof(); }
private:
int_type
_M_get() const
{
const int_type __eof = traits_type::eof();
int_type __ret = __eof;
if (_M_sbuf)
{
if (!traits_type::eq_int_type(_M_c, __eof))
__ret = _M_c;
else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()),
__eof))
_M_c = __ret;
else
_M_sbuf = 0;
}
return __ret;
}
bool
_M_at_eof() const
{
const int_type __eof = traits_type::eof();
return traits_type::eq_int_type(_M_get(), __eof);
}
};
template<typename _CharT, typename _Traits>
bool
operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
const istreambuf_iterator<_CharT, _Traits>& __b)
;
template<typename _CharT, typename _Traits>
bool
operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
const istreambuf_iterator<_CharT, _Traits>& __b)
;
template<typename _CharT, typename _Traits>
class ostreambuf_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
typedef basic_ostream<_CharT, _Traits> ostream_type;
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
ostreambuf_iterator<_CharT2> >::__type
copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
ostreambuf_iterator<_CharT2>);
private:
streambuf_type* _M_sbuf;
bool _M_failed;
public:
ostreambuf_iterator(ostream_type& __s) noexcept
: _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
ostreambuf_iterator(streambuf_type* __s) noexcept
: _M_sbuf(__s), _M_failed(!_M_sbuf) { }
ostreambuf_iterator&
operator=(_CharT __c)
{
if (!_M_failed &&
_Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
_M_failed = true;
return *this;
}
ostreambuf_iterator&
operator*()
{ return *this; }
ostreambuf_iterator&
operator++(int)
{ return *this; }
ostreambuf_iterator&
operator++()
{ return *this; }
bool
failed() const noexcept
{ return _M_failed; }
ostreambuf_iterator&
_M_put(const _CharT* __ws, streamsize __len)
{
if (__builtin_expect(!_M_failed, true)
&& __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
false))
_M_failed = true;
return *this;
}
};
template<typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
copy(istreambuf_iterator<_CharT> __first,
istreambuf_iterator<_CharT> __last,
ostreambuf_iterator<_CharT> __result)
;
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
__copy_move_a2(_CharT* __first, _CharT* __last,
ostreambuf_iterator<_CharT> __result)
;
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
__copy_move_a2(const _CharT* __first, const _CharT* __last,
ostreambuf_iterator<_CharT> __result)
;
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
_CharT*>::__type
__copy_move_a2(istreambuf_iterator<_CharT> __first,
istreambuf_iterator<_CharT> __last, _CharT* __result)
;
template<typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
istreambuf_iterator<_CharT> >::__type
find(istreambuf_iterator<_CharT> __first,
istreambuf_iterator<_CharT> __last, const _CharT& __val)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
#define _GLIBCXX_NUM_FACETS 28
template<typename _Tp>
void
__convert_to_v(const char*, _Tp&, ios_base::iostate&,
const __c_locale&) throw();
template<>
void
__convert_to_v(const char*, float&, ios_base::iostate&,
const __c_locale&) throw();
template<>
void
__convert_to_v(const char*, double&, ios_base::iostate&,
const __c_locale&) throw();
template<>
void
__convert_to_v(const char*, long double&, ios_base::iostate&,
const __c_locale&) throw();
template<typename _CharT, typename _Traits>
struct __pad
{
static void
_S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
};
template<typename _CharT>
_CharT*
__add_grouping(_CharT* __s, _CharT __sep,
const char* __gbeg, size_t __gsize,
const _CharT* __first, const _CharT* __last);
template<typename _CharT>
ostreambuf_iterator<_CharT>
__write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
;
template<typename _CharT, typename _OutIter>
_OutIter
__write(_OutIter __s, const _CharT* __ws, int __len)
;
template<typename _CharT>
class __ctype_abstract_base : public locale::facet, public ctype_base
{
public:
typedef _CharT char_type;
bool
is(mask __m, char_type __c) const
;
const char_type*
is(const char_type *__lo, const char_type *__hi, mask *__vec) const
;
const char_type*
scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
;
const char_type*
scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
;
char_type
toupper(char_type __c) const
;
const char_type*
toupper(char_type *__lo, const char_type* __hi) const
;
char_type
tolower(char_type __c) const
;
const char_type*
tolower(char_type* __lo, const char_type* __hi) const
;
char_type
widen(char __c) const
;
const char*
widen(const char* __lo, const char* __hi, char_type* __to) const
;
char
narrow(char_type __c, char __dfault) const
;
const char_type*
narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const
;
protected:
explicit
__ctype_abstract_base(size_t __refs = 0) ;
virtual
~__ctype_abstract_base() ;
virtual bool
do_is(mask __m, char_type __c) const = 0;
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi,
mask* __vec) const = 0;
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo,
const char_type* __hi) const = 0;
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const = 0;
virtual char_type
do_toupper(char_type __c) const = 0;
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const = 0;
virtual char_type
do_tolower(char_type __c) const = 0;
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const = 0;
virtual char_type
do_widen(char __c) const = 0;
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
virtual char
do_narrow(char_type __c, char __dfault) const = 0;
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const = 0;
};
template<typename _CharT>
class ctype : public __ctype_abstract_base<_CharT>
{
public:
typedef _CharT char_type;
typedef typename __ctype_abstract_base<_CharT>::mask mask;
static locale::id id;
explicit
ctype(size_t __refs = 0) ;
protected:
virtual
~ctype();
virtual bool
do_is(mask __m, char_type __c) const;
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const;
virtual char_type
do_toupper(char_type __c) const;
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
virtual char_type
do_tolower(char_type __c) const;
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
virtual char_type
do_widen(char __c) const;
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
virtual char
do_narrow(char_type, char __dfault) const;
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const;
};
template<typename _CharT>
locale::id ctype<_CharT>::id;
template<>
class ctype<char> : public locale::facet, public ctype_base
{
public:
typedef char char_type;
protected:
__c_locale _M_c_locale_ctype;
bool _M_del;
__to_type _M_toupper;
__to_type _M_tolower;
const mask* _M_table;
mutable char _M_widen_ok;
mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
mutable char _M_narrow_ok;
public:
static locale::id id;
static const size_t table_size = 1 + static_cast<unsigned char>(-1);
explicit
ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
explicit
ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
size_t __refs = 0);
inline bool
is(mask __m, char __c) const;
inline const char*
is(const char* __lo, const char* __hi, mask* __vec) const;
inline const char*
scan_is(mask __m, const char* __lo, const char* __hi) const;
inline const char*
scan_not(mask __m, const char* __lo, const char* __hi) const;
char_type
toupper(char_type __c) const
;
const char_type*
toupper(char_type *__lo, const char_type* __hi) const
;
char_type
tolower(char_type __c) const
;
const char_type*
tolower(char_type* __lo, const char_type* __hi) const
;
char_type
widen(char __c) const
;
const char*
widen(const char* __lo, const char* __hi, char_type* __to) const
;
char
narrow(char_type __c, char __dfault) const
;
const char_type*
narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const
;
const mask*
table() const throw()
;
static const mask*
classic_table() throw();
protected:
virtual
~ctype();
virtual char_type
do_toupper(char_type __c) const;
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
virtual char_type
do_tolower(char_type __c) const;
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
virtual char_type
do_widen(char __c) const
;
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __to) const
;
virtual char
do_narrow(char_type __c, char __dfault) const
;
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const
;
private:
void _M_narrow_init() const;
void _M_widen_init() const;
};
template<>
class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
{
public:
typedef wchar_t char_type;
typedef wctype_t __wmask_type;
protected:
__c_locale _M_c_locale_ctype;
bool _M_narrow_ok;
char _M_narrow[128];
wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
mask _M_bit[16];
__wmask_type _M_wmask[16];
public:
static locale::id id;
explicit
ctype(size_t __refs = 0);
explicit
ctype(__c_locale __cloc, size_t __refs = 0);
protected:
__wmask_type
_M_convert_to_wmask(const mask __m) const throw();
virtual
~ctype();
virtual bool
do_is(mask __m, char_type __c) const;
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const;
virtual char_type
do_toupper(char_type __c) const;
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
virtual char_type
do_tolower(char_type __c) const;
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
virtual char_type
do_widen(char __c) const;
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __to) const;
virtual char
do_narrow(char_type __c, char __dfault) const;
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const;
void
_M_initialize_ctype() throw();
};
template<typename _CharT>
class ctype_byname : public ctype<_CharT>
{
public:
typedef typename ctype<_CharT>::mask mask;
explicit
ctype_byname(const char* __s, size_t __refs = 0);
protected:
virtual
~ctype_byname() ;;
};
template<>
class ctype_byname<char> : public ctype<char>
{
public:
explicit
ctype_byname(const char* __s, size_t __refs = 0);
protected:
virtual
~ctype_byname();
};
template<>
class ctype_byname<wchar_t> : public ctype<wchar_t>
{
public:
explicit
ctype_byname(const char* __s, size_t __refs = 0);
protected:
virtual
~ctype_byname();
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
}
namespace std __attribute__ ((__visibility__ ("default")))
{
class __num_base
{
public:
enum
{
_S_ominus,
_S_oplus,
_S_ox,
_S_oX,
_S_odigits,
_S_odigits_end = _S_odigits + 16,
_S_oudigits = _S_odigits_end,
_S_oudigits_end = _S_oudigits + 16,
_S_oe = _S_odigits + 14,
_S_oE = _S_oudigits + 14,
_S_oend = _S_oudigits_end
};
static const char* _S_atoms_out;
static const char* _S_atoms_in;
enum
{
_S_iminus,
_S_iplus,
_S_ix,
_S_iX,
_S_izero,
_S_ie = _S_izero + 14,
_S_iE = _S_izero + 20,
_S_iend = 26
};
static void
_S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
};
template<typename _CharT>
struct __numpunct_cache : public locale::facet
{
const char* _M_grouping;
size_t _M_grouping_size;
bool _M_use_grouping;
const _CharT* _M_truename;
size_t _M_truename_size;
const _CharT* _M_falsename;
size_t _M_falsename_size;
_CharT _M_decimal_point;
_CharT _M_thousands_sep;
_CharT _M_atoms_out[__num_base::_S_oend];
_CharT _M_atoms_in[__num_base::_S_iend];
bool _M_allocated;
__numpunct_cache(size_t __refs = 0)
;
~__numpunct_cache();
void
_M_cache(const locale& __loc);
private:
__numpunct_cache&
operator=(const __numpunct_cache&);
explicit
__numpunct_cache(const __numpunct_cache&);
};
template<typename _CharT>
class numpunct : public locale::facet
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
typedef __numpunct_cache<_CharT> __cache_type;
protected:
__cache_type* _M_data;
public:
static locale::id id;
explicit
numpunct(size_t __refs = 0)
;
explicit
numpunct(__cache_type* __cache, size_t __refs = 0)
;
explicit
numpunct(__c_locale __cloc, size_t __refs = 0)
;
char_type
decimal_point() const
;
char_type
thousands_sep() const
;
string
grouping() const
;
string_type
truename() const
;
string_type
falsename() const
;
protected:
virtual
~numpunct();
virtual char_type
do_decimal_point() const
;
virtual char_type
do_thousands_sep() const
;
virtual string
do_grouping() const
;
virtual string_type
do_truename() const
;
virtual string_type
do_falsename() const
;
void
_M_initialize_numpunct(__c_locale __cloc = 0);
};
template<typename _CharT>
locale::id numpunct<_CharT>::id;
template<>
numpunct<char>::~numpunct();
template<>
void
numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
template<>
numpunct<wchar_t>::~numpunct();
template<>
void
numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
template<typename _CharT>
class numpunct_byname : public numpunct<_CharT>
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
explicit
numpunct_byname(const char* __s, size_t __refs = 0)
;
protected:
virtual
~numpunct_byname() ;
};
template<typename _CharT, typename _InIter>
class num_get : public locale::facet
{
public:
typedef _CharT char_type;
typedef _InIter iter_type;
static locale::id id;
explicit
num_get(size_t __refs = 0) ;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, bool& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned short& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned int& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long long& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long long& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, float& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, double& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long double& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, void*& __v) const
;
protected:
virtual ~num_get() ;
iter_type
_M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
string&) const;
template<typename _ValueT>
iter_type
_M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
_ValueT&) const;
template<typename _CharT2>
typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
_M_find(const _CharT2*, size_t __len, _CharT2 __c) const
;
template<typename _CharT2>
typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
int>::__type
_M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
;
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long& __v) const
;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned short& __v) const
;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned int& __v) const
;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long& __v) const
;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long long& __v) const
;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long long& __v) const
;
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
double&) const;
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
long double&) const;
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
};
template<typename _CharT, typename _InIter>
locale::id num_get<_CharT, _InIter>::id;
template<typename _CharT, typename _OutIter>
class num_put : public locale::facet
{
public:
typedef _CharT char_type;
typedef _OutIter iter_type;
static locale::id id;
explicit
num_put(size_t __refs = 0) ;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long long __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
long double __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
const void* __v) const
;
protected:
template<typename _ValueT>
iter_type
_M_insert_float(iter_type, ios_base& __io, char_type __fill,
char __mod, _ValueT __v) const;
void
_M_group_float(const char* __grouping, size_t __grouping_size,
char_type __sep, const char_type* __p, char_type* __new,
char_type* __cs, int& __len) const;
template<typename _ValueT>
iter_type
_M_insert_int(iter_type, ios_base& __io, char_type __fill,
_ValueT __v) const;
void
_M_group_int(const char* __grouping, size_t __grouping_size,
char_type __sep, ios_base& __io, char_type* __new,
char_type* __cs, int& __len) const;
void
_M_pad(char_type __fill, streamsize __w, ios_base& __io,
char_type* __new, const char_type* __cs, int& __len) const;
virtual
~num_put() ;;
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const;
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
;
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long __v) const
;
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
long long __v) const
;
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long long __v) const
;
virtual iter_type
do_put(iter_type, ios_base&, char_type, double) const;
virtual iter_type
do_put(iter_type, ios_base&, char_type, long double) const;
virtual iter_type
do_put(iter_type, ios_base&, char_type, const void*) const;
};
template <typename _CharT, typename _OutIter>
locale::id num_put<_CharT, _OutIter>::id;
template<typename _CharT>
bool
isspace(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isprint(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
iscntrl(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isupper(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
islower(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isalpha(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isdigit(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
ispunct(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isxdigit(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isalnum(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isgraph(_CharT __c, const locale& __loc)
;
template<typename _CharT>
_CharT
toupper(_CharT __c, const locale& __loc)
;
template<typename _CharT>
_CharT
tolower(_CharT __c, const locale& __loc)
;
}
#define _LOCALE_FACETS_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Facet>
struct __use_cache
{
const _Facet*
operator() (const locale& __loc) const;
};
template<typename _CharT>
struct __use_cache<__numpunct_cache<_CharT> >
{
const __numpunct_cache<_CharT>*
operator() (const locale& __loc) const
;
};
__attribute__ ((__pure__)) bool
__verify_grouping(const char* __grouping, size_t __grouping_size,
const string& __grouping_tmp) throw ();
template<typename _CharT, typename _ValueT>
int
__int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
ios_base::fmtflags __flags, bool __dec)
;
template<typename _CharT>
_CharT*
__add_grouping(_CharT* __s, _CharT __sep,
const char* __gbeg, size_t __gsize,
const _CharT* __first, const _CharT* __last)
;
extern template class numpunct<char>;
extern template class numpunct_byname<char>;
extern template class num_get<char>;
extern template class num_put<char>;
extern template class ctype_byname<char>;
extern template
const ctype<char>&
use_facet<ctype<char> >(const locale&);
extern template
const numpunct<char>&
use_facet<numpunct<char> >(const locale&);
extern template
const num_put<char>&
use_facet<num_put<char> >(const locale&);
extern template
const num_get<char>&
use_facet<num_get<char> >(const locale&);
extern template
bool
has_facet<ctype<char> >(const locale&);
extern template
bool
has_facet<numpunct<char> >(const locale&);
extern template
bool
has_facet<num_put<char> >(const locale&);
extern template
bool
has_facet<num_get<char> >(const locale&);
extern template class numpunct<wchar_t>;
extern template class numpunct_byname<wchar_t>;
extern template class num_get<wchar_t>;
extern template class num_put<wchar_t>;
extern template class ctype_byname<wchar_t>;
extern template
const ctype<wchar_t>&
use_facet<ctype<wchar_t> >(const locale&);
extern template
const numpunct<wchar_t>&
use_facet<numpunct<wchar_t> >(const locale&);
extern template
const num_put<wchar_t>&
use_facet<num_put<wchar_t> >(const locale&);
extern template
const num_get<wchar_t>&
use_facet<num_get<wchar_t> >(const locale&);
extern template
bool
has_facet<ctype<wchar_t> >(const locale&);
extern template
bool
has_facet<numpunct<wchar_t> >(const locale&);
extern template
bool
has_facet<num_put<wchar_t> >(const locale&);
extern template
bool
has_facet<num_get<wchar_t> >(const locale&);
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Facet>
const _Facet&
__check_facet(const _Facet* __f)
;
template<typename _CharT, typename _Traits>
class basic_ios : public ios_base
{
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef ctype<_CharT> __ctype_type;
typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
__num_put_type;
typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
__num_get_type;
protected:
basic_ostream<_CharT, _Traits>* _M_tie;
mutable char_type _M_fill;
mutable bool _M_fill_init;
basic_streambuf<_CharT, _Traits>* _M_streambuf;
const __ctype_type* _M_ctype;
const __num_put_type* _M_num_put;
const __num_get_type* _M_num_get;
public:
explicit operator bool() const
;
bool
operator!() const
;
iostate
rdstate() const
;
void
clear(iostate __state = goodbit);
void
setstate(iostate __state)
;
void
_M_setstate(iostate __state)
;
bool
good() const
;
bool
eof() const
;
bool
fail() const
;
bool
bad() const
;
iostate
exceptions() const
;
void
exceptions(iostate __except)
;
explicit
basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
;
virtual
~basic_ios() ;
basic_ostream<_CharT, _Traits>*
tie() const
;
basic_ostream<_CharT, _Traits>*
tie(basic_ostream<_CharT, _Traits>* __tiestr)
;
basic_streambuf<_CharT, _Traits>*
rdbuf() const
;
basic_streambuf<_CharT, _Traits>*
rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
basic_ios&
copyfmt(const basic_ios& __rhs);
char_type
fill() const
;
char_type
fill(char_type __ch)
;
locale
imbue(const locale& __loc);
char
narrow(char_type __c, char __dfault) const
;
char_type
widen(char __c) const
;
protected:
basic_ios()
;
void
init(basic_streambuf<_CharT, _Traits>* __sb);
basic_ios(const basic_ios&) = delete;
basic_ios& operator=(const basic_ios&) = delete;
void
move(basic_ios& __rhs)
;
void
move(basic_ios&& __rhs)
;
void
swap(basic_ios& __rhs) noexcept
{
ios_base::_M_swap(__rhs);
_M_cache_locale(_M_ios_locale);
__rhs._M_cache_locale(__rhs._M_ios_locale);
std::swap(_M_tie, __rhs._M_tie);
std::swap(_M_fill, __rhs._M_fill);
std::swap(_M_fill_init, __rhs._M_fill_init);
}
void
set_rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
{ _M_streambuf = __sb; }
void
_M_cache_locale(const locale& __loc);
};
}
#define _BASIC_IOS_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
extern template class basic_ios<char>;
extern template class basic_ios<wchar_t>;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
class basic_ostream : virtual public basic_ios<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_ios<_CharT, _Traits> __ios_type;
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
__num_put_type;
typedef ctype<_CharT> __ctype_type;
explicit
basic_ostream(__streambuf_type* __sb)
;
virtual
~basic_ostream() ;
class sentry;
friend class sentry;
__ostream_type&
operator<<(__ostream_type& (*__pf)(__ostream_type&))
;
__ostream_type&
operator<<(__ios_type& (*__pf)(__ios_type&))
;
__ostream_type&
operator<<(ios_base& (*__pf) (ios_base&))
;
__ostream_type&
operator<<(long __n)
;
__ostream_type&
operator<<(unsigned long __n)
;
__ostream_type&
operator<<(bool __n)
;
__ostream_type&
operator<<(short __n);
__ostream_type&
operator<<(unsigned short __n)
;
__ostream_type&
operator<<(int __n);
__ostream_type&
operator<<(unsigned int __n)
;
__ostream_type&
operator<<(long long __n)
;
__ostream_type&
operator<<(unsigned long long __n)
;
__ostream_type&
operator<<(double __f)
;
__ostream_type&
operator<<(float __f)
;
__ostream_type&
operator<<(long double __f)
;
__ostream_type&
operator<<(const void* __p)
;
__ostream_type&
operator<<(__streambuf_type* __sb);
__ostream_type&
put(char_type __c);
void
_M_write(const char_type* __s, streamsize __n)
;
__ostream_type&
write(const char_type* __s, streamsize __n);
__ostream_type&
flush();
pos_type
tellp();
__ostream_type&
seekp(pos_type);
__ostream_type&
seekp(off_type, ios_base::seekdir);
protected:
basic_ostream()
;
basic_ostream(basic_iostream<_CharT, _Traits>&) ;
basic_ostream(const basic_ostream&) = delete;
basic_ostream(basic_ostream&& __rhs)
;
basic_ostream& operator=(const basic_ostream&) = delete;
basic_ostream&
operator=(basic_ostream&& __rhs)
;
void
swap(basic_ostream& __rhs)
;
template<typename _ValueT>
__ostream_type&
_M_insert(_ValueT __v);
};
template <typename _CharT, typename _Traits>
class basic_ostream<_CharT, _Traits>::sentry
{
bool _M_ok;
basic_ostream<_CharT, _Traits>& _M_os;
public:
explicit
sentry(basic_ostream<_CharT, _Traits>& __os);
~sentry()
;
explicit
operator bool() const
;
};
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
;
template <class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, char __c)
;
template<class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
;
template<class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits> &
operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
template<class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
;
template<class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
;
template<class _Traits>
basic_ostream<char, _Traits> &
operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
endl(basic_ostream<_CharT, _Traits>& __os)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
ends(basic_ostream<_CharT, _Traits>& __os)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
flush(basic_ostream<_CharT, _Traits>& __os)
;
template<typename _CharT, typename _Traits, typename _Tp>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp& __x)
;
}
#define _OSTREAM_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
;
extern template class basic_ostream<char>;
extern template ostream& endl(ostream&);
extern template ostream& ends(ostream&);
extern template ostream& flush(ostream&);
extern template ostream& operator<<(ostream&, char);
extern template ostream& operator<<(ostream&, unsigned char);
extern template ostream& operator<<(ostream&, signed char);
extern template ostream& operator<<(ostream&, const char*);
extern template ostream& operator<<(ostream&, const unsigned char*);
extern template ostream& operator<<(ostream&, const signed char*);
extern template ostream& ostream::_M_insert(long);
extern template ostream& ostream::_M_insert(unsigned long);
extern template ostream& ostream::_M_insert(bool);
extern template ostream& ostream::_M_insert(long long);
extern template ostream& ostream::_M_insert(unsigned long long);
extern template ostream& ostream::_M_insert(double);
extern template ostream& ostream::_M_insert(long double);
extern template ostream& ostream::_M_insert(const void*);
extern template class basic_ostream<wchar_t>;
extern template wostream& endl(wostream&);
extern template wostream& ends(wostream&);
extern template wostream& flush(wostream&);
extern template wostream& operator<<(wostream&, wchar_t);
extern template wostream& operator<<(wostream&, char);
extern template wostream& operator<<(wostream&, const wchar_t*);
extern template wostream& operator<<(wostream&, const char*);
extern template wostream& wostream::_M_insert(long);
extern template wostream& wostream::_M_insert(unsigned long);
extern template wostream& wostream::_M_insert(bool);
extern template wostream& wostream::_M_insert(long long);
extern template wostream& wostream::_M_insert(unsigned long long);
extern template wostream& wostream::_M_insert(double);
extern template wostream& wostream::_M_insert(long double);
extern template wostream& wostream::_M_insert(const void*);
}
#define _GLIBCXX_ISTREAM 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
class basic_istream : virtual public basic_ios<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_ios<_CharT, _Traits> __ios_type;
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
__num_get_type;
typedef ctype<_CharT> __ctype_type;
protected:
streamsize _M_gcount;
public:
explicit
basic_istream(__streambuf_type* __sb)
;
virtual
~basic_istream()
;
class sentry;
friend class sentry;
__istream_type&
operator>>(__istream_type& (*__pf)(__istream_type&))
;
__istream_type&
operator>>(__ios_type& (*__pf)(__ios_type&))
;
__istream_type&
operator>>(ios_base& (*__pf)(ios_base&))
;
__istream_type&
operator>>(bool& __n)
;
__istream_type&
operator>>(short& __n);
__istream_type&
operator>>(unsigned short& __n)
;
__istream_type&
operator>>(int& __n);
__istream_type&
operator>>(unsigned int& __n)
;
__istream_type&
operator>>(long& __n)
;
__istream_type&
operator>>(unsigned long& __n)
;
__istream_type&
operator>>(long long& __n)
;
__istream_type&
operator>>(unsigned long long& __n)
;
__istream_type&
operator>>(float& __f)
;
__istream_type&
operator>>(double& __f)
;
__istream_type&
operator>>(long double& __f)
;
__istream_type&
operator>>(void*& __p)
;
__istream_type&
operator>>(__streambuf_type* __sb);
streamsize
gcount() const
;
int_type
get();
__istream_type&
get(char_type& __c);
__istream_type&
get(char_type* __s, streamsize __n, char_type __delim);
__istream_type&
get(char_type* __s, streamsize __n)
;
__istream_type&
get(__streambuf_type& __sb, char_type __delim);
__istream_type&
get(__streambuf_type& __sb)
;
__istream_type&
getline(char_type* __s, streamsize __n, char_type __delim);
__istream_type&
getline(char_type* __s, streamsize __n)
;
__istream_type&
ignore(streamsize __n, int_type __delim);
__istream_type&
ignore(streamsize __n);
__istream_type&
ignore();
int_type
peek();
__istream_type&
read(char_type* __s, streamsize __n);
streamsize
readsome(char_type* __s, streamsize __n);
__istream_type&
putback(char_type __c);
__istream_type&
unget();
int
sync();
pos_type
tellg();
__istream_type&
seekg(pos_type);
__istream_type&
seekg(off_type, ios_base::seekdir);
protected:
basic_istream()
;
basic_istream(const basic_istream&) = delete;
basic_istream(basic_istream&& __rhs)
;
basic_istream& operator=(const basic_istream&) = delete;
basic_istream&
operator=(basic_istream&& __rhs)
;
void
swap(basic_istream& __rhs)
;
template<typename _ValueT>
__istream_type&
_M_extract(_ValueT& __v);
};
template<>
basic_istream<char>&
basic_istream<char>::
getline(char_type* __s, streamsize __n, char_type __delim);
template<>
basic_istream<char>&
basic_istream<char>::
ignore(streamsize __n);
template<>
basic_istream<char>&
basic_istream<char>::
ignore(streamsize __n, int_type __delim);
template<>
basic_istream<wchar_t>&
basic_istream<wchar_t>::
getline(char_type* __s, streamsize __n, char_type __delim);
template<>
basic_istream<wchar_t>&
basic_istream<wchar_t>::
ignore(streamsize __n);
template<>
basic_istream<wchar_t>&
basic_istream<wchar_t>::
ignore(streamsize __n, int_type __delim);
template<typename _CharT, typename _Traits>
class basic_istream<_CharT, _Traits>::sentry
{
bool _M_ok;
public:
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef typename __istream_type::__ctype_type __ctype_type;
typedef typename _Traits::int_type __int_type;
explicit
sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
explicit
operator bool() const
;
};
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
template<class _Traits>
basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
;
template<class _Traits>
basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
;
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
template<>
basic_istream<char>&
operator>>(basic_istream<char>& __in, char* __s);
template<class _Traits>
basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
;
template<class _Traits>
basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
;
template<typename _CharT, typename _Traits>
class basic_iostream
: public basic_istream<_CharT, _Traits>,
public basic_ostream<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_ostream<_CharT, _Traits> __ostream_type;
explicit
basic_iostream(basic_streambuf<_CharT, _Traits>* __sb) ;
virtual
~basic_iostream() ;
protected:
basic_iostream() ;
basic_iostream(const basic_iostream&) = delete;
basic_iostream(basic_iostream&& __rhs)
;
basic_iostream& operator=(const basic_iostream&) = delete;
basic_iostream&
operator=(basic_iostream&& __rhs)
;
void
swap(basic_iostream& __rhs)
;
};
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
ws(basic_istream<_CharT, _Traits>& __is);
template<typename _CharT, typename _Traits, typename _Tp>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x)
;
}
#define _ISTREAM_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
;
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
;
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
ws(basic_istream<_CharT, _Traits>& __in)
;
extern template class basic_istream<char>;
extern template istream& ws(istream&);
extern template istream& operator>>(istream&, char&);
extern template istream& operator>>(istream&, char*);
extern template istream& operator>>(istream&, unsigned char&);
extern template istream& operator>>(istream&, signed char&);
extern template istream& operator>>(istream&, unsigned char*);
extern template istream& operator>>(istream&, signed char*);
extern template istream& istream::_M_extract(unsigned short&);
extern template istream& istream::_M_extract(unsigned int&);
extern template istream& istream::_M_extract(long&);
extern template istream& istream::_M_extract(unsigned long&);
extern template istream& istream::_M_extract(bool&);
extern template istream& istream::_M_extract(long long&);
extern template istream& istream::_M_extract(unsigned long long&);
extern template istream& istream::_M_extract(float&);
extern template istream& istream::_M_extract(double&);
extern template istream& istream::_M_extract(long double&);
extern template istream& istream::_M_extract(void*&);
extern template class basic_iostream<char>;
extern template class basic_istream<wchar_t>;
extern template wistream& ws(wistream&);
extern template wistream& operator>>(wistream&, wchar_t&);
extern template wistream& operator>>(wistream&, wchar_t*);
extern template wistream& wistream::_M_extract(unsigned short&);
extern template wistream& wistream::_M_extract(unsigned int&);
extern template wistream& wistream::_M_extract(long&);
extern template wistream& wistream::_M_extract(unsigned long&);
extern template wistream& wistream::_M_extract(bool&);
extern template wistream& wistream::_M_extract(long long&);
extern template wistream& wistream::_M_extract(unsigned long long&);
extern template wistream& wistream::_M_extract(float&);
extern template wistream& wistream::_M_extract(double&);
extern template wistream& wistream::_M_extract(long double&);
extern template wistream& wistream::_M_extract(void*&);
extern template class basic_iostream<wchar_t>;
}
#define _STREAM_ITERATOR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp, typename _CharT = char,
typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
class istream_iterator
: public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef basic_istream<_CharT, _Traits> istream_type;
private:
istream_type* _M_stream;
_Tp _M_value;
bool _M_ok;
public:
constexpr istream_iterator()
: _M_stream(0), _M_value(), _M_ok(false) {}
istream_iterator(istream_type& __s)
;
istream_iterator(const istream_iterator& __obj)
;
const _Tp&
operator*() const
;
const _Tp*
operator->() const ;
istream_iterator&
operator++()
;
istream_iterator
operator++(int)
;
bool
_M_equal(const istream_iterator& __x) const
;
private:
void
_M_read()
;
};
template<typename _Tp, typename _CharT, typename _Traits, typename _Dist>
bool
operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
;
template <class _Tp, class _CharT, class _Traits, class _Dist>
bool
operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
;
template<typename _Tp, typename _CharT = char,
typename _Traits = char_traits<_CharT> >
class ostream_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef basic_ostream<_CharT, _Traits> ostream_type;
private:
ostream_type* _M_stream;
const _CharT* _M_string;
public:
ostream_iterator(ostream_type& __s) ;
ostream_iterator(ostream_type& __s, const _CharT* __c) ;
ostream_iterator(const ostream_iterator& __obj) ;
ostream_iterator&
operator=(const _Tp& __value)
;
ostream_iterator&
operator*()
;
ostream_iterator&
operator++()
;
ostream_iterator&
operator++(int)
;
};
}
namespace boost
{
namespace detail {
template <class Category, class T, class Distance, class Pointer, class Reference>
struct iterator_base : std::iterator<Category, T, Distance, Pointer, Reference> {};
}
template <class Category, class T, class Distance = std::ptrdiff_t,
class Pointer = T*, class Reference = T&>
struct iterator : boost::detail::iterator_base<Category, T, Distance, Pointer, Reference> {};
}
#define WORKAROUND_DWA2002126_HPP
#define __BORLANDC___WORKAROUND_GUARD 1
#define __CODEGEARC___WORKAROUND_GUARD 1
#define _MSC_VER_WORKAROUND_GUARD 1
#define _MSC_FULL_VER_WORKAROUND_GUARD 1
#define BOOST_MSVC_WORKAROUND_GUARD 1
#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 1
#define __GNUC___WORKAROUND_GUARD 0
#define __GNUC_MINOR___WORKAROUND_GUARD 0
#define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 0
#define __IBMCPP___WORKAROUND_GUARD 1
#define __SUNPRO_CC_WORKAROUND_GUARD 1
#define __DECCXX_VER_WORKAROUND_GUARD 1
#define __MWERKS___WORKAROUND_GUARD 1
#define __EDG___WORKAROUND_GUARD 1
#define __EDG_VERSION___WORKAROUND_GUARD 1
#define __HP_aCC_WORKAROUND_GUARD 1
#define __hpxstd98_WORKAROUND_GUARD 1
#define _CRAYC_WORKAROUND_GUARD 1
#define __DMC___WORKAROUND_GUARD 1
#define MPW_CPLUS_WORKAROUND_GUARD 1
#define __COMO___WORKAROUND_GUARD 1
#define __COMO_VERSION___WORKAROUND_GUARD 1
#define __INTEL_COMPILER_WORKAROUND_GUARD 1
#define __ICL_WORKAROUND_GUARD 1
#define _COMPILER_VERSION_WORKAROUND_GUARD 1
#define _RWSTD_VER_WORKAROUND_GUARD 1
#define BOOST_RWSTD_VER_WORKAROUND_GUARD 1
#define __GLIBCPP___WORKAROUND_GUARD 1
#define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 1
#define __SGI_STL_PORT_WORKAROUND_GUARD 1
#define _STLPORT_VERSION_WORKAROUND_GUARD 1
#define __LIBCOMO_VERSION___WORKAROUND_GUARD 1
#define _CPPLIB_VER_WORKAROUND_GUARD 1
#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 1
#define BOOST_INTEL_WIN_WORKAROUND_GUARD 1
#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 1
#define BOOST_INTEL_WORKAROUND_GUARD 1
#define BOOST_MPL_CFG_GCC_WORKAROUND_GUARD 0
#define BOOST_WORKAROUND(symbol,test) ((symbol ## _WORKAROUND_GUARD + 0 == 0) && (symbol != 0) && (1 % (( (symbol test) ) + 1)))
#define BOOST_TESTED_AT(value) != ((value)-(value))
namespace boost {
namespace detail {
template <typename T> class empty_base {
};
}
}
namespace boost
{
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct less_than_comparable2 : B
{
friend bool operator<=(const T& x, const U& y) ;
friend bool operator>=(const T& x, const U& y) ;
friend bool operator>(const U& x, const T& y) ;
friend bool operator<(const U& x, const T& y) ;
friend bool operator<=(const U& x, const T& y) ;
friend bool operator>=(const U& x, const T& y) ;
};
template <class T, class B = ::boost::detail::empty_base<T> >
struct less_than_comparable1 : B
{
friend bool operator>(const T& x, const T& y) ;
friend bool operator<=(const T& x, const T& y) ;
friend bool operator>=(const T& x, const T& y) ;
};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct equality_comparable2 : B
{
friend bool operator==(const U& y, const T& x) ;
friend bool operator!=(const U& y, const T& x) ;
friend bool operator!=(const T& y, const U& x) ;
};
template <class T, class B = ::boost::detail::empty_base<T> >
struct equality_comparable1 : B
{
friend bool operator!=(const T& x, const T& y) ;
};
#define BOOST_OPERATOR2_LEFT(name) name ##2 ##_ ##left
#define BOOST_BINARY_OPERATOR_COMMUTATIVE(NAME,OP) template <class T, class U, class B = ::boost::detail::empty_base<T> > struct NAME ##2 : B { friend T operator OP( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } friend T operator OP( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv OP ##= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct NAME ##1 : B { friend T operator OP( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } };
#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE(NAME,OP) template <class T, class U, class B = ::boost::detail::empty_base<T> > struct NAME ##2 : B { friend T operator OP( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct BOOST_OPERATOR2_LEFT(NAME) : B { friend T operator OP( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct NAME ##1 : B { friend T operator OP( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct multipliable2 : B { friend T operator *( const T& lhs, const U& rhs ) ; friend T operator *( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct multipliable1 : B { friend T operator *( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct addable2 : B { friend T operator +( const T& lhs, const U& rhs ) ; friend T operator +( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct addable1 : B { friend T operator +( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct subtractable2 : B { friend T operator -( const T& lhs, const U& rhs ) ; }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct subtractable2_left : B { friend T operator -( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct subtractable1 : B { friend T operator -( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct dividable2 : B { friend T operator /( const T& lhs, const U& rhs ) ; }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct dividable2_left : B { friend T operator /( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct dividable1 : B { friend T operator /( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct modable2 : B { friend T operator %( const T& lhs, const U& rhs ) ; }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct modable2_left : B { friend T operator %( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct modable1 : B { friend T operator %( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct xorable2 : B { friend T operator ^( const T& lhs, const U& rhs ) ; friend T operator ^( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct xorable1 : B { friend T operator ^( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct andable2 : B { friend T operator &( const T& lhs, const U& rhs ) ; friend T operator &( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct andable1 : B { friend T operator &( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct orable2 : B { friend T operator |( const T& lhs, const U& rhs ) ; friend T operator |( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct orable1 : B { friend T operator |( const T& lhs, const T& rhs ) ; };
#undef BOOST_BINARY_OPERATOR_COMMUTATIVE
#undef BOOST_BINARY_OPERATOR_NON_COMMUTATIVE
#undef BOOST_OPERATOR2_LEFT
template <class T, class B = ::boost::detail::empty_base<T> >
struct incrementable : B
{
friend T operator++(T& x, int)
;
private:
typedef T incrementable_type;
};
template <class T, class B = ::boost::detail::empty_base<T> >
struct decrementable : B
{
friend T operator--(T& x, int)
;
private:
typedef T decrementable_type;
};
template <class T, class P, class B = ::boost::detail::empty_base<T> >
struct dereferenceable : B
{
P operator->() const
;
};
template <class T, class I, class R, class B = ::boost::detail::empty_base<T> >
struct indexable : B
{
R operator[](I n) const
;
};
#define BOOST_BINARY_OPERATOR(NAME,OP) template <class T, class U, class B = ::boost::detail::empty_base<T> > struct NAME ##2 : B { friend T operator OP( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct NAME ##1 : B { friend T operator OP( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct left_shiftable2 : B { friend T operator <<( const T& lhs, const U& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct left_shiftable1 : B { friend T operator <<( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct right_shiftable2 : B { friend T operator >>( const T& lhs, const U& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct right_shiftable1 : B { friend T operator >>( const T& lhs, const T& rhs ) ; };
#undef BOOST_BINARY_OPERATOR
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct equivalent2 : B
{
friend bool operator==(const T& x, const U& y)
;
};
template <class T, class B = ::boost::detail::empty_base<T> >
struct equivalent1 : B
{
friend bool operator==(const T&x, const T&y)
;
};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct partially_ordered2 : B
{
friend bool operator<=(const T& x, const U& y)
;
friend bool operator>=(const T& x, const U& y)
;
friend bool operator>(const U& x, const T& y)
;
friend bool operator<(const U& x, const T& y)
;
friend bool operator<=(const U& x, const T& y)
;
friend bool operator>=(const U& x, const T& y)
;
};
template <class T, class B = ::boost::detail::empty_base<T> >
struct partially_ordered1 : B
{
friend bool operator>(const T& x, const T& y)
;
friend bool operator<=(const T& x, const T& y)
;
friend bool operator>=(const T& x, const T& y)
;
};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct totally_ordered2
: less_than_comparable2<T, U
, equality_comparable2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct totally_ordered1
: less_than_comparable1<T
, equality_comparable1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct additive2
: addable2<T, U
, subtractable2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct additive1
: addable1<T
, subtractable1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct multiplicative2
: multipliable2<T, U
, dividable2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct multiplicative1
: multipliable1<T
, dividable1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct integer_multiplicative2
: multiplicative2<T, U
, modable2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct integer_multiplicative1
: multiplicative1<T
, modable1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct arithmetic2
: additive2<T, U
, multiplicative2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct arithmetic1
: additive1<T
, multiplicative1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct integer_arithmetic2
: additive2<T, U
, integer_multiplicative2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct integer_arithmetic1
: additive1<T
, integer_multiplicative1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct bitwise2
: xorable2<T, U
, andable2<T, U
, orable2<T, U, B
> > > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct bitwise1
: xorable1<T
, andable1<T
, orable1<T, B
> > > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct unit_steppable
: incrementable<T
, decrementable<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct shiftable2
: left_shiftable2<T, U
, right_shiftable2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct shiftable1
: left_shiftable1<T
, right_shiftable1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ring_operators2
: additive2<T, U
, subtractable2_left<T, U
, multipliable2<T, U, B
> > > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct ring_operators1
: additive1<T
, multipliable1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ordered_ring_operators2
: ring_operators2<T, U
, totally_ordered2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct ordered_ring_operators1
: ring_operators1<T
, totally_ordered1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct field_operators2
: ring_operators2<T, U
, dividable2<T, U
, dividable2_left<T, U, B
> > > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct field_operators1
: ring_operators1<T
, dividable1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ordered_field_operators2
: field_operators2<T, U
, totally_ordered2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct ordered_field_operators1
: field_operators1<T
, totally_ordered1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct euclidian_ring_operators2
: ring_operators2<T, U
, dividable2<T, U
, dividable2_left<T, U
, modable2<T, U
, modable2_left<T, U, B
> > > > > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct euclidian_ring_operators1
: ring_operators1<T
, dividable1<T
, modable1<T, B
> > > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ordered_euclidian_ring_operators2
: totally_ordered2<T, U
, euclidian_ring_operators2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct ordered_euclidian_ring_operators1
: totally_ordered1<T
, euclidian_ring_operators1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct euclidean_ring_operators2
: ring_operators2<T, U
, dividable2<T, U
, dividable2_left<T, U
, modable2<T, U
, modable2_left<T, U, B
> > > > > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct euclidean_ring_operators1
: ring_operators1<T
, dividable1<T
, modable1<T, B
> > > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ordered_euclidean_ring_operators2
: totally_ordered2<T, U
, euclidean_ring_operators2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct ordered_euclidean_ring_operators1
: totally_ordered1<T
, euclidean_ring_operators1<T, B
> > {};
template <class T, class P, class B = ::boost::detail::empty_base<T> >
struct input_iteratable
: equality_comparable1<T
, incrementable<T
, dereferenceable<T, P, B
> > > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct output_iteratable
: incrementable<T, B
> {};
template <class T, class P, class B = ::boost::detail::empty_base<T> >
struct forward_iteratable
: input_iteratable<T, P, B
> {};
template <class T, class P, class B = ::boost::detail::empty_base<T> >
struct bidirectional_iteratable
: forward_iteratable<T, P
, decrementable<T, B
> > {};
template <class T, class P, class D, class R, class B = ::boost::detail::empty_base<T> >
struct random_access_iteratable
: bidirectional_iteratable<T, P
, less_than_comparable1<T
, additive2<T, D
, indexable<T, D, R, B
> > > > {};
}
#define BOOST_IMPORT_TEMPLATE4(template_name)
#define BOOST_IMPORT_TEMPLATE3(template_name)
#define BOOST_IMPORT_TEMPLATE2(template_name)
#define BOOST_IMPORT_TEMPLATE1(template_name)
namespace boost {
namespace detail {
struct true_t {};
struct false_t {};
}
template<class T> struct is_chained_base {
typedef ::boost::detail::false_t value;
};
}
#define BOOST_OPERATOR_TEMPLATE4(template_name4) BOOST_IMPORT_TEMPLATE4(template_name4) template<class T, class U, class V, class W, class B> struct is_chained_base< ::boost::template_name4<T, U, V, W, B> > { typedef ::boost::detail::true_t value; };
#define BOOST_OPERATOR_TEMPLATE3(template_name3) BOOST_IMPORT_TEMPLATE3(template_name3) template<class T, class U, class V, class B> struct is_chained_base< ::boost::template_name3<T, U, V, B> > { typedef ::boost::detail::true_t value; };
#define BOOST_OPERATOR_TEMPLATE2(template_name2) BOOST_IMPORT_TEMPLATE2(template_name2) template<class T, class U, class B> struct is_chained_base< ::boost::template_name2<T, U, B> > { typedef ::boost::detail::true_t value; };
#define BOOST_OPERATOR_TEMPLATE1(template_name1) BOOST_IMPORT_TEMPLATE1(template_name1) template<class T, class B> struct is_chained_base< ::boost::template_name1<T, B> > { typedef ::boost::detail::true_t value; };
#define BOOST_OPERATOR_TEMPLATE(template_name) template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct template_name : template_name ##2<T, U, B> {}; template<class T, class U, class B> struct template_name<T, U, B, ::boost::detail::true_t> : template_name ##1<T, U> {}; template <class T, class B> struct template_name<T, T, B, ::boost::detail::false_t> : template_name ##1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::template_name<T, U, B, O> > { typedef ::boost::detail::true_t value; }; BOOST_OPERATOR_TEMPLATE2(template_name ##2) BOOST_OPERATOR_TEMPLATE1(template_name ##1)
namespace boost {
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct less_than_comparable : less_than_comparable2<T, U, B> {}; template<class T, class U, class B> struct less_than_comparable<T, U, B, ::boost::detail::true_t> : less_than_comparable1<T, U> {}; template <class T, class B> struct less_than_comparable<T, T, B, ::boost::detail::false_t> : less_than_comparable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::less_than_comparable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::less_than_comparable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::less_than_comparable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct equality_comparable : equality_comparable2<T, U, B> {}; template<class T, class U, class B> struct equality_comparable<T, U, B, ::boost::detail::true_t> : equality_comparable1<T, U> {}; template <class T, class B> struct equality_comparable<T, T, B, ::boost::detail::false_t> : equality_comparable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::equality_comparable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::equality_comparable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::equality_comparable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct multipliable : multipliable2<T, U, B> {}; template<class T, class U, class B> struct multipliable<T, U, B, ::boost::detail::true_t> : multipliable1<T, U> {}; template <class T, class B> struct multipliable<T, T, B, ::boost::detail::false_t> : multipliable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::multipliable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::multipliable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::multipliable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct addable : addable2<T, U, B> {}; template<class T, class U, class B> struct addable<T, U, B, ::boost::detail::true_t> : addable1<T, U> {}; template <class T, class B> struct addable<T, T, B, ::boost::detail::false_t> : addable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::addable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::addable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::addable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct subtractable : subtractable2<T, U, B> {}; template<class T, class U, class B> struct subtractable<T, U, B, ::boost::detail::true_t> : subtractable1<T, U> {}; template <class T, class B> struct subtractable<T, T, B, ::boost::detail::false_t> : subtractable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::subtractable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::subtractable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::subtractable1<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< ::boost::subtractable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct dividable : dividable2<T, U, B> {}; template<class T, class U, class B> struct dividable<T, U, B, ::boost::detail::true_t> : dividable1<T, U> {}; template <class T, class B> struct dividable<T, T, B, ::boost::detail::false_t> : dividable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::dividable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::dividable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::dividable1<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< ::boost::dividable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct modable : modable2<T, U, B> {}; template<class T, class U, class B> struct modable<T, U, B, ::boost::detail::true_t> : modable1<T, U> {}; template <class T, class B> struct modable<T, T, B, ::boost::detail::false_t> : modable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::modable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::modable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::modable1<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< ::boost::modable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct xorable : xorable2<T, U, B> {}; template<class T, class U, class B> struct xorable<T, U, B, ::boost::detail::true_t> : xorable1<T, U> {}; template <class T, class B> struct xorable<T, T, B, ::boost::detail::false_t> : xorable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::xorable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::xorable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::xorable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct andable : andable2<T, U, B> {}; template<class T, class U, class B> struct andable<T, U, B, ::boost::detail::true_t> : andable1<T, U> {}; template <class T, class B> struct andable<T, T, B, ::boost::detail::false_t> : andable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::andable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::andable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::andable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct orable : orable2<T, U, B> {}; template<class T, class U, class B> struct orable<T, U, B, ::boost::detail::true_t> : orable1<T, U> {}; template <class T, class B> struct orable<T, T, B, ::boost::detail::false_t> : orable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::orable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::orable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::orable1<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class B> struct is_chained_base< ::boost::incrementable<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class B> struct is_chained_base< ::boost::decrementable<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< ::boost::dereferenceable<T, U, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class V, class B> struct is_chained_base< ::boost::indexable<T, U, V, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct left_shiftable : left_shiftable2<T, U, B> {}; template<class T, class U, class B> struct left_shiftable<T, U, B, ::boost::detail::true_t> : left_shiftable1<T, U> {}; template <class T, class B> struct left_shiftable<T, T, B, ::boost::detail::false_t> : left_shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::left_shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::left_shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::left_shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct right_shiftable : right_shiftable2<T, U, B> {}; template<class T, class U, class B> struct right_shiftable<T, U, B, ::boost::detail::true_t> : right_shiftable1<T, U> {}; template <class T, class B> struct right_shiftable<T, T, B, ::boost::detail::false_t> : right_shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::right_shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::right_shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::right_shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct equivalent : equivalent2<T, U, B> {}; template<class T, class U, class B> struct equivalent<T, U, B, ::boost::detail::true_t> : equivalent1<T, U> {}; template <class T, class B> struct equivalent<T, T, B, ::boost::detail::false_t> : equivalent1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::equivalent<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::equivalent2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::equivalent1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct partially_ordered : partially_ordered2<T, U, B> {}; template<class T, class U, class B> struct partially_ordered<T, U, B, ::boost::detail::true_t> : partially_ordered1<T, U> {}; template <class T, class B> struct partially_ordered<T, T, B, ::boost::detail::false_t> : partially_ordered1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::partially_ordered<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::partially_ordered2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::partially_ordered1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct totally_ordered : totally_ordered2<T, U, B> {}; template<class T, class U, class B> struct totally_ordered<T, U, B, ::boost::detail::true_t> : totally_ordered1<T, U> {}; template <class T, class B> struct totally_ordered<T, T, B, ::boost::detail::false_t> : totally_ordered1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::totally_ordered<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::totally_ordered2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::totally_ordered1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct additive : additive2<T, U, B> {}; template<class T, class U, class B> struct additive<T, U, B, ::boost::detail::true_t> : additive1<T, U> {}; template <class T, class B> struct additive<T, T, B, ::boost::detail::false_t> : additive1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::additive<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::additive2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::additive1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct multiplicative : multiplicative2<T, U, B> {}; template<class T, class U, class B> struct multiplicative<T, U, B, ::boost::detail::true_t> : multiplicative1<T, U> {}; template <class T, class B> struct multiplicative<T, T, B, ::boost::detail::false_t> : multiplicative1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::multiplicative<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::multiplicative2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::multiplicative1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct integer_multiplicative : integer_multiplicative2<T, U, B> {}; template<class T, class U, class B> struct integer_multiplicative<T, U, B, ::boost::detail::true_t> : integer_multiplicative1<T, U> {}; template <class T, class B> struct integer_multiplicative<T, T, B, ::boost::detail::false_t> : integer_multiplicative1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::integer_multiplicative<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::integer_multiplicative2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::integer_multiplicative1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct arithmetic : arithmetic2<T, U, B> {}; template<class T, class U, class B> struct arithmetic<T, U, B, ::boost::detail::true_t> : arithmetic1<T, U> {}; template <class T, class B> struct arithmetic<T, T, B, ::boost::detail::false_t> : arithmetic1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::arithmetic<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::arithmetic2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::arithmetic1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct integer_arithmetic : integer_arithmetic2<T, U, B> {}; template<class T, class U, class B> struct integer_arithmetic<T, U, B, ::boost::detail::true_t> : integer_arithmetic1<T, U> {}; template <class T, class B> struct integer_arithmetic<T, T, B, ::boost::detail::false_t> : integer_arithmetic1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::integer_arithmetic<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::integer_arithmetic2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::integer_arithmetic1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct bitwise : bitwise2<T, U, B> {}; template<class T, class U, class B> struct bitwise<T, U, B, ::boost::detail::true_t> : bitwise1<T, U> {}; template <class T, class B> struct bitwise<T, T, B, ::boost::detail::false_t> : bitwise1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::bitwise<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::bitwise2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::bitwise1<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class B> struct is_chained_base< ::boost::unit_steppable<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct shiftable : shiftable2<T, U, B> {}; template<class T, class U, class B> struct shiftable<T, U, B, ::boost::detail::true_t> : shiftable1<T, U> {}; template <class T, class B> struct shiftable<T, T, B, ::boost::detail::false_t> : shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ring_operators : ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ring_operators<T, U, B, ::boost::detail::true_t> : ring_operators1<T, U> {}; template <class T, class B> struct ring_operators<T, T, B, ::boost::detail::false_t> : ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_ring_operators : ordered_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_ring_operators1<T, U> {}; template <class T, class B> struct ordered_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct field_operators : field_operators2<T, U, B> {}; template<class T, class U, class B> struct field_operators<T, U, B, ::boost::detail::true_t> : field_operators1<T, U> {}; template <class T, class B> struct field_operators<T, T, B, ::boost::detail::false_t> : field_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::field_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::field_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::field_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_field_operators : ordered_field_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_field_operators<T, U, B, ::boost::detail::true_t> : ordered_field_operators1<T, U> {}; template <class T, class B> struct ordered_field_operators<T, T, B, ::boost::detail::false_t> : ordered_field_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_field_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_field_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_field_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct euclidian_ring_operators : euclidian_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct euclidian_ring_operators<T, U, B, ::boost::detail::true_t> : euclidian_ring_operators1<T, U> {}; template <class T, class B> struct euclidian_ring_operators<T, T, B, ::boost::detail::false_t> : euclidian_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::euclidian_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::euclidian_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::euclidian_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_euclidian_ring_operators : ordered_euclidian_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_euclidian_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_euclidian_ring_operators1<T, U> {}; template <class T, class B> struct ordered_euclidian_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_euclidian_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_euclidian_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_euclidian_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_euclidian_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct euclidean_ring_operators : euclidean_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct euclidean_ring_operators<T, U, B, ::boost::detail::true_t> : euclidean_ring_operators1<T, U> {}; template <class T, class B> struct euclidean_ring_operators<T, T, B, ::boost::detail::false_t> : euclidean_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::euclidean_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::euclidean_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::euclidean_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_euclidean_ring_operators : ordered_euclidean_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_euclidean_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_euclidean_ring_operators1<T, U> {}; template <class T, class B> struct ordered_euclidean_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_euclidean_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_euclidean_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_euclidean_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_euclidean_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< ::boost::input_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
template<class T, class B> struct is_chained_base< ::boost::output_iteratable<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< ::boost::forward_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< ::boost::bidirectional_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class V, class W, class B> struct is_chained_base< ::boost::random_access_iteratable<T, U, V, W, B> > { typedef ::boost::detail::true_t value; };
#undef BOOST_OPERATOR_TEMPLATE
#undef BOOST_OPERATOR_TEMPLATE4
#undef BOOST_OPERATOR_TEMPLATE3
#undef BOOST_OPERATOR_TEMPLATE2
#undef BOOST_OPERATOR_TEMPLATE1
#undef BOOST_IMPORT_TEMPLATE1
#undef BOOST_IMPORT_TEMPLATE2
#undef BOOST_IMPORT_TEMPLATE3
#undef BOOST_IMPORT_TEMPLATE4
template <class T, class U>
struct operators2
: totally_ordered2<T,U
, integer_arithmetic2<T,U
, bitwise2<T,U
> > > {};
template <class T, class U = T>
struct operators : operators2<T, U> {};
template <class T> struct operators<T, T>
: totally_ordered<T
, integer_arithmetic<T
, bitwise<T
, unit_steppable<T
> > > > {};
template <class T,
class V,
class D = std::ptrdiff_t,
class P = V const *,
class R = V const &>
struct input_iterator_helper
: input_iteratable<T, P
, boost::iterator<std::input_iterator_tag, V, D, P, R
> > {};
template<class T>
struct output_iterator_helper
: output_iteratable<T
, boost::iterator<std::output_iterator_tag, void, void, void, void
> >
{
T& operator*() ;
T& operator++() ;
};
template <class T,
class V,
class D = std::ptrdiff_t,
class P = V*,
class R = V&>
struct forward_iterator_helper
: forward_iteratable<T, P
, boost::iterator<std::forward_iterator_tag, V, D, P, R
> > {};
template <class T,
class V,
class D = std::ptrdiff_t,
class P = V*,
class R = V&>
struct bidirectional_iterator_helper
: bidirectional_iteratable<T, P
, boost::iterator<std::bidirectional_iterator_tag, V, D, P, R
> > {};
template <class T,
class V,
class D = std::ptrdiff_t,
class P = V*,
class R = V&>
struct random_access_iterator_helper
: random_access_iteratable<T, P, D, R
, boost::iterator<std::random_access_iterator_tag, V, D, P, R
> >
{
friend D requires_difference_operator(const T& x, const T& y) ;
};
}
#define BOOST_NONCOPYABLE_HPP_INCLUDED
namespace boost {
namespace noncopyable_
{
class noncopyable
{
protected:
constexpr noncopyable() = default;
~noncopyable() = default;
noncopyable( const noncopyable& ) = delete;
noncopyable& operator=( const noncopyable& ) = delete;
};
}
typedef noncopyable_::noncopyable noncopyable;
}
#define BOOST_UTILITY_ENABLE_IF_HPP
namespace boost
{
template <bool B, class T = void>
struct enable_if_c {
typedef T type;
};
template <class T>
struct enable_if_c<false, T> {};
template <class Cond, class T = void>
struct enable_if : public enable_if_c<Cond::value, T> {};
template <bool B, class T>
struct lazy_enable_if_c {
typedef typename T::type type;
};
template <class T>
struct lazy_enable_if_c<false, T> {};
template <class Cond, class T>
struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
template <bool B, class T = void>
struct disable_if_c {
typedef T type;
};
template <class T>
struct disable_if_c<true, T> {};
template <class Cond, class T = void>
struct disable_if : public disable_if_c<Cond::value, T> {};
template <bool B, class T>
struct lazy_disable_if_c {
typedef typename T::type type;
};
template <class T>
struct lazy_disable_if_c<true, T> {};
template <class Cond, class T>
struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
}
#define BOOST_CERRNO_HPP
#undef __need_error_t
#define BOOST_CONFIG_ABI_PREFIX_HPP
#define BOOST_SYSTEM_NOEXCEPT BOOST_NOEXCEPT
namespace boost
{
namespace system
{
class error_code;
class error_condition;
template< class T >
struct is_error_code_enum { static const bool value = false; };
template< class T >
struct is_error_condition_enum { static const bool value = false; };
namespace errc
{
enum errc_t
{
success = 0,
address_family_not_supported = 97,
address_in_use = 98,
address_not_available = 99,
already_connected = 106,
argument_list_too_long = 7,
argument_out_of_domain = 33,
bad_address = 14,
bad_file_descriptor = 9,
bad_message = 74,
broken_pipe = 32,
connection_aborted = 103,
connection_already_in_progress = 114,
connection_refused = 111,
connection_reset = 104,
cross_device_link = 18,
destination_address_required = 89,
device_or_resource_busy = 16,
directory_not_empty = 39,
executable_format_error = 8,
file_exists = 17,
file_too_large = 27,
filename_too_long = 36,
function_not_supported = 38,
host_unreachable = 113,
identifier_removed = 43,
illegal_byte_sequence = 84,
inappropriate_io_control_operation = 25,
interrupted = 4,
invalid_argument = 22,
invalid_seek = 29,
io_error = 5,
is_a_directory = 21,
message_size = 90,
network_down = 100,
network_reset = 102,
network_unreachable = 101,
no_buffer_space = 105,
no_child_process = 10,
no_link = 67,
no_lock_available = 37,
no_message_available = 61,
no_message = 42,
no_protocol_option = 92,
no_space_on_device = 28,
no_stream_resources = 63,
no_such_device_or_address = 6,
no_such_device = 19,
no_such_file_or_directory = 2,
no_such_process = 3,
not_a_directory = 20,
not_a_socket = 88,
not_a_stream = 60,
not_connected = 107,
not_enough_memory = 12,
not_supported = 95,
operation_canceled = 125,
operation_in_progress = 115,
operation_not_permitted = 1,
operation_not_supported = 95,
operation_would_block = 11,
owner_dead = 130,
permission_denied = 13,
protocol_error = 71,
protocol_not_supported = 93,
read_only_file_system = 30,
resource_deadlock_would_occur = 35,
resource_unavailable_try_again = 11,
result_out_of_range = 34,
state_not_recoverable = 131,
stream_timeout = 62,
text_file_busy = 26,
timed_out = 110,
too_many_files_open_in_system = 23,
too_many_files_open = 24,
too_many_links = 31,
too_many_symbolic_link_levels = 40,
value_too_large = 75,
wrong_protocol_type = 91
};
}
namespace posix = errc;
namespace posix_error = errc;
template<> struct is_error_condition_enum<errc::errc_t>
{ static const bool value = true; };
class error_category : public noncopyable
{
public:
virtual ~error_category();
virtual const char * name() const noexcept = 0;
virtual std::string message( int ev ) const = 0;
inline virtual error_condition default_error_condition( int ev ) const noexcept;
inline virtual bool equivalent( int code,
const error_condition & condition ) const noexcept;
inline virtual bool equivalent( const error_code & code,
int condition ) const noexcept;
bool operator==(const error_category & rhs) const noexcept { return this == &rhs; }
bool operator!=(const error_category & rhs) const noexcept { return this != &rhs; }
bool operator<( const error_category & rhs ) const noexcept
{
return std::less<const error_category*>()( this, &rhs );
}
};
const error_category & system_category() noexcept;
const error_category & generic_category() noexcept;
const error_category & get_system_category() ;
const error_category & get_generic_category() ;
const error_category & get_posix_category() ;
static const error_category & posix_category = generic_category();
static const error_category & errno_ecat = generic_category();
static const error_category & native_ecat = system_category();
class error_condition
{
public:
error_condition() noexcept : m_val(0), m_cat(&generic_category()) {}
error_condition( int val, const error_category & cat ) noexcept : m_val(val), m_cat(&cat) {}
template <class ErrorConditionEnum>
error_condition(ErrorConditionEnum e,
typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum> >::type* = 0) noexcept
{
*this = make_error_condition(e);
}
void assign( int val, const error_category & cat ) noexcept
{
m_val = val;
m_cat = &cat;
}
template<typename ErrorConditionEnum>
typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum>, error_condition>::type &
operator=( ErrorConditionEnum val ) noexcept
{
*this = make_error_condition(val);
return *this;
}
void clear() noexcept
{
m_val = 0;
m_cat = &generic_category();
}
int value() const noexcept { return m_val; }
const error_category & category() const noexcept { return *m_cat; }
std::string message() const { return m_cat->message(value()); }
typedef void (*unspecified_bool_type)();
static void unspecified_bool_true() ;
operator unspecified_bool_type() const noexcept
{
return m_val == 0 ? 0 : unspecified_bool_true;
}
bool operator!() const noexcept
{
return m_val == 0;
}
inline friend bool operator==( const error_condition & lhs,
const error_condition & rhs ) noexcept
{
return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
}
inline friend bool operator<( const error_condition & lhs,
const error_condition & rhs ) noexcept
{
return lhs.m_cat < rhs.m_cat
|| (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
}
private:
int m_val;
const error_category * m_cat;
};
class error_code
{
public:
error_code() noexcept : m_val(0), m_cat(&system_category()) {}
error_code( int val, const error_category & cat ) noexcept : m_val(val), m_cat(&cat) {}
template <class ErrorCodeEnum>
error_code(ErrorCodeEnum e,
typename boost::enable_if<is_error_code_enum<ErrorCodeEnum> >::type* = 0) noexcept
{
*this = make_error_code(e);
}
void assign( int val, const error_category & cat ) noexcept
{
m_val = val;
m_cat = &cat;
}
template<typename ErrorCodeEnum>
typename boost::enable_if<is_error_code_enum<ErrorCodeEnum>, error_code>::type &
operator=( ErrorCodeEnum val ) noexcept
{
*this = make_error_code(val);
return *this;
}
void clear() noexcept
{
m_val = 0;
m_cat = &system_category();
}
int value() const noexcept { return m_val; }
const error_category & category() const noexcept { return *m_cat; }
error_condition default_error_condition() const noexcept { return m_cat->default_error_condition(value()); }
std::string message() const { return m_cat->message(value()); }
typedef void (*unspecified_bool_type)();
static void unspecified_bool_true() ;
operator unspecified_bool_type() const noexcept
{
return m_val == 0 ? 0 : unspecified_bool_true;
}
bool operator!() const noexcept
{
return m_val == 0;
}
inline friend bool operator==( const error_code & lhs,
const error_code & rhs ) noexcept
{
return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
}
inline friend bool operator<( const error_code & lhs,
const error_code & rhs ) noexcept
{
return lhs.m_cat < rhs.m_cat
|| (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
}
private:
int m_val;
const error_category * m_cat;
};
extern error_code throws;
}
namespace detail { system::error_code * throws() ; }
system::error_code & throws()
;
namespace system
{
inline bool operator!=( const error_code & lhs,
const error_code & rhs ) noexcept
{
return !(lhs == rhs);
}
inline bool operator!=( const error_condition & lhs,
const error_condition & rhs ) noexcept
{
return !(lhs == rhs);
}
inline bool operator==( const error_code & code,
const error_condition & condition ) noexcept
{
return code.category().equivalent( code.value(), condition )
|| condition.category().equivalent( code, condition.value() );
}
inline bool operator!=( const error_code & lhs,
const error_condition & rhs ) noexcept
{
return !(lhs == rhs);
}
inline bool operator==( const error_condition & condition,
const error_code & code ) noexcept
{
return condition.category().equivalent( code, condition.value() )
|| code.category().equivalent( code.value(), condition );
}
inline bool operator!=( const error_condition & lhs,
const error_code & rhs ) noexcept
{
return !(lhs == rhs);
}
template <class charT, class traits>
inline std::basic_ostream<charT,traits>&
operator<< (std::basic_ostream<charT,traits>& os, error_code ec)
{
os << ec.category().name() << ':' << ec.value();
return os;
}
inline std::size_t hash_value( const error_code & ec )
{
return static_cast<std::size_t>(ec.value())
+ reinterpret_cast<std::size_t>(&ec.category());
}
namespace errc
{
inline error_code make_error_code( errc_t e ) noexcept
{ return error_code( e, generic_category() ); }
inline error_condition make_error_condition( errc_t e ) noexcept
{ return error_condition( e, generic_category() ); }
}
error_condition error_category::default_error_condition( int ev ) const noexcept
{
return error_condition( ev, *this );
}
bool error_category::equivalent( int code,
const error_condition & condition ) const noexcept
{
return default_error_condition( code ) == condition;
}
bool error_category::equivalent( const error_code & code,
int condition ) const noexcept
{
return *this == code.category() && code.value() == condition;
}
}
}
#undef BOOST_CONFIG_ABI_PREFIX_HPP
namespace boost {
namespace asio {
namespace detail {
inline void do_throw_error(const boost::system::error_code& err);
inline void do_throw_error(const boost::system::error_code& err,
const char* location);
void throw_error(const boost::system::error_code& err)
;
void throw_error(const boost::system::error_code& err,
const char* location)
;
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_THROW_ERROR_IPP
#define BOOST_ASIO_DETAIL_THROW_EXCEPTION_HPP
#define UUID_AA15E74A856F11E08B8D93F24824019B
#define UUID_61531AB0680611DEADD5846855D89593
#define BOOST_ATTRIBUTE_NORETURN __attribute__((__noreturn__))
#define UUID_274DA366004E11DCB1DDFE2E56D89593
namespace
boost
{
namespace
exception_detail
{
template <class T>
class
refcount_ptr
{
public:
refcount_ptr()
;
~refcount_ptr()
;
refcount_ptr( refcount_ptr const & x )
;
refcount_ptr &
operator=( refcount_ptr const & x )
;
void
adopt( T * px )
;
T *
get() const
;
private:
T * px_;
void
add_ref()
;
void
release()
;
};
}
template <class Tag,class T>
class error_info;
typedef error_info<struct throw_function_,char const *> throw_function;
typedef error_info<struct throw_file_,char const *> throw_file;
typedef error_info<struct throw_line_,int> throw_line;
template <>
class
error_info<throw_function_,char const *>
{
public:
typedef char const * value_type;
value_type v_;
explicit
error_info( value_type v )
;
};
template <>
class
error_info<throw_file_,char const *>
{
public:
typedef char const * value_type;
value_type v_;
explicit
error_info( value_type v )
;
};
template <>
class
error_info<throw_line_,int>
{
public:
typedef int value_type;
value_type v_;
explicit
error_info( value_type v )
;
};
#pragma GCC visibility push (default)
class exception;
#pragma GCC visibility pop
template <class T>
class shared_ptr;
namespace
exception_detail
{
class error_info_base;
struct type_info_;
struct
error_info_container
{
virtual char const * diagnostic_information( char const * ) const = 0;
virtual shared_ptr<error_info_base> get( type_info_ const & ) const = 0;
virtual void set( shared_ptr<error_info_base> const &, type_info_ const & ) = 0;
virtual void add_ref() const = 0;
virtual bool release() const = 0;
virtual refcount_ptr<exception_detail::error_info_container> clone() const = 0;
protected:
~error_info_container() throw()
;
};
template <class>
struct get_info;
template <>
struct get_info<throw_function>;
template <>
struct get_info<throw_file>;
template <>
struct get_info<throw_line>;
char const * get_diagnostic_information( exception const &, char const * );
void copy_boost_exception( exception *, exception const * );
template <class E,class Tag,class T>
E const & set_info( E const &, error_info<Tag,T> const & );
template <class E>
E const & set_info( E const &, throw_function const & );
template <class E>
E const & set_info( E const &, throw_file const & );
template <class E>
E const & set_info( E const &, throw_line const & );
}
#pragma GCC visibility push (default)
class
exception
{
protected:
exception()
;
virtual ~exception() throw()
= 0
;
private:
template <class E>
friend E const & exception_detail::set_info( E const &, throw_function const & );
template <class E>
friend E const & exception_detail::set_info( E const &, throw_file const & );
template <class E>
friend E const & exception_detail::set_info( E const &, throw_line const & );
template <class E,class Tag,class T>
friend E const & exception_detail::set_info( E const &, error_info<Tag,T> const & );
friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );
template <class>
friend struct exception_detail::get_info;
friend struct exception_detail::get_info<throw_function>;
friend struct exception_detail::get_info<throw_file>;
friend struct exception_detail::get_info<throw_line>;
friend void exception_detail::copy_boost_exception( exception *, exception const * );
mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
mutable char const * throw_function_;
mutable char const * throw_file_;
mutable int throw_line_;
};
#pragma GCC visibility pop
namespace
exception_detail
{
template <class E>
E const &
set_info( E const & x, throw_function const & y )
;
template <class E>
E const &
set_info( E const & x, throw_file const & y )
;
template <class E>
E const &
set_info( E const & x, throw_line const & y )
;
}
namespace
exception_detail
{
#pragma GCC visibility push (default)
template <class T>
struct
error_info_injector:
public T,
public exception
{
explicit
error_info_injector( T const & x )
;
~error_info_injector() throw()
;
};
#pragma GCC visibility pop
struct large_size { char c[256]; };
large_size dispatch_boost_exception( exception const * );
struct small_size { };
small_size dispatch_boost_exception( void const * );
template <class,int>
struct enable_error_info_helper;
template <class T>
struct
enable_error_info_helper<T,sizeof(large_size)>
{
typedef T type;
};
template <class T>
struct
enable_error_info_helper<T,sizeof(small_size)>
{
typedef error_info_injector<T> type;
};
template <class T>
struct
enable_error_info_return_type
{
typedef typename enable_error_info_helper<T,sizeof(exception_detail::dispatch_boost_exception(static_cast<T *>(0)))>::type type;
};
}
template <class T>
typename
exception_detail::enable_error_info_return_type<T>::type
enable_error_info( T const & x )
;
namespace
exception_detail
{
#pragma GCC visibility push (default)
class
clone_base
{
public:
virtual clone_base const * clone() const = 0;
virtual void rethrow() const = 0;
virtual
~clone_base() throw()
;
};
#pragma GCC visibility pop
void
copy_boost_exception( exception * a, exception const * b )
;
void
copy_boost_exception( void *, void const * )
;
template <class T>
class
clone_impl:
public T,
public virtual clone_base
{
struct clone_tag { };
clone_impl( clone_impl const & x, clone_tag )
;
public:
explicit
clone_impl( T const & x )
;
~clone_impl() throw()
;
private:
clone_base const *
clone() const
;
void
rethrow() const
;
};
}
template <class T>
exception_detail::clone_impl<T>
enable_current_exception( T const & x )
;
}
#define BOOST_CURRENT_FUNCTION_HPP_INCLUDED
namespace boost
{
namespace detail
{
void current_function_helper()
;
}
}
#define BOOST_THROW_EXCEPTION_CURRENT_FUNCTION BOOST_CURRENT_FUNCTION
#define BOOST_THROW_EXCEPTION(x) ::boost::exception_detail::throw_exception_(x,BOOST_THROW_EXCEPTION_CURRENT_FUNCTION,__FILE__,__LINE__)
namespace boost
{
void throw_exception_assert_compatibility( std::exception const & ) ;
template<class E> __attribute__((__noreturn__)) void throw_exception( E const & e )
;
namespace
exception_detail
{
template <class E>
__attribute__((__noreturn__))
void
throw_exception_( E const & x, char const * current_function, char const * file, int line )
;
}
}
namespace boost {
namespace asio {
namespace detail {
using boost::throw_exception;
}
}
}
#define BOOST_SYSTEM_ERROR_HPP
#undef _ASSERT_H
#undef assert
#undef __ASSERT_VOID_CAST
#undef assert_perror
#define _ASSERT_H 1
#define __ASSERT_VOID_CAST static_cast<void>
#define assert(expr) (__ASSERT_VOID_CAST (0))
#define assert_perror(errnum) (__ASSERT_VOID_CAST (0))
namespace boost
{
namespace system
{
class __attribute__((__visibility__("default"))) system_error : public std::runtime_error
{
public:
system_error( error_code ec ) ;
system_error( error_code ec, const std::string & what_arg ) ;
system_error( error_code ec, const char* what_arg ) ;
system_error( int ev, const error_category & ecat )
: std::runtime_error(""), m_error_code(ev,ecat) {}
system_error( int ev, const error_category & ecat,
const std::string & what_arg )
: std::runtime_error(what_arg), m_error_code(ev,ecat) {}
system_error( int ev, const error_category & ecat,
const char * what_arg )
: std::runtime_error(what_arg), m_error_code(ev,ecat) {}
virtual ~system_error() throw() ;
const error_code & code() const throw() ;
const char * what() const throw();
private:
error_code m_error_code;
mutable std::string m_what;
};
}
}
namespace boost {
namespace asio {
namespace detail {
void do_throw_error(const boost::system::error_code& err)
;
void do_throw_error(const boost::system::error_code& err, const char* location)
;
}
}
}
#define BOOST_ASIO_ERROR_HPP
#undef __need_error_t
#define _NETDB_H 1
#define _NETINET_IN_H 1
#define _SYS_SOCKET_H 1
extern "C" {
#define _SYS_UIO_H 1
extern "C" {
#define _BITS_UIO_H 1
#define UIO_MAXIOV 1024
struct iovec
{
void *iov_base;
size_t iov_len;
};
#define _BITS_UIO_H_FOR_SYS_UIO_H 1
extern "C" {
extern ssize_t process_vm_readv (pid_t __pid, const struct iovec *__lvec,
unsigned long int __liovcnt,
const struct iovec *__rvec,
unsigned long int __riovcnt,
unsigned long int __flags)
throw ();
extern ssize_t process_vm_writev (pid_t __pid, const struct iovec *__lvec,
unsigned long int __liovcnt,
const struct iovec *__rvec,
unsigned long int __riovcnt,
unsigned long int __flags)
throw ();
}
extern ssize_t readv (int __fd, const struct iovec *__iovec, int __count)
;
extern ssize_t writev (int __fd, const struct iovec *__iovec, int __count)
;
extern ssize_t preadv (int __fd, const struct iovec *__iovec, int __count,
__off_t __offset) ;
extern ssize_t pwritev (int __fd, const struct iovec *__iovec, int __count,
__off_t __offset) ;
extern ssize_t preadv64 (int __fd, const struct iovec *__iovec, int __count,
__off64_t __offset) ;
extern ssize_t pwritev64 (int __fd, const struct iovec *__iovec, int __count,
__off64_t __offset) ;
}
#define __need_size_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define __BITS_SOCKET_H
#define __need_size_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
enum __socket_type
{
SOCK_STREAM = 1,
#define SOCK_STREAM SOCK_STREAM
SOCK_DGRAM = 2,
#define SOCK_DGRAM SOCK_DGRAM
SOCK_RAW = 3,
#define SOCK_RAW SOCK_RAW
SOCK_RDM = 4,
#define SOCK_RDM SOCK_RDM
SOCK_SEQPACKET = 5,
#define SOCK_SEQPACKET SOCK_SEQPACKET
SOCK_DCCP = 6,
#define SOCK_DCCP SOCK_DCCP
SOCK_PACKET = 10,
#define SOCK_PACKET SOCK_PACKET
SOCK_CLOEXEC = 02000000,
#define SOCK_CLOEXEC SOCK_CLOEXEC
SOCK_NONBLOCK = 00004000
#define SOCK_NONBLOCK SOCK_NONBLOCK
};
#define PF_UNSPEC 0
#define PF_LOCAL 1
#define PF_UNIX PF_LOCAL
#define PF_FILE PF_LOCAL
#define PF_INET 2
#define PF_AX25 3
#define PF_IPX 4
#define PF_APPLETALK 5
#define PF_NETROM 6
#define PF_BRIDGE 7
#define PF_ATMPVC 8
#define PF_X25 9
#define PF_INET6 10
#define PF_ROSE 11
#define PF_DECnet 12
#define PF_NETBEUI 13
#define PF_SECURITY 14
#define PF_KEY 15
#define PF_NETLINK 16
#define PF_ROUTE PF_NETLINK
#define PF_PACKET 17
#define PF_ASH 18
#define PF_ECONET 19
#define PF_ATMSVC 20
#define PF_RDS 21
#define PF_SNA 22
#define PF_IRDA 23
#define PF_PPPOX 24
#define PF_WANPIPE 25
#define PF_LLC 26
#define PF_CAN 29
#define PF_TIPC 30
#define PF_BLUETOOTH 31
#define PF_IUCV 32
#define PF_RXRPC 33
#define PF_ISDN 34
#define PF_PHONET 35
#define PF_IEEE802154 36
#define PF_CAIF 37
#define PF_ALG 38
#define PF_NFC 39
#define PF_VSOCK 40
#define PF_MAX 41
#define AF_UNSPEC PF_UNSPEC
#define AF_LOCAL PF_LOCAL
#define AF_UNIX PF_UNIX
#define AF_FILE PF_FILE
#define AF_INET PF_INET
#define AF_AX25 PF_AX25
#define AF_IPX PF_IPX
#define AF_APPLETALK PF_APPLETALK
#define AF_NETROM PF_NETROM
#define AF_BRIDGE PF_BRIDGE
#define AF_ATMPVC PF_ATMPVC
#define AF_X25 PF_X25
#define AF_INET6 PF_INET6
#define AF_ROSE PF_ROSE
#define AF_DECnet PF_DECnet
#define AF_NETBEUI PF_NETBEUI
#define AF_SECURITY PF_SECURITY
#define AF_KEY PF_KEY
#define AF_NETLINK PF_NETLINK
#define AF_ROUTE PF_ROUTE
#define AF_PACKET PF_PACKET
#define AF_ASH PF_ASH
#define AF_ECONET PF_ECONET
#define AF_ATMSVC PF_ATMSVC
#define AF_RDS PF_RDS
#define AF_SNA PF_SNA
#define AF_IRDA PF_IRDA
#define AF_PPPOX PF_PPPOX
#define AF_WANPIPE PF_WANPIPE
#define AF_LLC PF_LLC
#define AF_CAN PF_CAN
#define AF_TIPC PF_TIPC
#define AF_BLUETOOTH PF_BLUETOOTH
#define AF_IUCV PF_IUCV
#define AF_RXRPC PF_RXRPC
#define AF_ISDN PF_ISDN
#define AF_PHONET PF_PHONET
#define AF_IEEE802154 PF_IEEE802154
#define AF_CAIF PF_CAIF
#define AF_ALG PF_ALG
#define AF_NFC PF_NFC
#define AF_VSOCK PF_VSOCK
#define AF_MAX PF_MAX
#define SOL_RAW 255
#define SOL_DECNET 261
#define SOL_X25 262
#define SOL_PACKET 263
#define SOL_ATM 264
#define SOL_AAL 265
#define SOL_IRDA 266
#define SOMAXCONN 128
#define _BITS_SOCKADDR_H 1
typedef unsigned short int sa_family_t;
#define __SOCKADDR_COMMON(sa_prefix) sa_family_t sa_prefix ##family
#define __SOCKADDR_COMMON_SIZE (sizeof (unsigned short int))
struct sockaddr
{
sa_family_t sa_family;
char sa_data[14];
};
#define __ss_aligntype unsigned long int
#define _SS_SIZE 128
#define _SS_PADSIZE (_SS_SIZE - (2 * sizeof (__ss_aligntype)))
struct sockaddr_storage
{
sa_family_t ss_family;
unsigned long int __ss_align;
char __ss_padding[(128 - (2 * sizeof (unsigned long int)))];
};
enum
{
MSG_OOB = 0x01,
#define MSG_OOB MSG_OOB
MSG_PEEK = 0x02,
#define MSG_PEEK MSG_PEEK
MSG_DONTROUTE = 0x04,
#define MSG_DONTROUTE MSG_DONTROUTE
MSG_TRYHARD = MSG_DONTROUTE,
#define MSG_TRYHARD MSG_DONTROUTE
MSG_CTRUNC = 0x08,
#define MSG_CTRUNC MSG_CTRUNC
MSG_PROXY = 0x10,
#define MSG_PROXY MSG_PROXY
MSG_TRUNC = 0x20,
#define MSG_TRUNC MSG_TRUNC
MSG_DONTWAIT = 0x40,
#define MSG_DONTWAIT MSG_DONTWAIT
MSG_EOR = 0x80,
#define MSG_EOR MSG_EOR
MSG_WAITALL = 0x100,
#define MSG_WAITALL MSG_WAITALL
MSG_FIN = 0x200,
#define MSG_FIN MSG_FIN
MSG_SYN = 0x400,
#define MSG_SYN MSG_SYN
MSG_CONFIRM = 0x800,
#define MSG_CONFIRM MSG_CONFIRM
MSG_RST = 0x1000,
#define MSG_RST MSG_RST
MSG_ERRQUEUE = 0x2000,
#define MSG_ERRQUEUE MSG_ERRQUEUE
MSG_NOSIGNAL = 0x4000,
#define MSG_NOSIGNAL MSG_NOSIGNAL
MSG_MORE = 0x8000,
#define MSG_MORE MSG_MORE
MSG_WAITFORONE = 0x10000,
#define MSG_WAITFORONE MSG_WAITFORONE
MSG_FASTOPEN = 0x20000000,
#define MSG_FASTOPEN MSG_FASTOPEN
MSG_CMSG_CLOEXEC = 0x40000000
#define MSG_CMSG_CLOEXEC MSG_CMSG_CLOEXEC
};
struct msghdr
{
void *msg_name;
socklen_t msg_namelen;
struct iovec *msg_iov;
size_t msg_iovlen;
void *msg_control;
size_t msg_controllen;
int msg_flags;
};
struct cmsghdr
{
size_t cmsg_len;
int cmsg_level;
int cmsg_type;
};
#define CMSG_DATA(cmsg) ((unsigned char *) ((struct cmsghdr *) (cmsg) + 1))
#define CMSG_NXTHDR(mhdr,cmsg) __cmsg_nxthdr (mhdr, cmsg)
#define CMSG_FIRSTHDR(mhdr) ((size_t) (mhdr)->msg_controllen >= sizeof (struct cmsghdr) ? (struct cmsghdr *) (mhdr)->msg_control : (struct cmsghdr *) 0)
#define CMSG_ALIGN(len) (((len) + sizeof (size_t) - 1) & (size_t) ~(sizeof (size_t) - 1))
#define CMSG_SPACE(len) (CMSG_ALIGN (len) + CMSG_ALIGN (sizeof (struct cmsghdr)))
#define CMSG_LEN(len) (CMSG_ALIGN (sizeof (struct cmsghdr)) + (len))
extern struct cmsghdr *__cmsg_nxthdr (struct msghdr *__mhdr,
struct cmsghdr *__cmsg) throw ();
enum
{
SCM_RIGHTS = 0x01
#define SCM_RIGHTS SCM_RIGHTS
, SCM_CREDENTIALS = 0x02
#define SCM_CREDENTIALS SCM_CREDENTIALS
};
struct ucred
{
pid_t pid;
uid_t uid;
gid_t gid;
};
#define __ASM_GENERIC_SOCKET_H
#define __ASM_GENERIC_SOCKIOS_H
#define FIOSETOWN 0x8901
#define SIOCSPGRP 0x8902
#define FIOGETOWN 0x8903
#define SIOCGPGRP 0x8904
#define SIOCATMARK 0x8905
#define SIOCGSTAMP 0x8906
#define SIOCGSTAMPNS 0x8907
#define SOL_SOCKET 1
#define SO_DEBUG 1
#define SO_REUSEADDR 2
#define SO_TYPE 3
#define SO_ERROR 4
#define SO_DONTROUTE 5
#define SO_BROADCAST 6
#define SO_SNDBUF 7
#define SO_RCVBUF 8
#define SO_SNDBUFFORCE 32
#define SO_RCVBUFFORCE 33
#define SO_KEEPALIVE 9
#define SO_OOBINLINE 10
#define SO_NO_CHECK 11
#define SO_PRIORITY 12
#define SO_LINGER 13
#define SO_BSDCOMPAT 14
#define SO_REUSEPORT 15
#define SO_PASSCRED 16
#define SO_PEERCRED 17
#define SO_RCVLOWAT 18
#define SO_SNDLOWAT 19
#define SO_RCVTIMEO 20
#define SO_SNDTIMEO 21
#define SO_SECURITY_AUTHENTICATION 22
#define SO_SECURITY_ENCRYPTION_TRANSPORT 23
#define SO_SECURITY_ENCRYPTION_NETWORK 24
#define SO_BINDTODEVICE 25
#define SO_ATTACH_FILTER 26
#define SO_DETACH_FILTER 27
#define SO_GET_FILTER SO_ATTACH_FILTER
#define SO_PEERNAME 28
#define SO_TIMESTAMP 29
#define SCM_TIMESTAMP SO_TIMESTAMP
#define SO_ACCEPTCONN 30
#define SO_PEERSEC 31
#define SO_PASSSEC 34
#define SO_TIMESTAMPNS 35
#define SCM_TIMESTAMPNS SO_TIMESTAMPNS
#define SO_MARK 36
#define SO_TIMESTAMPING 37
#define SCM_TIMESTAMPING SO_TIMESTAMPING
#define SO_PROTOCOL 38
#define SO_DOMAIN 39
#define SO_RXQ_OVFL 40
#define SO_WIFI_STATUS 41
#define SCM_WIFI_STATUS SO_WIFI_STATUS
#define SO_PEEK_OFF 42
#define SO_NOFCS 43
#define SO_LOCK_FILTER 44
#define SO_SELECT_ERR_QUEUE 45
#define SO_BUSY_POLL 46
#define SO_MAX_PACING_RATE 47
#define SO_BPF_EXTENSIONS 48
struct linger
{
int l_onoff;
int l_linger;
};
struct osockaddr
{
unsigned short int sa_family;
unsigned char sa_data[14];
};
enum
{
SHUT_RD = 0,
#define SHUT_RD SHUT_RD
SHUT_WR,
#define SHUT_WR SHUT_WR
SHUT_RDWR
#define SHUT_RDWR SHUT_RDWR
};
#define __SOCKADDR_ARG struct sockaddr *__restrict
#define __CONST_SOCKADDR_ARG const struct sockaddr *
struct mmsghdr
{
struct msghdr msg_hdr;
unsigned int msg_len;
};
extern int socket (int __domain, int __type, int __protocol) throw ();
extern int socketpair (int __domain, int __type, int __protocol,
int __fds[2]) throw ();
extern int bind (int __fd, const struct sockaddr * __addr, socklen_t __len)
throw ();
extern int getsockname (int __fd, struct sockaddr *__restrict __addr,
socklen_t *__restrict __len) throw ();
extern int connect (int __fd, const struct sockaddr * __addr, socklen_t __len);
extern int getpeername (int __fd, struct sockaddr *__restrict __addr,
socklen_t *__restrict __len) throw ();
extern ssize_t send (int __fd, const void *__buf, size_t __n, int __flags);
extern ssize_t recv (int __fd, void *__buf, size_t __n, int __flags);
extern ssize_t sendto (int __fd, const void *__buf, size_t __n,
int __flags, const struct sockaddr * __addr,
socklen_t __addr_len);
extern ssize_t recvfrom (int __fd, void *__restrict __buf, size_t __n,
int __flags, struct sockaddr *__restrict __addr,
socklen_t *__restrict __addr_len);
extern ssize_t sendmsg (int __fd, const struct msghdr *__message,
int __flags);
extern int sendmmsg (int __fd, struct mmsghdr *__vmessages,
unsigned int __vlen, int __flags);
extern ssize_t recvmsg (int __fd, struct msghdr *__message, int __flags);
extern int recvmmsg (int __fd, struct mmsghdr *__vmessages,
unsigned int __vlen, int __flags,
const struct timespec *__tmo);
extern int getsockopt (int __fd, int __level, int __optname,
void *__restrict __optval,
socklen_t *__restrict __optlen) throw ();
extern int setsockopt (int __fd, int __level, int __optname,
const void *__optval, socklen_t __optlen) throw ();
extern int listen (int __fd, int __n) throw ();
extern int accept (int __fd, struct sockaddr *__restrict __addr,
socklen_t *__restrict __addr_len);
extern int accept4 (int __fd, struct sockaddr *__restrict __addr,
socklen_t *__restrict __addr_len, int __flags);
extern int shutdown (int __fd, int __how) throw ();
extern int sockatmark (int __fd) throw ();
extern int isfdtype (int __fd, int __fdtype) throw ();
}
extern "C" {
typedef uint32_t in_addr_t;
struct in_addr
{
in_addr_t s_addr;
};
#define IP_OPTIONS 4
#define IP_HDRINCL 3
#define IP_TOS 1
#define IP_TTL 2
#define IP_RECVOPTS 6
#define IP_RECVRETOPTS IP_RETOPTS
#define IP_RETOPTS 7
#define IP_MULTICAST_IF 32
#define IP_MULTICAST_TTL 33
#define IP_MULTICAST_LOOP 34
#define IP_ADD_MEMBERSHIP 35
#define IP_DROP_MEMBERSHIP 36
#define IP_UNBLOCK_SOURCE 37
#define IP_BLOCK_SOURCE 38
#define IP_ADD_SOURCE_MEMBERSHIP 39
#define IP_DROP_SOURCE_MEMBERSHIP 40
#define IP_MSFILTER 41
#define MCAST_JOIN_GROUP 42
#define MCAST_BLOCK_SOURCE 43
#define MCAST_UNBLOCK_SOURCE 44
#define MCAST_LEAVE_GROUP 45
#define MCAST_JOIN_SOURCE_GROUP 46
#define MCAST_LEAVE_SOURCE_GROUP 47
#define MCAST_MSFILTER 48
#define IP_MULTICAST_ALL 49
#define IP_UNICAST_IF 50
#define MCAST_EXCLUDE 0
#define MCAST_INCLUDE 1
#define IP_ROUTER_ALERT 5
#define IP_PKTINFO 8
#define IP_PKTOPTIONS 9
#define IP_PMTUDISC 10
#define IP_MTU_DISCOVER 10
#define IP_RECVERR 11
#define IP_RECVTTL 12
#define IP_RECVTOS 13
#define IP_MTU 14
#define IP_FREEBIND 15
#define IP_IPSEC_POLICY 16
#define IP_XFRM_POLICY 17
#define IP_PASSSEC 18
#define IP_TRANSPARENT 19
#define IP_MULTICAST_ALL 49
#define IP_ORIGDSTADDR 20
#define IP_RECVORIGDSTADDR IP_ORIGDSTADDR
#define IP_MINTTL 21
#define IP_PMTUDISC_DONT 0
#define IP_PMTUDISC_WANT 1
#define IP_PMTUDISC_DO 2
#define IP_PMTUDISC_PROBE 3
#define SOL_IP 0
#define IP_DEFAULT_MULTICAST_TTL 1
#define IP_DEFAULT_MULTICAST_LOOP 1
#define IP_MAX_MEMBERSHIPS 20
struct ip_opts
{
struct in_addr ip_dst;
char ip_opts[40];
};
struct ip_mreqn
{
struct in_addr imr_multiaddr;
struct in_addr imr_address;
int imr_ifindex;
};
struct in_pktinfo
{
int ipi_ifindex;
struct in_addr ipi_spec_dst;
struct in_addr ipi_addr;
};
#define IPV6_ADDRFORM 1
#define IPV6_2292PKTINFO 2
#define IPV6_2292HOPOPTS 3
#define IPV6_2292DSTOPTS 4
#define IPV6_2292RTHDR 5
#define IPV6_2292PKTOPTIONS 6
#define IPV6_CHECKSUM 7
#define IPV6_2292HOPLIMIT 8
#define SCM_SRCRT IPV6_RXSRCRT
#define IPV6_NEXTHOP 9
#define IPV6_AUTHHDR 10
#define IPV6_UNICAST_HOPS 16
#define IPV6_MULTICAST_IF 17
#define IPV6_MULTICAST_HOPS 18
#define IPV6_MULTICAST_LOOP 19
#define IPV6_JOIN_GROUP 20
#define IPV6_LEAVE_GROUP 21
#define IPV6_ROUTER_ALERT 22
#define IPV6_MTU_DISCOVER 23
#define IPV6_MTU 24
#define IPV6_RECVERR 25
#define IPV6_V6ONLY 26
#define IPV6_JOIN_ANYCAST 27
#define IPV6_LEAVE_ANYCAST 28
#define IPV6_IPSEC_POLICY 34
#define IPV6_XFRM_POLICY 35
#define IPV6_RECVPKTINFO 49
#define IPV6_PKTINFO 50
#define IPV6_RECVHOPLIMIT 51
#define IPV6_HOPLIMIT 52
#define IPV6_RECVHOPOPTS 53
#define IPV6_HOPOPTS 54
#define IPV6_RTHDRDSTOPTS 55
#define IPV6_RECVRTHDR 56
#define IPV6_RTHDR 57
#define IPV6_RECVDSTOPTS 58
#define IPV6_DSTOPTS 59
#define IPV6_RECVTCLASS 66
#define IPV6_TCLASS 67
#define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
#define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP
#define IPV6_RXHOPOPTS IPV6_HOPOPTS
#define IPV6_RXDSTOPTS IPV6_DSTOPTS
#define IPV6_PMTUDISC_DONT 0
#define IPV6_PMTUDISC_WANT 1
#define IPV6_PMTUDISC_DO 2
#define IPV6_PMTUDISC_PROBE 3
#define SOL_IPV6 41
#define SOL_ICMPV6 58
#define IPV6_RTHDR_LOOSE 0
#define IPV6_RTHDR_STRICT 1
#define IPV6_RTHDR_TYPE_0 0
enum
{
IPPROTO_IP = 0,
#define IPPROTO_IP IPPROTO_IP
IPPROTO_ICMP = 1,
#define IPPROTO_ICMP IPPROTO_ICMP
IPPROTO_IGMP = 2,
#define IPPROTO_IGMP IPPROTO_IGMP
IPPROTO_IPIP = 4,
#define IPPROTO_IPIP IPPROTO_IPIP
IPPROTO_TCP = 6,
#define IPPROTO_TCP IPPROTO_TCP
IPPROTO_EGP = 8,
#define IPPROTO_EGP IPPROTO_EGP
IPPROTO_PUP = 12,
#define IPPROTO_PUP IPPROTO_PUP
IPPROTO_UDP = 17,
#define IPPROTO_UDP IPPROTO_UDP
IPPROTO_IDP = 22,
#define IPPROTO_IDP IPPROTO_IDP
IPPROTO_TP = 29,
#define IPPROTO_TP IPPROTO_TP
IPPROTO_DCCP = 33,
#define IPPROTO_DCCP IPPROTO_DCCP
IPPROTO_IPV6 = 41,
#define IPPROTO_IPV6 IPPROTO_IPV6
IPPROTO_RSVP = 46,
#define IPPROTO_RSVP IPPROTO_RSVP
IPPROTO_GRE = 47,
#define IPPROTO_GRE IPPROTO_GRE
IPPROTO_ESP = 50,
#define IPPROTO_ESP IPPROTO_ESP
IPPROTO_AH = 51,
#define IPPROTO_AH IPPROTO_AH
IPPROTO_MTP = 92,
#define IPPROTO_MTP IPPROTO_MTP
IPPROTO_BEETPH = 94,
#define IPPROTO_BEETPH IPPROTO_BEETPH
IPPROTO_ENCAP = 98,
#define IPPROTO_ENCAP IPPROTO_ENCAP
IPPROTO_PIM = 103,
#define IPPROTO_PIM IPPROTO_PIM
IPPROTO_COMP = 108,
#define IPPROTO_COMP IPPROTO_COMP
IPPROTO_SCTP = 132,
#define IPPROTO_SCTP IPPROTO_SCTP
IPPROTO_UDPLITE = 136,
#define IPPROTO_UDPLITE IPPROTO_UDPLITE
IPPROTO_RAW = 255,
#define IPPROTO_RAW IPPROTO_RAW
IPPROTO_MAX
};
enum
{
IPPROTO_HOPOPTS = 0,
#define IPPROTO_HOPOPTS IPPROTO_HOPOPTS
IPPROTO_ROUTING = 43,
#define IPPROTO_ROUTING IPPROTO_ROUTING
IPPROTO_FRAGMENT = 44,
#define IPPROTO_FRAGMENT IPPROTO_FRAGMENT
IPPROTO_ICMPV6 = 58,
#define IPPROTO_ICMPV6 IPPROTO_ICMPV6
IPPROTO_NONE = 59,
#define IPPROTO_NONE IPPROTO_NONE
IPPROTO_DSTOPTS = 60,
#define IPPROTO_DSTOPTS IPPROTO_DSTOPTS
IPPROTO_MH = 135
#define IPPROTO_MH IPPROTO_MH
};
typedef uint16_t in_port_t;
enum
{
IPPORT_ECHO = 7,
IPPORT_DISCARD = 9,
IPPORT_SYSTAT = 11,
IPPORT_DAYTIME = 13,
IPPORT_NETSTAT = 15,
IPPORT_FTP = 21,
IPPORT_TELNET = 23,
IPPORT_SMTP = 25,
IPPORT_TIMESERVER = 37,
IPPORT_NAMESERVER = 42,
IPPORT_WHOIS = 43,
IPPORT_MTP = 57,
IPPORT_TFTP = 69,
IPPORT_RJE = 77,
IPPORT_FINGER = 79,
IPPORT_TTYLINK = 87,
IPPORT_SUPDUP = 95,
IPPORT_EXECSERVER = 512,
IPPORT_LOGINSERVER = 513,
IPPORT_CMDSERVER = 514,
IPPORT_EFSSERVER = 520,
IPPORT_BIFFUDP = 512,
IPPORT_WHOSERVER = 513,
IPPORT_ROUTESERVER = 520,
IPPORT_RESERVED = 1024,
IPPORT_USERRESERVED = 5000
};
#define IN_CLASSA(a) ((((in_addr_t)(a)) & 0x80000000) == 0)
#define IN_CLASSA_NET 0xff000000
#define IN_CLASSA_NSHIFT 24
#define IN_CLASSA_HOST (0xffffffff & ~IN_CLASSA_NET)
#define IN_CLASSA_MAX 128
#define IN_CLASSB(a) ((((in_addr_t)(a)) & 0xc0000000) == 0x80000000)
#define IN_CLASSB_NET 0xffff0000
#define IN_CLASSB_NSHIFT 16
#define IN_CLASSB_HOST (0xffffffff & ~IN_CLASSB_NET)
#define IN_CLASSB_MAX 65536
#define IN_CLASSC(a) ((((in_addr_t)(a)) & 0xe0000000) == 0xc0000000)
#define IN_CLASSC_NET 0xffffff00
#define IN_CLASSC_NSHIFT 8
#define IN_CLASSC_HOST (0xffffffff & ~IN_CLASSC_NET)
#define IN_CLASSD(a) ((((in_addr_t)(a)) & 0xf0000000) == 0xe0000000)
#define IN_MULTICAST(a) IN_CLASSD(a)
#define IN_EXPERIMENTAL(a) ((((in_addr_t)(a)) & 0xe0000000) == 0xe0000000)
#define IN_BADCLASS(a) ((((in_addr_t)(a)) & 0xf0000000) == 0xf0000000)
#define INADDR_ANY ((in_addr_t) 0x00000000)
#define INADDR_BROADCAST ((in_addr_t) 0xffffffff)
#define INADDR_NONE ((in_addr_t) 0xffffffff)
#define IN_LOOPBACKNET 127
#define INADDR_LOOPBACK ((in_addr_t) 0x7f000001)
#define INADDR_UNSPEC_GROUP ((in_addr_t) 0xe0000000)
#define INADDR_ALLHOSTS_GROUP ((in_addr_t) 0xe0000001)
#define INADDR_ALLRTRS_GROUP ((in_addr_t) 0xe0000002)
#define INADDR_MAX_LOCAL_GROUP ((in_addr_t) 0xe00000ff)
struct in6_addr
{
union
{
uint8_t __u6_addr8[16];
uint16_t __u6_addr16[8];
uint32_t __u6_addr32[4];
} __in6_u;
#define s6_addr __in6_u.__u6_addr8
#define s6_addr16 __in6_u.__u6_addr16
#define s6_addr32 __in6_u.__u6_addr32
};
extern const struct in6_addr in6addr_any;
extern const struct in6_addr in6addr_loopback;
#define IN6ADDR_ANY_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } } }
#define IN6ADDR_LOOPBACK_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 } } }
#define INET_ADDRSTRLEN 16
#define INET6_ADDRSTRLEN 46
struct sockaddr_in
{
sa_family_t sin_family;
in_port_t sin_port;
struct in_addr sin_addr;
unsigned char sin_zero[sizeof (struct sockaddr) -
(sizeof (unsigned short int)) -
sizeof (in_port_t) -
sizeof (struct in_addr)];
};
struct sockaddr_in6
{
sa_family_t sin6_family;
in_port_t sin6_port;
uint32_t sin6_flowinfo;
struct in6_addr sin6_addr;
uint32_t sin6_scope_id;
};
struct ip_mreq
{
struct in_addr imr_multiaddr;
struct in_addr imr_interface;
};
struct ip_mreq_source
{
struct in_addr imr_multiaddr;
struct in_addr imr_interface;
struct in_addr imr_sourceaddr;
};
struct ipv6_mreq
{
struct in6_addr ipv6mr_multiaddr;
unsigned int ipv6mr_interface;
};
struct group_req
{
uint32_t gr_interface;
struct sockaddr_storage gr_group;
};
struct group_source_req
{
uint32_t gsr_interface;
struct sockaddr_storage gsr_group;
struct sockaddr_storage gsr_source;
};
struct ip_msfilter
{
struct in_addr imsf_multiaddr;
struct in_addr imsf_interface;
uint32_t imsf_fmode;
uint32_t imsf_numsrc;
struct in_addr imsf_slist[1];
};
#define IP_MSFILTER_SIZE(numsrc) (sizeof (struct ip_msfilter) - sizeof (struct in_addr) + (numsrc) * sizeof (struct in_addr))
struct group_filter
{
uint32_t gf_interface;
struct sockaddr_storage gf_group;
uint32_t gf_fmode;
uint32_t gf_numsrc;
struct sockaddr_storage gf_slist[1];
};
#define GROUP_FILTER_SIZE(numsrc) (sizeof (struct group_filter) - sizeof (struct sockaddr_storage) + ((numsrc) * sizeof (struct sockaddr_storage)))
extern uint32_t ntohl (uint32_t __netlong) throw () __attribute__ ((__const__));
extern uint16_t ntohs (uint16_t __netshort)
throw () __attribute__ ((__const__));
extern uint32_t htonl (uint32_t __hostlong)
throw () __attribute__ ((__const__));
extern uint16_t htons (uint16_t __hostshort)
throw () __attribute__ ((__const__));
#define IN6_IS_ADDR_UNSPECIFIED(a) (__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); __a->s6_addr32[0] == 0 && __a->s6_addr32[1] == 0 && __a->s6_addr32[2] == 0 && __a->s6_addr32[3] == 0; }))
#define IN6_IS_ADDR_LOOPBACK(a) (__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); __a->s6_addr32[0] == 0 && __a->s6_addr32[1] == 0 && __a->s6_addr32[2] == 0 && __a->s6_addr32[3] == htonl (1); }))
#define IN6_IS_ADDR_LINKLOCAL(a) (__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); (__a->s6_addr32[0] & htonl (0xffc00000)) == htonl (0xfe800000); }))
#define IN6_IS_ADDR_SITELOCAL(a) (__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); (__a->s6_addr32[0] & htonl (0xffc00000)) == htonl (0xfec00000); }))
#define IN6_IS_ADDR_V4MAPPED(a) (__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); __a->s6_addr32[0] == 0 && __a->s6_addr32[1] == 0 && __a->s6_addr32[2] == htonl (0xffff); }))
#define IN6_IS_ADDR_V4COMPAT(a) (__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); __a->s6_addr32[0] == 0 && __a->s6_addr32[1] == 0 && __a->s6_addr32[2] == 0 && ntohl (__a->s6_addr32[3]) > 1; }))
#define IN6_ARE_ADDR_EQUAL(a,b) (__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); const struct in6_addr *__b = (const struct in6_addr *) (b); __a->s6_addr32[0] == __b->s6_addr32[0] && __a->s6_addr32[1] == __b->s6_addr32[1] && __a->s6_addr32[2] == __b->s6_addr32[2] && __a->s6_addr32[3] == __b->s6_addr32[3]; }))
#define IN6_IS_ADDR_MULTICAST(a) (((const uint8_t *) (a))[0] == 0xff)
extern int bindresvport (int __sockfd, struct sockaddr_in *__sock_in) throw ();
extern int bindresvport6 (int __sockfd, struct sockaddr_in6 *__sock_in)
throw ();
#define IN6_IS_ADDR_MC_NODELOCAL(a) (IN6_IS_ADDR_MULTICAST(a) && ((((const uint8_t *) (a))[1] & 0xf) == 0x1))
#define IN6_IS_ADDR_MC_LINKLOCAL(a) (IN6_IS_ADDR_MULTICAST(a) && ((((const uint8_t *) (a))[1] & 0xf) == 0x2))
#define IN6_IS_ADDR_MC_SITELOCAL(a) (IN6_IS_ADDR_MULTICAST(a) && ((((const uint8_t *) (a))[1] & 0xf) == 0x5))
#define IN6_IS_ADDR_MC_ORGLOCAL(a) (IN6_IS_ADDR_MULTICAST(a) && ((((const uint8_t *) (a))[1] & 0xf) == 0x8))
#define IN6_IS_ADDR_MC_GLOBAL(a) (IN6_IS_ADDR_MULTICAST(a) && ((((const uint8_t *) (a))[1] & 0xf) == 0xe))
struct cmsghdr;
struct in6_pktinfo
{
struct in6_addr ipi6_addr;
unsigned int ipi6_ifindex;
};
struct ip6_mtuinfo
{
struct sockaddr_in6 ip6m_addr;
uint32_t ip6m_mtu;
};
extern int inet6_option_space (int __nbytes)
throw () __attribute__ ((__deprecated__));
extern int inet6_option_init (void *__bp, struct cmsghdr **__cmsgp,
int __type) throw () __attribute__ ((__deprecated__));
extern int inet6_option_append (struct cmsghdr *__cmsg,
const uint8_t *__typep, int __multx,
int __plusy) throw () __attribute__ ((__deprecated__));
extern uint8_t *inet6_option_alloc (struct cmsghdr *__cmsg, int __datalen,
int __multx, int __plusy)
throw () __attribute__ ((__deprecated__));
extern int inet6_option_next (const struct cmsghdr *__cmsg,
uint8_t **__tptrp)
throw () __attribute__ ((__deprecated__));
extern int inet6_option_find (const struct cmsghdr *__cmsg,
uint8_t **__tptrp, int __type)
throw () __attribute__ ((__deprecated__));
extern int inet6_opt_init (void *__extbuf, socklen_t __extlen) throw ();
extern int inet6_opt_append (void *__extbuf, socklen_t __extlen, int __offset,
uint8_t __type, socklen_t __len, uint8_t __align,
void **__databufp) throw ();
extern int inet6_opt_finish (void *__extbuf, socklen_t __extlen, int __offset)
throw ();
extern int inet6_opt_set_val (void *__databuf, int __offset, void *__val,
socklen_t __vallen) throw ();
extern int inet6_opt_next (void *__extbuf, socklen_t __extlen, int __offset,
uint8_t *__typep, socklen_t *__lenp,
void **__databufp) throw ();
extern int inet6_opt_find (void *__extbuf, socklen_t __extlen, int __offset,
uint8_t __type, socklen_t *__lenp,
void **__databufp) throw ();
extern int inet6_opt_get_val (void *__databuf, int __offset, void *__val,
socklen_t __vallen) throw ();
extern socklen_t inet6_rth_space (int __type, int __segments) throw ();
extern void *inet6_rth_init (void *__bp, socklen_t __bp_len, int __type,
int __segments) throw ();
extern int inet6_rth_add (void *__bp, const struct in6_addr *__addr) throw ();
extern int inet6_rth_reverse (const void *__in, void *__out) throw ();
extern int inet6_rth_segments (const void *__bp) throw ();
extern struct in6_addr *inet6_rth_getaddr (const void *__bp, int __index)
throw ();
extern int getipv4sourcefilter (int __s, struct in_addr __interface_addr,
struct in_addr __group, uint32_t *__fmode,
uint32_t *__numsrc, struct in_addr *__slist)
throw ();
extern int setipv4sourcefilter (int __s, struct in_addr __interface_addr,
struct in_addr __group, uint32_t __fmode,
uint32_t __numsrc,
const struct in_addr *__slist)
throw ();
extern int getsourcefilter (int __s, uint32_t __interface_addr,
const struct sockaddr *__group,
socklen_t __grouplen, uint32_t *__fmode,
uint32_t *__numsrc,
struct sockaddr_storage *__slist) throw ();
extern int setsourcefilter (int __s, uint32_t __interface_addr,
const struct sockaddr *__group,
socklen_t __grouplen, uint32_t __fmode,
uint32_t __numsrc,
const struct sockaddr_storage *__slist) throw ();
}
#define _RPC_NETDB_H 1
#define __need_size_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
extern "C" {
struct rpcent
{
char *r_name;
char **r_aliases;
int r_number;
};
extern void setrpcent (int __stayopen) throw ();
extern void endrpcent (void) throw ();
extern struct rpcent *getrpcbyname (const char *__name) throw ();
extern struct rpcent *getrpcbynumber (int __number) throw ();
extern struct rpcent *getrpcent (void) throw ();
extern int getrpcbyname_r (const char *__name, struct rpcent *__result_buf,
char *__buffer, size_t __buflen,
struct rpcent **__result) throw ();
extern int getrpcbynumber_r (int __number, struct rpcent *__result_buf,
char *__buffer, size_t __buflen,
struct rpcent **__result) throw ();
extern int getrpcent_r (struct rpcent *__result_buf, char *__buffer,
size_t __buflen, struct rpcent **__result) throw ();
}
#define __need_sigevent_t
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
#define __have_sigval_t 1
typedef union sigval
{
int sival_int;
void *sival_ptr;
} sigval_t;
#define __have_sigevent_t 1
#define __SIGEV_MAX_SIZE 64
#define __SIGEV_PAD_SIZE ((__SIGEV_MAX_SIZE / sizeof (int)) - 4)
typedef struct sigevent
{
sigval_t sigev_value;
int sigev_signo;
int sigev_notify;
union
{
int _pad[((64 / sizeof (int)) - 4)];
__pid_t _tid;
struct
{
void (*_function) (sigval_t);
pthread_attr_t *_attribute;
} _sigev_thread;
} _sigev_un;
} sigevent_t;
#define sigev_notify_function _sigev_un._sigev_thread._function
#define sigev_notify_attributes _sigev_un._sigev_thread._attribute
enum
{
SIGEV_SIGNAL = 0,
#define SIGEV_SIGNAL SIGEV_SIGNAL
SIGEV_NONE,
#define SIGEV_NONE SIGEV_NONE
SIGEV_THREAD,
#define SIGEV_THREAD SIGEV_THREAD
SIGEV_THREAD_ID = 4
#define SIGEV_THREAD_ID SIGEV_THREAD_ID
};
#define __need_timespec
struct netent
{
char *n_name;
char **n_aliases;
int n_addrtype;
uint32_t n_net;
};
#define _PATH_HEQUIV "/etc/hosts.equiv"
#define _PATH_HOSTS "/etc/hosts"
#define _PATH_NETWORKS "/etc/networks"
#define _PATH_NSSWITCH_CONF "/etc/nsswitch.conf"
#define _PATH_PROTOCOLS "/etc/protocols"
#define _PATH_SERVICES "/etc/services"
extern "C" {
#define h_errno (*__h_errno_location ())
extern int *__h_errno_location (void) throw () __attribute__ ((__const__));
#define HOST_NOT_FOUND 1
#define TRY_AGAIN 2
#define NO_RECOVERY 3
#define NO_DATA 4
#define NETDB_INTERNAL -1
#define NETDB_SUCCESS 0
#define NO_ADDRESS NO_DATA
#define IPPORT_RESERVED 1024
#define SCOPE_DELIMITER '%'
extern void herror (const char *__str) throw ();
extern const char *hstrerror (int __err_num) throw ();
struct hostent
{
char *h_name;
char **h_aliases;
int h_addrtype;
int h_length;
char **h_addr_list;
#define h_addr h_addr_list[0]
};
extern void sethostent (int __stay_open);
extern void endhostent (void);
extern struct hostent *gethostent (void);
extern struct hostent *gethostbyaddr (const void *__addr, __socklen_t __len,
int __type);
extern struct hostent *gethostbyname (const char *__name);
extern struct hostent *gethostbyname2 (const char *__name, int __af);
extern int gethostent_r (struct hostent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct hostent **__restrict __result,
int *__restrict __h_errnop);
extern int gethostbyaddr_r (const void *__restrict __addr, __socklen_t __len,
int __type,
struct hostent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct hostent **__restrict __result,
int *__restrict __h_errnop);
extern int gethostbyname_r (const char *__restrict __name,
struct hostent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct hostent **__restrict __result,
int *__restrict __h_errnop);
extern int gethostbyname2_r (const char *__restrict __name, int __af,
struct hostent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct hostent **__restrict __result,
int *__restrict __h_errnop);
extern void setnetent (int __stay_open);
extern void endnetent (void);
extern struct netent *getnetent (void);
extern struct netent *getnetbyaddr (uint32_t __net, int __type);
extern struct netent *getnetbyname (const char *__name);
extern int getnetent_r (struct netent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct netent **__restrict __result,
int *__restrict __h_errnop);
extern int getnetbyaddr_r (uint32_t __net, int __type,
struct netent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct netent **__restrict __result,
int *__restrict __h_errnop);
extern int getnetbyname_r (const char *__restrict __name,
struct netent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct netent **__restrict __result,
int *__restrict __h_errnop);
struct servent
{
char *s_name;
char **s_aliases;
int s_port;
char *s_proto;
};
extern void setservent (int __stay_open);
extern void endservent (void);
extern struct servent *getservent (void);
extern struct servent *getservbyname (const char *__name, const char *__proto);
extern struct servent *getservbyport (int __port, const char *__proto);
extern int getservent_r (struct servent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct servent **__restrict __result);
extern int getservbyname_r (const char *__restrict __name,
const char *__restrict __proto,
struct servent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct servent **__restrict __result);
extern int getservbyport_r (int __port, const char *__restrict __proto,
struct servent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct servent **__restrict __result);
struct protoent
{
char *p_name;
char **p_aliases;
int p_proto;
};
extern void setprotoent (int __stay_open);
extern void endprotoent (void);
extern struct protoent *getprotoent (void);
extern struct protoent *getprotobyname (const char *__name);
extern struct protoent *getprotobynumber (int __proto);
extern int getprotoent_r (struct protoent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct protoent **__restrict __result);
extern int getprotobyname_r (const char *__restrict __name,
struct protoent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct protoent **__restrict __result);
extern int getprotobynumber_r (int __proto,
struct protoent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct protoent **__restrict __result);
extern int setnetgrent (const char *__netgroup);
extern void endnetgrent (void);
extern int getnetgrent (char **__restrict __hostp,
char **__restrict __userp,
char **__restrict __domainp);
extern int innetgr (const char *__netgroup, const char *__host,
const char *__user, const char *__domain);
extern int getnetgrent_r (char **__restrict __hostp,
char **__restrict __userp,
char **__restrict __domainp,
char *__restrict __buffer, size_t __buflen);
extern int rcmd (char **__restrict __ahost, unsigned short int __rport,
const char *__restrict __locuser,
const char *__restrict __remuser,
const char *__restrict __cmd, int *__restrict __fd2p);
extern int rcmd_af (char **__restrict __ahost, unsigned short int __rport,
const char *__restrict __locuser,
const char *__restrict __remuser,
const char *__restrict __cmd, int *__restrict __fd2p,
sa_family_t __af);
extern int rexec (char **__restrict __ahost, int __rport,
const char *__restrict __name,
const char *__restrict __pass,
const char *__restrict __cmd, int *__restrict __fd2p);
extern int rexec_af (char **__restrict __ahost, int __rport,
const char *__restrict __name,
const char *__restrict __pass,
const char *__restrict __cmd, int *__restrict __fd2p,
sa_family_t __af);
extern int ruserok (const char *__rhost, int __suser,
const char *__remuser, const char *__locuser);
extern int ruserok_af (const char *__rhost, int __suser,
const char *__remuser, const char *__locuser,
sa_family_t __af);
extern int iruserok (uint32_t __raddr, int __suser,
const char *__remuser, const char *__locuser);
extern int iruserok_af (const void *__raddr, int __suser,
const char *__remuser, const char *__locuser,
sa_family_t __af);
extern int rresvport (int *__alport);
extern int rresvport_af (int *__alport, sa_family_t __af);
struct addrinfo
{
int ai_flags;
int ai_family;
int ai_socktype;
int ai_protocol;
socklen_t ai_addrlen;
struct sockaddr *ai_addr;
char *ai_canonname;
struct addrinfo *ai_next;
};
struct gaicb
{
const char *ar_name;
const char *ar_service;
const struct addrinfo *ar_request;
struct addrinfo *ar_result;
int __return;
int __glibc_reserved[5];
};
#define GAI_WAIT 0
#define GAI_NOWAIT 1
#define AI_PASSIVE 0x0001
#define AI_CANONNAME 0x0002
#define AI_NUMERICHOST 0x0004
#define AI_V4MAPPED 0x0008
#define AI_ALL 0x0010
#define AI_ADDRCONFIG 0x0020
#define AI_IDN 0x0040
#define AI_CANONIDN 0x0080
#define AI_IDN_ALLOW_UNASSIGNED 0x0100
#define AI_IDN_USE_STD3_ASCII_RULES 0x0200
#define AI_NUMERICSERV 0x0400
#define EAI_BADFLAGS -1
#define EAI_NONAME -2
#define EAI_AGAIN -3
#define EAI_FAIL -4
#define EAI_FAMILY -6
#define EAI_SOCKTYPE -7
#define EAI_SERVICE -8
#define EAI_MEMORY -10
#define EAI_SYSTEM -11
#define EAI_OVERFLOW -12
#define EAI_NODATA -5
#define EAI_ADDRFAMILY -9
#define EAI_INPROGRESS -100
#define EAI_CANCELED -101
#define EAI_NOTCANCELED -102
#define EAI_ALLDONE -103
#define EAI_INTR -104
#define EAI_IDN_ENCODE -105
#define NI_MAXHOST 1025
#define NI_MAXSERV 32
#define NI_NUMERICHOST 1
#define NI_NUMERICSERV 2
#define NI_NOFQDN 4
#define NI_NAMEREQD 8
#define NI_DGRAM 16
#define NI_IDN 32
#define NI_IDN_ALLOW_UNASSIGNED 64
#define NI_IDN_USE_STD3_ASCII_RULES 128
extern int getaddrinfo (const char *__restrict __name,
const char *__restrict __service,
const struct addrinfo *__restrict __req,
struct addrinfo **__restrict __pai);
extern void freeaddrinfo (struct addrinfo *__ai) throw ();
extern const char *gai_strerror (int __ecode) throw ();
extern int getnameinfo (const struct sockaddr *__restrict __sa,
socklen_t __salen, char *__restrict __host,
socklen_t __hostlen, char *__restrict __serv,
socklen_t __servlen, int __flags);
extern int getaddrinfo_a (int __mode, struct gaicb *__list[],
int __ent, struct sigevent *__restrict __sig);
extern int gai_suspend (const struct gaicb *const __list[], int __ent,
const struct timespec *__timeout);
extern int gai_error (struct gaicb *__req) throw ();
extern int gai_cancel (struct gaicb *__gaicbp) throw ();
}
#define BOOST_ASIO_NATIVE_ERROR(e) e
#define BOOST_ASIO_SOCKET_ERROR(e) e
#define BOOST_ASIO_NETDB_ERROR(e) e
#define BOOST_ASIO_GETADDRINFO_ERROR(e) e
#define BOOST_ASIO_WIN_OR_POSIX(e_win,e_posix) e_posix
namespace boost {
namespace asio {
namespace error {
enum basic_errors
{
access_denied = 13,
address_family_not_supported = 97,
address_in_use = 98,
already_connected = 106,
already_started = 114,
broken_pipe = 32,
connection_aborted = 103,
connection_refused = 111,
connection_reset = 104,
bad_descriptor = 9,
fault = 14,
host_unreachable = 113,
in_progress = 115,
interrupted = 4,
invalid_argument = 22,
message_size = 90,
name_too_long = 36,
network_down = 100,
network_reset = 102,
network_unreachable = 101,
no_descriptors = 24,
no_buffer_space = 105,
no_memory = 12,
no_permission = 1,
no_protocol_option = 92,
not_connected = 107,
not_socket = 88,
operation_aborted = 125,
operation_not_supported = 95,
shut_down = 108,
timed_out = 110,
try_again = 11,
would_block = 11
};
enum netdb_errors
{
host_not_found = 1,
host_not_found_try_again = 2,
no_data = 4,
no_recovery = 3
};
enum addrinfo_errors
{
service_not_found = -8,
socket_type_not_supported = -7
};
enum misc_errors
{
already_open = 1,
eof,
not_found,
fd_set_failure
};
const boost::system::error_category& get_system_category()
;
extern inline
const boost::system::error_category& get_netdb_category();
extern inline
const boost::system::error_category& get_addrinfo_category();
extern inline
const boost::system::error_category& get_misc_category();
static const boost::system::error_category& system_category
= boost::asio::error::get_system_category();
static const boost::system::error_category& netdb_category
= boost::asio::error::get_netdb_category();
static const boost::system::error_category& addrinfo_category
= boost::asio::error::get_addrinfo_category();
static const boost::system::error_category& misc_category
= boost::asio::error::get_misc_category();
}
}
}
namespace boost {
namespace system {
template<> struct is_error_code_enum<boost::asio::error::basic_errors>
{
static const bool value = true;
};
template<> struct is_error_code_enum<boost::asio::error::netdb_errors>
{
static const bool value = true;
};
template<> struct is_error_code_enum<boost::asio::error::addrinfo_errors>
{
static const bool value = true;
};
template<> struct is_error_code_enum<boost::asio::error::misc_errors>
{
static const bool value = true;
};
}
}
namespace boost {
namespace asio {
namespace error {
boost::system::error_code make_error_code(basic_errors e)
;
boost::system::error_code make_error_code(netdb_errors e)
;
boost::system::error_code make_error_code(addrinfo_errors e)
;
boost::system::error_code make_error_code(misc_errors e)
;
}
}
}
#undef BOOST_ASIO_NATIVE_ERROR
#undef BOOST_ASIO_SOCKET_ERROR
#undef BOOST_ASIO_NETDB_ERROR
#undef BOOST_ASIO_GETADDRINFO_ERROR
#undef BOOST_ASIO_WIN_OR_POSIX
#define BOOST_ASIO_IMPL_ERROR_IPP
namespace boost {
namespace asio {
namespace error {
namespace detail {
class netdb_category : public boost::system::error_category
{
public:
const char* name() const noexcept
{
return "asio.netdb";
}
std::string message(int value) const
{
if (value == error::host_not_found)
return "Host not found (authoritative)";
if (value == error::host_not_found_try_again)
return "Host not found (non-authoritative), try again later";
if (value == error::no_data)
return "The query is valid, but it does not have associated data";
if (value == error::no_recovery)
return "A non-recoverable error occurred during database lookup";
return "asio.netdb error";
}
};
}
const boost::system::error_category& get_netdb_category()
;
namespace detail {
class addrinfo_category : public boost::system::error_category
{
public:
const char* name() const noexcept
{
return "asio.addrinfo";
}
std::string message(int value) const
{
if (value == error::service_not_found)
return "Service not found";
if (value == error::socket_type_not_supported)
return "Socket type not supported";
return "asio.addrinfo error";
}
};
}
const boost::system::error_category& get_addrinfo_category()
;
namespace detail {
class misc_category : public boost::system::error_category
{
public:
const char* name() const noexcept
{
return "asio.misc";
}
std::string message(int value) const
{
if (value == error::already_open)
return "Already open";
if (value == error::eof)
return "End of file";
if (value == error::not_found)
return "Element not found";
if (value == error::fd_set_failure)
return "The descriptor does not fit into the select call's fd_set";
return "asio.misc error";
}
};
}
const boost::system::error_category& get_misc_category()
;
}
}
}
namespace boost {
namespace asio {
namespace detail {
}
}
}
namespace boost {
namespace asio {
namespace detail {
typedef posix_event event;
}
}
}
#define BOOST_ASIO_DETAIL_OP_QUEUE_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Operation>
class op_queue;
class op_queue_access
{
public:
template <typename Operation>
static Operation* next(Operation* o)
;
template <typename Operation1, typename Operation2>
static void next(Operation1*& o1, Operation2* o2)
;
template <typename Operation>
static void destroy(Operation* o)
;
template <typename Operation>
static Operation*& front(op_queue<Operation>& q)
;
template <typename Operation>
static Operation*& back(op_queue<Operation>& q)
;
};
template <typename Operation>
class op_queue
: private noncopyable
{
public:
op_queue()
;
~op_queue()
;
Operation* front()
;
void pop()
;
void push(Operation* h)
;
template <typename OtherOperation>
void push(op_queue<OtherOperation>& q)
;
bool empty() const
;
private:
friend class op_queue_access;
Operation* front_;
Operation* back_;
};
}
}
}
#define BOOST_ASIO_DETAIL_THREAD_INFO_BASE_HPP
#define _GCC_LIMITS_H_
#define _GCC_NEXT_LIMITS_H
#define _LIBC_LIMITS_H_ 1
#define MB_LEN_MAX 16
#define LLONG_MIN (-LLONG_MAX-1)
#define LLONG_MAX __LONG_LONG_MAX__
#define ULLONG_MAX (LLONG_MAX * 2ULL + 1)
#define _BITS_POSIX1_LIM_H 1
#define _POSIX_AIO_LISTIO_MAX 2
#define _POSIX_AIO_MAX 1
#define _POSIX_ARG_MAX 4096
#define _POSIX_CHILD_MAX 25
#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_FD_SETSIZE _POSIX_OPEN_MAX
#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_SYMLINK_MAX 255
#define _POSIX_SYMLOOP_MAX 8
#define _POSIX_TIMER_MAX 32
#define _POSIX_TTY_NAME_MAX 9
#define _POSIX_TZNAME_MAX 6
#define _POSIX_QLIMIT 1
#define _POSIX_HIWAT _POSIX_PIPE_BUF
#define _POSIX_UIO_MAXIOV 16
#define _POSIX_CLOCKRES_MIN 20000000
#define __undef_NR_OPEN
#define __undef_LINK_MAX
#define __undef_OPEN_MAX
#define __undef_ARG_MAX
#define _LINUX_LIMITS_H
#define NR_OPEN 1024
#define NGROUPS_MAX 65536
#define ARG_MAX 131072
#define LINK_MAX 127
#define MAX_CANON 255
#define MAX_INPUT 255
#define NAME_MAX 255
#define PATH_MAX 4096
#define PIPE_BUF 4096
#define XATTR_NAME_MAX 255
#define XATTR_SIZE_MAX 65536
#define XATTR_LIST_MAX 65536
#define RTSIG_MAX 32
#undef NR_OPEN
#undef __undef_NR_OPEN
#undef LINK_MAX
#undef __undef_LINK_MAX
#undef OPEN_MAX
#undef __undef_OPEN_MAX
#undef ARG_MAX
#undef __undef_ARG_MAX
#define _POSIX_THREAD_KEYS_MAX 128
#define PTHREAD_KEYS_MAX 1024
#define _POSIX_THREAD_DESTRUCTOR_ITERATIONS 4
#define PTHREAD_DESTRUCTOR_ITERATIONS _POSIX_THREAD_DESTRUCTOR_ITERATIONS
#define _POSIX_THREAD_THREADS_MAX 64
#undef PTHREAD_THREADS_MAX
#define AIO_PRIO_DELTA_MAX 20
#define PTHREAD_STACK_MIN 16384
#define DELAYTIMER_MAX 2147483647
#define TTY_NAME_MAX 32
#define LOGIN_NAME_MAX 256
#define HOST_NAME_MAX 64
#define MQ_PRIO_MAX 32768
#define SEM_VALUE_MAX (2147483647)
#define SSIZE_MAX LONG_MAX
#define _BITS_POSIX2_LIM_H 1
#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_COLL_WEIGHTS_MAX 2
#define _POSIX2_EXPR_NEST_MAX 32
#define _POSIX2_LINE_MAX 2048
#define _POSIX2_RE_DUP_MAX 255
#define _POSIX2_CHARCLASS_NAME_MAX 14
#define BC_BASE_MAX _POSIX2_BC_BASE_MAX
#define BC_DIM_MAX _POSIX2_BC_DIM_MAX
#define BC_SCALE_MAX _POSIX2_BC_SCALE_MAX
#define BC_STRING_MAX _POSIX2_BC_STRING_MAX
#define COLL_WEIGHTS_MAX 255
#define EXPR_NEST_MAX _POSIX2_EXPR_NEST_MAX
#define LINE_MAX _POSIX2_LINE_MAX
#define CHARCLASS_NAME_MAX 2048
#define RE_DUP_MAX (0x7fff)
#define _XOPEN_LIM_H 1
#define __need_IOV_MAX
#define L_tmpnam 20
#define TMP_MAX 238328
#define FILENAME_MAX 4096
#define L_ctermid 9
#define L_cuserid 9
#undef FOPEN_MAX
#define FOPEN_MAX 16
#define IOV_MAX 1024
#define _XOPEN_IOV_MAX _POSIX_UIO_MAXIOV
#define NL_ARGMAX _POSIX_ARG_MAX
#define NL_LANGMAX _POSIX2_LINE_MAX
#define NL_MSGMAX INT_MAX
#define NL_NMAX INT_MAX
#define NL_SETMAX INT_MAX
#define NL_TEXTMAX INT_MAX
#define NZERO 20
#define WORD_BIT 32
#define LONG_BIT 64
#undef _GCC_NEXT_LIMITS_H
#define _LIMITS_H___
#undef CHAR_BIT
#define CHAR_BIT __CHAR_BIT__
#undef SCHAR_MIN
#define SCHAR_MIN (-SCHAR_MAX - 1)
#undef SCHAR_MAX
#define SCHAR_MAX __SCHAR_MAX__
#undef UCHAR_MAX
#define UCHAR_MAX (SCHAR_MAX * 2 + 1)
#undef CHAR_MIN
#define CHAR_MIN SCHAR_MIN
#undef CHAR_MAX
#define CHAR_MAX SCHAR_MAX
#undef SHRT_MIN
#define SHRT_MIN (-SHRT_MAX - 1)
#undef SHRT_MAX
#define SHRT_MAX __SHRT_MAX__
#undef USHRT_MAX
#define USHRT_MAX (SHRT_MAX * 2 + 1)
#undef INT_MIN
#define INT_MIN (-INT_MAX - 1)
#undef INT_MAX
#define INT_MAX __INT_MAX__
#undef UINT_MAX
#define UINT_MAX (INT_MAX * 2U + 1U)
#undef LONG_MIN
#define LONG_MIN (-LONG_MAX - 1L)
#undef LONG_MAX
#define LONG_MAX __LONG_MAX__
#undef ULONG_MAX
#define ULONG_MAX (LONG_MAX * 2UL + 1UL)
#undef LONG_LONG_MIN
#define LONG_LONG_MIN (-LONG_LONG_MAX - 1LL)
#undef LONG_LONG_MAX
#define LONG_LONG_MAX __LONG_LONG_MAX__
#undef ULONG_LONG_MAX
#define ULONG_LONG_MAX (LONG_LONG_MAX * 2ULL + 1ULL)
#define _GLIBCXX_CLIMITS 1
namespace boost {
namespace asio {
namespace detail {
class thread_info_base
: private noncopyable
{
public:
thread_info_base()
;
~thread_info_base()
;
static void* allocate(thread_info_base* this_thread, std::size_t size)
;
static void deallocate(thread_info_base* this_thread,
void* pointer, std::size_t size)
;
private:
void* reusable_memory_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
class task_io_service;
class task_io_service_operation;
struct task_io_service_thread_info : public thread_info_base
{
event* wakeup_event;
op_queue<task_io_service_operation> private_op_queue;
long private_outstanding_work;
task_io_service_thread_info* next;
};
}
}
}
namespace boost {
namespace asio {
void* asio_handler_allocate(std::size_t size, ...)
;
void asio_handler_deallocate(void* pointer, std::size_t size, ...)
;
}
}
namespace boost_asio_handler_alloc_helpers {
template <typename Handler>
void* allocate(std::size_t s, Handler& h)
;
template <typename Handler>
void deallocate(void* p, std::size_t s, Handler& h)
;
}
#define BOOST_ASIO_DEFINE_HANDLER_PTR(op) struct ptr { Handler* h; void* v; op* p; ~ptr() { reset(); } void reset() { if (p) { p->~op(); p = 0; } if (v) { boost_asio_handler_alloc_helpers::deallocate(v, sizeof(op), *h); v = 0; } } }
#define BOOST_ASIO_DETAIL_HANDLER_CONT_HELPERS_HPP
#define BOOST_ASIO_HANDLER_CONTINUATION_HOOK_HPP
namespace boost {
namespace asio {
bool asio_handler_is_continuation(...)
;
}
}
namespace boost_asio_handler_cont_helpers {
template <typename Context>
bool is_continuation(Context& context)
;
}
#define BOOST_ASIO_DETAIL_HANDLER_INVOKE_HELPERS_HPP
#define BOOST_ASIO_HANDLER_INVOKE_HOOK_HPP
namespace boost {
namespace asio {
template <typename Function>
void asio_handler_invoke(Function& function, ...)
;
template <typename Function>
void asio_handler_invoke(const Function& function, ...)
;
}
}
namespace boost_asio_handler_invoke_helpers {
template <typename Function, typename Context>
void invoke(Function& function, Context& context)
;
template <typename Function, typename Context>
void invoke(const Function& function, Context& context)
;
}
namespace boost {
namespace asio {
namespace detail {
template <typename Handler, typename Arg1>
class binder1
{
public:
binder1(const Handler& handler, const Arg1& arg1)
;
binder1(Handler& handler, const Arg1& arg1)
;
void operator()()
;
void operator()() const
;
Handler handler_;
Arg1 arg1_;
};
template <typename Handler, typename Arg1>
void* asio_handler_allocate(std::size_t size,
binder1<Handler, Arg1>* this_handler)
;
template <typename Handler, typename Arg1>
void asio_handler_deallocate(void* pointer, std::size_t size,
binder1<Handler, Arg1>* this_handler)
;
template <typename Handler, typename Arg1>
inline bool asio_handler_is_continuation(
binder1<Handler, Arg1>* this_handler)
{
return boost_asio_handler_cont_helpers::is_continuation(
this_handler->handler_);
}
template <typename Function, typename Handler, typename Arg1>
inline void asio_handler_invoke(Function& function,
binder1<Handler, Arg1>* this_handler)
{
boost_asio_handler_invoke_helpers::invoke(
function, this_handler->handler_);
}
template <typename Function, typename Handler, typename Arg1>
inline void asio_handler_invoke(const Function& function,
binder1<Handler, Arg1>* this_handler)
{
boost_asio_handler_invoke_helpers::invoke(
function, this_handler->handler_);
}
template <typename Handler, typename Arg1>
inline binder1<Handler, Arg1> bind_handler(Handler handler,
const Arg1& arg1)
{
return binder1<Handler, Arg1>(handler, arg1);
}
template <typename Handler, typename Arg1, typename Arg2>
class binder2
{
public:
binder2(const Handler& handler, const Arg1& arg1, const Arg2& arg2)
;
binder2(Handler& handler, const Arg1& arg1, const Arg2& arg2)
;
void operator()()
;
void operator()() const
;
Handler handler_;
Arg1 arg1_;
Arg2 arg2_;
};
template <typename Handler, typename Arg1, typename Arg2>
void* asio_handler_allocate(std::size_t size,
binder2<Handler, Arg1, Arg2>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2>
void asio_handler_deallocate(void* pointer, std::size_t size,
binder2<Handler, Arg1, Arg2>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2>
bool asio_handler_is_continuation(
binder2<Handler, Arg1, Arg2>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2>
void asio_handler_invoke(Function& function,
binder2<Handler, Arg1, Arg2>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2>
void asio_handler_invoke(const Function& function,
binder2<Handler, Arg1, Arg2>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2>
binder2<Handler, Arg1, Arg2> bind_handler(Handler handler,
const Arg1& arg1, const Arg2& arg2)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
class binder3
{
public:
binder3(const Handler& handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3)
;
binder3(Handler& handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3)
;
void operator()()
;
void operator()() const
;
Handler handler_;
Arg1 arg1_;
Arg2 arg2_;
Arg3 arg3_;
};
template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
void* asio_handler_allocate(std::size_t size,
binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
void asio_handler_deallocate(void* pointer, std::size_t size,
binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
bool asio_handler_is_continuation(
binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2,
typename Arg3>
void asio_handler_invoke(Function& function,
binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2,
typename Arg3>
void asio_handler_invoke(const Function& function,
binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
binder3<Handler, Arg1, Arg2, Arg3> bind_handler(Handler handler,
const Arg1& arg1, const Arg2& arg2, const Arg3& arg3)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4>
class binder4
{
public:
binder4(const Handler& handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3, const Arg4& arg4)
;
binder4(Handler& handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3, const Arg4& arg4)
;
void operator()()
;
void operator()() const
;
Handler handler_;
Arg1 arg1_;
Arg2 arg2_;
Arg3 arg3_;
Arg4 arg4_;
};
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4>
void* asio_handler_allocate(std::size_t size,
binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4>
void asio_handler_deallocate(void* pointer, std::size_t size,
binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4>
bool asio_handler_is_continuation(
binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2,
typename Arg3, typename Arg4>
void asio_handler_invoke(Function& function,
binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2,
typename Arg3, typename Arg4>
void asio_handler_invoke(const Function& function,
binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4>
binder4<Handler, Arg1, Arg2, Arg3, Arg4> bind_handler(
Handler handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3, const Arg4& arg4)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5>
class binder5
{
public:
binder5(const Handler& handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
;
binder5(Handler& handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
;
void operator()()
;
void operator()() const
;
Handler handler_;
Arg1 arg1_;
Arg2 arg2_;
Arg3 arg3_;
Arg4 arg4_;
Arg5 arg5_;
};
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5>
void* asio_handler_allocate(std::size_t size,
binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5>
void asio_handler_deallocate(void* pointer, std::size_t size,
binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5>
bool asio_handler_is_continuation(
binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2,
typename Arg3, typename Arg4, typename Arg5>
void asio_handler_invoke(Function& function,
binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2,
typename Arg3, typename Arg4, typename Arg5>
void asio_handler_invoke(const Function& function,
binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5>
binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5> bind_handler(
Handler handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
;
}
}
}
namespace boost {
namespace asio {
namespace detail {
struct is_continuation_delegated
{
template <typename Dispatcher, typename Handler>
bool operator()(Dispatcher&, Handler& handler) const
;
};
struct is_continuation_if_running
{
template <typename Dispatcher, typename Handler>
bool operator()(Dispatcher& dispatcher, Handler&) const
;
};
template <typename Dispatcher, typename Handler,
typename IsContinuation = is_continuation_delegated>
class wrapped_handler
{
public:
typedef void result_type;
wrapped_handler(Dispatcher dispatcher, Handler& handler)
;
wrapped_handler(const wrapped_handler& other)
;
wrapped_handler(wrapped_handler&& other)
;
void operator()()
;
void operator()() const
;
template <typename Arg1>
void operator()(const Arg1& arg1)
;
template <typename Arg1>
void operator()(const Arg1& arg1) const
;
template <typename Arg1, typename Arg2>
void operator()(const Arg1& arg1, const Arg2& arg2)
;
template <typename Arg1, typename Arg2>
void operator()(const Arg1& arg1, const Arg2& arg2) const
;
template <typename Arg1, typename Arg2, typename Arg3>
void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3)
;
template <typename Arg1, typename Arg2, typename Arg3>
void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3) const
;
template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
const Arg4& arg4)
;
template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
const Arg4& arg4) const
;
template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
typename Arg5>
void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
const Arg4& arg4, const Arg5& arg5)
;
template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
typename Arg5>
void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
const Arg4& arg4, const Arg5& arg5) const
;
Dispatcher dispatcher_;
Handler handler_;
};
template <typename Handler, typename Context>
class rewrapped_handler
{
public:
explicit rewrapped_handler(Handler& handler, const Context& context)
;
explicit rewrapped_handler(const Handler& handler, const Context& context)
;
rewrapped_handler(const rewrapped_handler& other)
;
rewrapped_handler(rewrapped_handler&& other)
;
void operator()()
;
void operator()() const
;
Context context_;
Handler handler_;
};
template <typename Dispatcher, typename Handler, typename IsContinuation>
void* asio_handler_allocate(std::size_t size,
wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
;
template <typename Dispatcher, typename Handler, typename IsContinuation>
void asio_handler_deallocate(void* pointer, std::size_t size,
wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
;
template <typename Dispatcher, typename Handler, typename IsContinuation>
bool asio_handler_is_continuation(
wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
;
template <typename Function, typename Dispatcher,
typename Handler, typename IsContinuation>
void asio_handler_invoke(Function& function,
wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
;
template <typename Function, typename Dispatcher,
typename Handler, typename IsContinuation>
void asio_handler_invoke(const Function& function,
wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
;
template <typename Handler, typename Context>
void* asio_handler_allocate(std::size_t size,
rewrapped_handler<Handler, Context>* this_handler)
;
template <typename Handler, typename Context>
void asio_handler_deallocate(void* pointer, std::size_t size,
rewrapped_handler<Handler, Context>* this_handler)
;
template <typename Dispatcher, typename Context>
bool asio_handler_is_continuation(
rewrapped_handler<Dispatcher, Context>* this_handler)
;
template <typename Function, typename Handler, typename Context>
void asio_handler_invoke(Function& function,
rewrapped_handler<Handler, Context>* this_handler)
;
template <typename Function, typename Handler, typename Context>
void asio_handler_invoke(const Function& function,
rewrapped_handler<Handler, Context>* this_handler)
;
}
}
}
namespace boost {
namespace asio {
class io_service;
template <typename Service> Service& use_service(io_service& ios);
template <typename Service> void add_service(io_service& ios, Service* svc);
template <typename Service> bool has_service(io_service& ios);
namespace detail {
typedef class task_io_service io_service_impl;
class service_registry;
}
class io_service
: private noncopyable
{
private:
typedef detail::io_service_impl impl_type;
public:
class work;
friend class work;
class id;
class service;
class strand;
inline io_service();
inline explicit io_service(std::size_t concurrency_hint);
inline ~io_service();
inline std::size_t run();
inline std::size_t run(boost::system::error_code& ec);
inline std::size_t run_one();
inline std::size_t run_one(boost::system::error_code& ec);
inline std::size_t poll();
inline std::size_t poll(boost::system::error_code& ec);
inline std::size_t poll_one();
inline std::size_t poll_one(boost::system::error_code& ec);
inline void stop();
inline bool stopped() const;
inline void reset();
template <typename CompletionHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<CompletionHandler, void ()>::type>::type
dispatch(CompletionHandler&& handler);
template <typename CompletionHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<CompletionHandler, void ()>::type>::type
post(CompletionHandler&& handler);
template <typename Handler>
detail::wrapped_handler<io_service&, Handler>
wrap(Handler handler);
enum fork_event
{
fork_prepare,
fork_parent,
fork_child
};
inline void notify_fork(boost::asio::io_service::fork_event event);
template <typename Service>
friend Service& use_service(io_service& ios);
template <typename Service>
friend void add_service(io_service& ios, Service* svc);
template <typename Service>
friend bool has_service(io_service& ios);
private:
boost::asio::detail::service_registry* service_registry_;
impl_type& impl_;
};
class io_service::work
{
public:
explicit work(boost::asio::io_service& io_service);
work(const work& other);
~work();
boost::asio::io_service& get_io_service();
private:
void operator=(const work& other);
detail::io_service_impl& io_service_impl_;
};
class io_service::id
: private noncopyable
{
public:
id() ;
};
class io_service::service
: private noncopyable
{
public:
boost::asio::io_service& get_io_service();
protected:
inline service(boost::asio::io_service& owner);
inline virtual ~service();
private:
virtual void shutdown_service() = 0;
inline virtual void fork_service(
boost::asio::io_service::fork_event event);
friend class boost::asio::detail::service_registry;
struct key
{
key() ;
const std::type_info* type_info_;
const boost::asio::io_service::id* id_;
} key_;
boost::asio::io_service& owner_;
service* next_;
};
class service_already_exists
: public std::logic_error
{
public:
inline service_already_exists();
};
class invalid_service_owner
: public std::logic_error
{
public:
inline invalid_service_owner();
};
namespace detail {
template <typename Type>
class service_id
: public boost::asio::io_service::id
{
};
template <typename Type>
class service_base
: public boost::asio::io_service::service
{
public:
static boost::asio::detail::service_id<Type> id;
service_base(boost::asio::io_service& io_service)
;
};
template <typename Type>
boost::asio::detail::service_id<Type> service_base<Type>::id;
}
}
}
#define BOOST_ASIO_IMPL_IO_SERVICE_HPP
#define BOOST_ASIO_DETAIL_HANDLER_TYPE_REQUIREMENTS_HPP
#define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS 1
#define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1
#define BOOST_ASIO_UNUSED_TYPEDEF __attribute__((__unused__))
namespace boost {
namespace asio {
namespace detail {
template <typename Handler>
auto zero_arg_handler_test(Handler h, void*)
-> decltype(
sizeof(Handler(static_cast<const Handler&>(h))),
((h)()),
char(0));
template <typename Handler>
char (&zero_arg_handler_test(Handler, ...))[2];
template <typename Handler, typename Arg1>
auto one_arg_handler_test(Handler h, Arg1* a1)
-> decltype(
sizeof(Handler(static_cast<const Handler&>(h))),
((h)(*a1)),
char(0));
template <typename Handler>
char (&one_arg_handler_test(Handler h, ...))[2];
template <typename Handler, typename Arg1, typename Arg2>
auto two_arg_handler_test(Handler h, Arg1* a1, Arg2* a2)
-> decltype(
sizeof(Handler(static_cast<const Handler&>(h))),
((h)(*a1, *a2)),
char(0));
template <typename Handler>
char (&two_arg_handler_test(Handler, ...))[2];
#define BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT(expr,msg) static_assert(expr, msg);
template <typename T> T& lvref();
template <typename T> T& lvref(T);
template <typename T> const T& clvref();
template <typename T> const T& clvref(T);
template <typename T> char argbyv(T);
template <int>
struct handler_type_requirements
{
};
#define BOOST_ASIO_COMPLETION_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void()) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::zero_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), 0)) == 1, "CompletionHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()(), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_READ_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code, std::size_t)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_WRITE_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code, std::size_t)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_ACCEPT_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "AcceptHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_CONNECT_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "ConnectHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK(handler_type,handler,iter_type) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code, iter_type)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const iter_type*>(0))) == 1, "ComposedConnectHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const iter_type>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_RESOLVE_HANDLER_CHECK(handler_type,handler,iter_type) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code, iter_type)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const iter_type*>(0))) == 1, "ResolveHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const iter_type>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_WAIT_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "WaitHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_SIGNAL_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code, int)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const int*>(0))) == 1, "SignalHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const int>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_HANDSHAKE_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "HandshakeHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_BUFFERED_HANDSHAKE_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code, std::size_t)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "BufferedHandshakeHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_SHUTDOWN_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "ShutdownHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
}
}
}
#define BOOST_ASIO_DETAIL_SERVICE_REGISTRY_HPP
#define BOOST_ASIO_DETAIL_MUTEX_HPP
#define BOOST_ASIO_DETAIL_POSIX_MUTEX_HPP
#define BOOST_ASIO_DETAIL_SCOPED_LOCK_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Mutex>
class scoped_lock
: private noncopyable
{
public:
enum adopt_lock_t { adopt_lock };
scoped_lock(Mutex& m, adopt_lock_t)
;
explicit scoped_lock(Mutex& m)
;
~scoped_lock()
;
void lock()
;
void unlock()
;
bool locked() const
;
Mutex& mutex()
;
private:
Mutex& mutex_;
bool locked_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
class posix_event;
class posix_mutex
: private noncopyable
{
public:
typedef boost::asio::detail::scoped_lock<posix_mutex> scoped_lock;
inline posix_mutex();
~posix_mutex()
;
void lock()
;
void unlock()
;
private:
friend class posix_event;
::pthread_mutex_t mutex_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_POSIX_MUTEX_IPP
namespace boost {
namespace asio {
namespace detail {
}
}
}
namespace boost {
namespace asio {
namespace detail {
typedef posix_mutex mutex;
}
}
}
namespace boost {
namespace asio {
namespace detail {
#pragma GCC visibility push (default)
template <typename T>
class typeid_wrapper {};
#pragma GCC visibility pop
class service_registry
: private noncopyable
{
public:
template <typename Service, typename Arg>
service_registry(boost::asio::io_service& o,
Service* initial_service, Arg arg);
inline ~service_registry();
inline void notify_fork(boost::asio::io_service::fork_event fork_ev);
template <typename Service>
Service& first_service();
template <typename Service>
Service& use_service();
template <typename Service>
void add_service(Service* new_service);
template <typename Service>
bool has_service() const;
private:
inline static void init_key(
boost::asio::io_service::service::key& key,
const boost::asio::io_service::id& id);
template <typename Service>
static void init_key(boost::asio::io_service::service::key& key,
const boost::asio::detail::service_id<Service>& );
inline static bool keys_match(
const boost::asio::io_service::service::key& key1,
const boost::asio::io_service::service::key& key2);
typedef boost::asio::io_service::service*
(*factory_type)(boost::asio::io_service&);
template <typename Service>
static boost::asio::io_service::service* create(
boost::asio::io_service& owner);
inline static void destroy(
boost::asio::io_service::service* service);
struct auto_service_ptr;
friend struct auto_service_ptr;
struct auto_service_ptr
{
boost::asio::io_service::service* ptr_;
~auto_service_ptr() ;
};
inline boost::asio::io_service::service* do_use_service(
const boost::asio::io_service::service::key& key,
factory_type factory);
inline void do_add_service(
const boost::asio::io_service::service::key& key,
boost::asio::io_service::service* new_service);
inline bool do_has_service(
const boost::asio::io_service::service::key& key) const;
mutable boost::asio::detail::mutex mutex_;
boost::asio::io_service& owner_;
boost::asio::io_service::service* first_service_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_SERVICE_REGISTRY_HPP
namespace boost {
namespace asio {
namespace detail {
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_SERVICE_REGISTRY_IPP
#define _GLIBCXX_VECTOR 1
#define _STL_VECTOR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp, typename _Alloc>
struct _Vector_base
{
typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
rebind<_Tp>::other _Tp_alloc_type;
typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer
pointer;
struct _Vector_impl
: public _Tp_alloc_type
{
pointer _M_start;
pointer _M_finish;
pointer _M_end_of_storage;
_Vector_impl()
;
_Vector_impl(_Tp_alloc_type const& __a) noexcept
: _Tp_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage()
{ }
_Vector_impl(_Tp_alloc_type&& __a) noexcept
: _Tp_alloc_type(std::move(__a)),
_M_start(), _M_finish(), _M_end_of_storage()
{ }
void _M_swap_data(_Vector_impl& __x) noexcept
{
std::swap(_M_start, __x._M_start);
std::swap(_M_finish, __x._M_finish);
std::swap(_M_end_of_storage, __x._M_end_of_storage);
}
};
public:
typedef _Alloc allocator_type;
_Tp_alloc_type&
_M_get_Tp_allocator() noexcept
{ return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
const _Tp_alloc_type&
_M_get_Tp_allocator() const noexcept
{ return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
allocator_type
get_allocator() const noexcept
{ return allocator_type(_M_get_Tp_allocator()); }
_Vector_base()
: _M_impl() { }
_Vector_base(const allocator_type& __a) noexcept
: _M_impl(__a) { }
_Vector_base(size_t __n)
: _M_impl()
{ _M_create_storage(__n); }
_Vector_base(size_t __n, const allocator_type& __a)
: _M_impl(__a)
{ _M_create_storage(__n); }
_Vector_base(_Tp_alloc_type&& __a) noexcept
: _M_impl(std::move(__a)) { }
_Vector_base(_Vector_base&& __x) noexcept
: _M_impl(std::move(__x._M_get_Tp_allocator()))
{ this->_M_impl._M_swap_data(__x._M_impl); }
_Vector_base(_Vector_base&& __x, const allocator_type& __a)
: _M_impl(__a)
{
if (__x.get_allocator() == __a)
this->_M_impl._M_swap_data(__x._M_impl);
else
{
size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start;
_M_create_storage(__n);
}
}
~_Vector_base() noexcept
{ _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage
- this->_M_impl._M_start); }
public:
_Vector_impl _M_impl;
pointer
_M_allocate(size_t __n)
;
void
_M_deallocate(pointer __p, size_t __n)
;
private:
void
_M_create_storage(size_t __n)
;
};
template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
class vector : protected _Vector_base<_Tp, _Alloc>
{
typedef typename _Alloc::value_type _Alloc_value_type;
typedef _Vector_base<_Tp, _Alloc> _Base;
typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;
public:
typedef _Tp value_type;
typedef typename _Base::pointer pointer;
typedef typename _Alloc_traits::const_pointer const_pointer;
typedef typename _Alloc_traits::reference reference;
typedef typename _Alloc_traits::const_reference const_reference;
typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
const_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef _Alloc allocator_type;
protected:
using _Base::_M_allocate;
using _Base::_M_deallocate;
using _Base::_M_impl;
using _Base::_M_get_Tp_allocator;
public:
vector()
noexcept(is_nothrow_default_constructible<_Alloc>::value)
: _Base() { }
explicit
vector(const allocator_type& __a) noexcept
: _Base(__a) { }
explicit
vector(size_type __n, const allocator_type& __a = allocator_type())
: _Base(__n, __a)
{ _M_default_initialize(__n); }
vector(size_type __n, const value_type& __value,
const allocator_type& __a = allocator_type())
: _Base(__n, __a)
{ _M_fill_initialize(__n, __value); }
vector(const vector& __x)
: _Base(__x.size(),
_Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
{ this->_M_impl._M_finish =
std::__uninitialized_copy_a(__x.begin(), __x.end(),
this->_M_impl._M_start,
_M_get_Tp_allocator());
}
vector(vector&& __x) noexcept
: _Base(std::move(__x)) { }
vector(const vector& __x, const allocator_type& __a)
: _Base(__x.size(), __a)
{ this->_M_impl._M_finish =
std::__uninitialized_copy_a(__x.begin(), __x.end(),
this->_M_impl._M_start,
_M_get_Tp_allocator());
}
vector(vector&& __rv, const allocator_type& __m)
noexcept(_Alloc_traits::_S_always_equal())
: _Base(std::move(__rv), __m)
{
if (__rv.get_allocator() != __m)
{
this->_M_impl._M_finish =
std::__uninitialized_move_a(__rv.begin(), __rv.end(),
this->_M_impl._M_start,
_M_get_Tp_allocator());
__rv.clear();
}
}
vector(initializer_list<value_type> __l,
const allocator_type& __a = allocator_type())
: _Base(__a)
{
_M_range_initialize(__l.begin(), __l.end(),
random_access_iterator_tag());
}
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
vector(_InputIterator __first, _InputIterator __last,
const allocator_type& __a = allocator_type())
: _Base(__a)
{ _M_initialize_dispatch(__first, __last, __false_type()); }
~vector() noexcept
{ std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator()); }
vector&
operator=(const vector& __x);
vector&
operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
{
constexpr bool __move_storage =
_Alloc_traits::_S_propagate_on_move_assign()
|| _Alloc_traits::_S_always_equal();
_M_move_assign(std::move(__x),
integral_constant<bool, __move_storage>());
return *this;
}
vector&
operator=(initializer_list<value_type> __l)
{
this->assign(__l.begin(), __l.end());
return *this;
}
void
assign(size_type __n, const value_type& __val)
{ _M_fill_assign(__n, __val); }
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
void
assign(_InputIterator __first, _InputIterator __last)
{ _M_assign_dispatch(__first, __last, __false_type()); }
void
assign(initializer_list<value_type> __l)
{ this->assign(__l.begin(), __l.end()); }
using _Base::get_allocator;
iterator
begin() noexcept
{ return iterator(this->_M_impl._M_start); }
const_iterator
begin() const noexcept
{ return const_iterator(this->_M_impl._M_start); }
iterator
end() noexcept
{ return iterator(this->_M_impl._M_finish); }
const_iterator
end() const noexcept
{ return const_iterator(this->_M_impl._M_finish); }
reverse_iterator
rbegin() noexcept
{ return reverse_iterator(end()); }
const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(end()); }
reverse_iterator
rend() noexcept
{ return reverse_iterator(begin()); }
const_reverse_iterator
rend() const noexcept
{ return const_reverse_iterator(begin()); }
const_iterator
cbegin() const noexcept
{ return const_iterator(this->_M_impl._M_start); }
const_iterator
cend() const noexcept
{ return const_iterator(this->_M_impl._M_finish); }
const_reverse_iterator
crbegin() const noexcept
{ return const_reverse_iterator(end()); }
const_reverse_iterator
crend() const noexcept
{ return const_reverse_iterator(begin()); }
size_type
size() const noexcept
{ return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
size_type
max_size() const noexcept
{ return _Alloc_traits::max_size(_M_get_Tp_allocator()); }
void
resize(size_type __new_size)
{
if (__new_size > size())
_M_default_append(__new_size - size());
else if (__new_size < size())
_M_erase_at_end(this->_M_impl._M_start + __new_size);
}
void
resize(size_type __new_size, const value_type& __x)
{
if (__new_size > size())
insert(end(), __new_size - size(), __x);
else if (__new_size < size())
_M_erase_at_end(this->_M_impl._M_start + __new_size);
}
void
shrink_to_fit()
{ _M_shrink_to_fit(); }
size_type
capacity() const noexcept
{ return size_type(this->_M_impl._M_end_of_storage
- this->_M_impl._M_start); }
bool
empty() const noexcept
{ return begin() == end(); }
void
reserve(size_type __n);
reference
operator[](size_type __n) noexcept
{ return *(this->_M_impl._M_start + __n); }
const_reference
operator[](size_type __n) const noexcept
{ return *(this->_M_impl._M_start + __n); }
protected:
void
_M_range_check(size_type __n) const
{
if (__n >= this->size())
__throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"),
__n, this->size());
}
public:
reference
at(size_type __n)
{
_M_range_check(__n);
return (*this)[__n];
}
const_reference
at(size_type __n) const
{
_M_range_check(__n);
return (*this)[__n];
}
reference
front() noexcept
{ return *begin(); }
const_reference
front() const noexcept
{ return *begin(); }
reference
back() noexcept
{ return *(end() - 1); }
const_reference
back() const noexcept
{ return *(end() - 1); }
_Tp*
data() noexcept
{ return _M_data_ptr(this->_M_impl._M_start); }
const _Tp*
data() const noexcept
{ return _M_data_ptr(this->_M_impl._M_start); }
void
push_back(const value_type& __x)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
__x);
++this->_M_impl._M_finish;
}
else
_M_emplace_back_aux(__x);
}
void
push_back(value_type&& __x)
{ emplace_back(std::move(__x)); }
template<typename... _Args>
void
emplace_back(_Args&&... __args);
void
pop_back() noexcept
{
--this->_M_impl._M_finish;
_Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
}
template<typename... _Args>
iterator
emplace(const_iterator __position, _Args&&... __args);
iterator
insert(const_iterator __position, const value_type& __x);
iterator
insert(const_iterator __position, value_type&& __x)
;
iterator
insert(const_iterator __position, initializer_list<value_type> __l)
;
iterator
insert(const_iterator __position, size_type __n, const value_type& __x)
;
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
iterator
insert(const_iterator __position, _InputIterator __first,
_InputIterator __last)
;
iterator
erase(const_iterator __position)
;
iterator
erase(const_iterator __first, const_iterator __last)
;
void
swap(vector& __x)
noexcept(_Alloc_traits::_S_nothrow_swap())
{
this->_M_impl._M_swap_data(__x._M_impl);
_Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
__x._M_get_Tp_allocator());
}
void
clear() noexcept
{ _M_erase_at_end(this->_M_impl._M_start); }
protected:
template<typename _ForwardIterator>
pointer
_M_allocate_and_copy(size_type __n,
_ForwardIterator __first, _ForwardIterator __last)
{
pointer __result = this->_M_allocate(__n);
try
{
std::__uninitialized_copy_a(__first, __last, __result,
_M_get_Tp_allocator());
return __result;
}
catch(...)
{
_M_deallocate(__result, __n);
throw;
}
}
template<typename _Integer>
void
_M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
{
this->_M_impl._M_start = _M_allocate(static_cast<size_type>(__n));
this->_M_impl._M_end_of_storage =
this->_M_impl._M_start + static_cast<size_type>(__n);
_M_fill_initialize(static_cast<size_type>(__n), __value);
}
template<typename _InputIterator>
void
_M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
{
typedef typename std::iterator_traits<_InputIterator>::
iterator_category _IterCategory;
_M_range_initialize(__first, __last, _IterCategory());
}
template<typename _InputIterator>
void
_M_range_initialize(_InputIterator __first,
_InputIterator __last, std::input_iterator_tag)
{
for (; __first != __last; ++__first)
emplace_back(*__first);
}
template<typename _ForwardIterator>
void
_M_range_initialize(_ForwardIterator __first,
_ForwardIterator __last, std::forward_iterator_tag)
{
const size_type __n = std::distance(__first, __last);
this->_M_impl._M_start = this->_M_allocate(__n);
this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
this->_M_impl._M_finish =
std::__uninitialized_copy_a(__first, __last,
this->_M_impl._M_start,
_M_get_Tp_allocator());
}
void
_M_fill_initialize(size_type __n, const value_type& __value)
{
this->_M_impl._M_finish =
std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
_M_get_Tp_allocator());
}
void
_M_default_initialize(size_type __n)
{
this->_M_impl._M_finish =
std::__uninitialized_default_n_a(this->_M_impl._M_start, __n,
_M_get_Tp_allocator());
}
template<typename _Integer>
void
_M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
{ _M_fill_assign(__n, __val); }
template<typename _InputIterator>
void
_M_assign_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
{
typedef typename std::iterator_traits<_InputIterator>::
iterator_category _IterCategory;
_M_assign_aux(__first, __last, _IterCategory());
}
template<typename _InputIterator>
void
_M_assign_aux(_InputIterator __first, _InputIterator __last,
std::input_iterator_tag);
template<typename _ForwardIterator>
void
_M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
std::forward_iterator_tag);
void
_M_fill_assign(size_type __n, const value_type& __val);
template<typename _Integer>
void
_M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
__true_type)
;
template<typename _InputIterator>
void
_M_insert_dispatch(iterator __pos, _InputIterator __first,
_InputIterator __last, __false_type)
;
template<typename _InputIterator>
void
_M_range_insert(iterator __pos, _InputIterator __first,
_InputIterator __last, std::input_iterator_tag);
template<typename _ForwardIterator>
void
_M_range_insert(iterator __pos, _ForwardIterator __first,
_ForwardIterator __last, std::forward_iterator_tag);
void
_M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
void
_M_default_append(size_type __n);
bool
_M_shrink_to_fit();
template<typename... _Args>
void
_M_insert_aux(iterator __position, _Args&&... __args);
template<typename... _Args>
void
_M_emplace_back_aux(_Args&&... __args);
size_type
_M_check_len(size_type __n, const char* __s) const
;
void
_M_erase_at_end(pointer __pos) noexcept
{
std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator());
this->_M_impl._M_finish = __pos;
}
iterator
_M_erase(iterator __position);
iterator
_M_erase(iterator __first, iterator __last);
private:
void
_M_move_assign(vector&& __x, std::true_type) noexcept
{
vector __tmp(get_allocator());
this->_M_impl._M_swap_data(__tmp._M_impl);
this->_M_impl._M_swap_data(__x._M_impl);
std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
}
void
_M_move_assign(vector&& __x, std::false_type)
{
if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
_M_move_assign(std::move(__x), std::true_type());
else
{
this->assign(std::__make_move_if_noexcept_iterator(__x.begin()),
std::__make_move_if_noexcept_iterator(__x.end()));
__x.clear();
}
}
template<typename _Up>
_Up*
_M_data_ptr(_Up* __ptr) const
{ return __ptr; }
template<typename _Ptr>
typename std::pointer_traits<_Ptr>::element_type*
_M_data_ptr(_Ptr __ptr) const
{ return empty() ? nullptr : std::__addressof(*__ptr); }
};
template<typename _Tp, typename _Alloc>
bool
operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
;
template<typename _Tp, typename _Alloc>
bool
operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
;
template<typename _Tp, typename _Alloc>
bool
operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
;
template<typename _Tp, typename _Alloc>
bool
operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
;
template<typename _Tp, typename _Alloc>
bool
operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
;
template<typename _Tp, typename _Alloc>
bool
operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
;
template<typename _Tp, typename _Alloc>
inline void
swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
{ __x.swap(__y); }
}
#define _STL_BVECTOR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
typedef unsigned long _Bit_type;
enum { _S_word_bit = int(8 * sizeof(_Bit_type)) };
struct _Bit_reference
{
_Bit_type * _M_p;
_Bit_type _M_mask;
_Bit_reference(_Bit_type * __x, _Bit_type __y)
: _M_p(__x), _M_mask(__y) { }
_Bit_reference() noexcept : _M_p(0), _M_mask(0) { }
operator bool() const noexcept
{ return !!(*_M_p & _M_mask); }
_Bit_reference&
operator=(bool __x) noexcept
{
if (__x)
*_M_p |= _M_mask;
else
*_M_p &= ~_M_mask;
return *this;
}
_Bit_reference&
operator=(const _Bit_reference& __x) noexcept
{ return *this = bool(__x); }
bool
operator==(const _Bit_reference& __x) const
{ return bool(*this) == bool(__x); }
bool
operator<(const _Bit_reference& __x) const
{ return !bool(*this) && bool(__x); }
void
flip() noexcept
{ *_M_p ^= _M_mask; }
};
inline void
swap(_Bit_reference __x, _Bit_reference __y) noexcept
{
bool __tmp = __x;
__x = __y;
__y = __tmp;
}
inline void
swap(_Bit_reference __x, bool& __y) noexcept
{
bool __tmp = __x;
__x = __y;
__y = __tmp;
}
inline void
swap(bool& __x, _Bit_reference __y) noexcept
{
bool __tmp = __x;
__x = __y;
__y = __tmp;
}
struct _Bit_iterator_base
: public std::iterator<std::random_access_iterator_tag, bool>
{
_Bit_type * _M_p;
unsigned int _M_offset;
_Bit_iterator_base(_Bit_type * __x, unsigned int __y)
: _M_p(__x), _M_offset(__y) { }
void
_M_bump_up()
{
if (_M_offset++ == int(_S_word_bit) - 1)
{
_M_offset = 0;
++_M_p;
}
}
void
_M_bump_down()
{
if (_M_offset-- == 0)
{
_M_offset = int(_S_word_bit) - 1;
--_M_p;
}
}
void
_M_incr(ptrdiff_t __i)
{
difference_type __n = __i + _M_offset;
_M_p += __n / int(_S_word_bit);
__n = __n % int(_S_word_bit);
if (__n < 0)
{
__n += int(_S_word_bit);
--_M_p;
}
_M_offset = static_cast<unsigned int>(__n);
}
bool
operator==(const _Bit_iterator_base& __i) const
{ return _M_p == __i._M_p && _M_offset == __i._M_offset; }
bool
operator<(const _Bit_iterator_base& __i) const
{
return _M_p < __i._M_p
|| (_M_p == __i._M_p && _M_offset < __i._M_offset);
}
bool
operator!=(const _Bit_iterator_base& __i) const
{ return !(*this == __i); }
bool
operator>(const _Bit_iterator_base& __i) const
{ return __i < *this; }
bool
operator<=(const _Bit_iterator_base& __i) const
{ return !(__i < *this); }
bool
operator>=(const _Bit_iterator_base& __i) const
{ return !(*this < __i); }
};
inline ptrdiff_t
operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
{
return (int(_S_word_bit) * (__x._M_p - __y._M_p)
+ __x._M_offset - __y._M_offset);
}
struct _Bit_iterator : public _Bit_iterator_base
{
typedef _Bit_reference reference;
typedef _Bit_reference* pointer;
typedef _Bit_iterator iterator;
_Bit_iterator() : _Bit_iterator_base(0, 0) { }
_Bit_iterator(_Bit_type * __x, unsigned int __y)
: _Bit_iterator_base(__x, __y) { }
iterator
_M_const_cast() const
{ return *this; }
reference
operator*() const
{ return reference(_M_p, 1UL << _M_offset); }
iterator&
operator++()
{
_M_bump_up();
return *this;
}
iterator
operator++(int)
{
iterator __tmp = *this;
_M_bump_up();
return __tmp;
}
iterator&
operator--()
{
_M_bump_down();
return *this;
}
iterator
operator--(int)
{
iterator __tmp = *this;
_M_bump_down();
return __tmp;
}
iterator&
operator+=(difference_type __i)
{
_M_incr(__i);
return *this;
}
iterator&
operator-=(difference_type __i)
{
*this += -__i;
return *this;
}
iterator
operator+(difference_type __i) const
{
iterator __tmp = *this;
return __tmp += __i;
}
iterator
operator-(difference_type __i) const
{
iterator __tmp = *this;
return __tmp -= __i;
}
reference
operator[](difference_type __i) const
{ return *(*this + __i); }
};
inline _Bit_iterator
operator+(ptrdiff_t __n, const _Bit_iterator& __x)
{ return __x + __n; }
struct _Bit_const_iterator : public _Bit_iterator_base
{
typedef bool reference;
typedef bool const_reference;
typedef const bool* pointer;
typedef _Bit_const_iterator const_iterator;
_Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
_Bit_const_iterator(_Bit_type * __x, unsigned int __y)
: _Bit_iterator_base(__x, __y) { }
_Bit_const_iterator(const _Bit_iterator& __x)
: _Bit_iterator_base(__x._M_p, __x._M_offset) { }
_Bit_iterator
_M_const_cast() const
{ return _Bit_iterator(_M_p, _M_offset); }
const_reference
operator*() const
;
const_iterator&
operator++()
;
const_iterator
operator++(int)
;
const_iterator&
operator--()
;
const_iterator
operator--(int)
;
const_iterator&
operator+=(difference_type __i)
;
const_iterator&
operator-=(difference_type __i)
;
const_iterator
operator+(difference_type __i) const
;
const_iterator
operator-(difference_type __i) const
;
const_reference
operator[](difference_type __i) const
;
};
_Bit_const_iterator
operator+(ptrdiff_t __n, const _Bit_const_iterator& __x)
;
void
__fill_bvector(_Bit_iterator __first, _Bit_iterator __last, bool __x)
;
void
fill(_Bit_iterator __first, _Bit_iterator __last, const bool& __x)
;
template<typename _Alloc>
struct _Bvector_base
{
typedef typename _Alloc::template rebind<_Bit_type>::other
_Bit_alloc_type;
struct _Bvector_impl
: public _Bit_alloc_type
{
_Bit_iterator _M_start;
_Bit_iterator _M_finish;
_Bit_type* _M_end_of_storage;
_Bvector_impl()
;
_Bvector_impl(const _Bit_alloc_type& __a)
;
_Bvector_impl(_Bit_alloc_type&& __a)
;
};
public:
typedef _Alloc allocator_type;
_Bit_alloc_type&
_M_get_Bit_allocator() noexcept
{ return *static_cast<_Bit_alloc_type*>(&this->_M_impl); }
const _Bit_alloc_type&
_M_get_Bit_allocator() const noexcept
{ return *static_cast<const _Bit_alloc_type*>(&this->_M_impl); }
allocator_type
get_allocator() const noexcept
{ return allocator_type(_M_get_Bit_allocator()); }
_Bvector_base()
: _M_impl() { }
_Bvector_base(const allocator_type& __a)
: _M_impl(__a) { }
_Bvector_base(_Bvector_base&& __x) noexcept
: _M_impl(std::move(__x._M_get_Bit_allocator()))
{
this->_M_impl._M_start = __x._M_impl._M_start;
this->_M_impl._M_finish = __x._M_impl._M_finish;
this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage;
__x._M_impl._M_start = _Bit_iterator();
__x._M_impl._M_finish = _Bit_iterator();
__x._M_impl._M_end_of_storage = 0;
}
~_Bvector_base()
{ this->_M_deallocate(); }
protected:
_Bvector_impl _M_impl;
_Bit_type*
_M_allocate(size_t __n)
;
void
_M_deallocate()
;
static size_t
_S_nword(size_t __n)
;
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc>
class vector<bool, _Alloc> : protected _Bvector_base<_Alloc>
{
typedef _Bvector_base<_Alloc> _Base;
template<typename> friend struct hash;
public:
typedef bool value_type;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef _Bit_reference reference;
typedef bool const_reference;
typedef _Bit_reference* pointer;
typedef const bool* const_pointer;
typedef _Bit_iterator iterator;
typedef _Bit_const_iterator const_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef _Alloc allocator_type;
allocator_type get_allocator() const
;
protected:
using _Base::_M_allocate;
using _Base::_M_deallocate;
using _Base::_S_nword;
using _Base::_M_get_Bit_allocator;
public:
vector() ;
explicit
vector(const allocator_type& __a) ;
explicit
vector(size_type __n, const allocator_type& __a = allocator_type())
;
vector(size_type __n, const bool& __value,
const allocator_type& __a = allocator_type())
;
vector(const vector& __x)
;
vector(vector&& __x) noexcept
: _Base(std::move(__x)) { }
vector(initializer_list<bool> __l,
const allocator_type& __a = allocator_type())
: _Base(__a)
{
_M_initialize_range(__l.begin(), __l.end(),
random_access_iterator_tag());
}
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
vector(_InputIterator __first, _InputIterator __last,
const allocator_type& __a = allocator_type())
: _Base(__a)
{ _M_initialize_dispatch(__first, __last, __false_type()); }
~vector() noexcept { }
vector&
operator=(const vector& __x)
{
if (&__x == this)
return *this;
if (__x.size() > capacity())
{
this->_M_deallocate();
_M_initialize(__x.size());
}
this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
begin());
return *this;
}
vector&
operator=(vector&& __x)
{
this->clear();
this->swap(__x);
return *this;
}
vector&
operator=(initializer_list<bool> __l)
{
this->assign (__l.begin(), __l.end());
return *this;
}
void
assign(size_type __n, const bool& __x)
{ _M_fill_assign(__n, __x); }
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
void
assign(_InputIterator __first, _InputIterator __last)
{ _M_assign_dispatch(__first, __last, __false_type()); }
void
assign(initializer_list<bool> __l)
{ this->assign(__l.begin(), __l.end()); }
iterator
begin() noexcept
{ return this->_M_impl._M_start; }
const_iterator
begin() const noexcept
{ return this->_M_impl._M_start; }
iterator
end() noexcept
{ return this->_M_impl._M_finish; }
const_iterator
end() const noexcept
{ return this->_M_impl._M_finish; }
reverse_iterator
rbegin() noexcept
{ return reverse_iterator(end()); }
const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(end()); }
reverse_iterator
rend() noexcept
{ return reverse_iterator(begin()); }
const_reverse_iterator
rend() const noexcept
{ return const_reverse_iterator(begin()); }
const_iterator
cbegin() const noexcept
{ return this->_M_impl._M_start; }
const_iterator
cend() const noexcept
{ return this->_M_impl._M_finish; }
const_reverse_iterator
crbegin() const noexcept
{ return const_reverse_iterator(end()); }
const_reverse_iterator
crend() const noexcept
{ return const_reverse_iterator(begin()); }
size_type
size() const noexcept
{ return size_type(end() - begin()); }
size_type
max_size() const noexcept
{
const size_type __isize =
__gnu_cxx::__numeric_traits<difference_type>::__max
- int(_S_word_bit) + 1;
const size_type __asize = _M_get_Bit_allocator().max_size();
return (__asize <= __isize / int(_S_word_bit)
? __asize * int(_S_word_bit) : __isize);
}
size_type
capacity() const noexcept
{ return size_type(const_iterator(this->_M_impl._M_end_of_storage, 0)
- begin()); }
bool
empty() const noexcept
{ return begin() == end(); }
reference
operator[](size_type __n)
{
return *iterator(this->_M_impl._M_start._M_p
+ __n / int(_S_word_bit), __n % int(_S_word_bit));
}
const_reference
operator[](size_type __n) const
{
return *const_iterator(this->_M_impl._M_start._M_p
+ __n / int(_S_word_bit), __n % int(_S_word_bit));
}
protected:
void
_M_range_check(size_type __n) const
{
if (__n >= this->size())
__throw_out_of_range_fmt(("vector<bool>::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"),
__n, this->size());
}
public:
reference
at(size_type __n)
{ _M_range_check(__n); return (*this)[__n]; }
const_reference
at(size_type __n) const
{ _M_range_check(__n); return (*this)[__n]; }
void
reserve(size_type __n)
{
if (__n > max_size())
__throw_length_error(("vector::reserve"));
if (capacity() < __n)
_M_reallocate(__n);
}
reference
front()
{ return *begin(); }
const_reference
front() const
{ return *begin(); }
reference
back()
{ return *(end() - 1); }
const_reference
back() const
{ return *(end() - 1); }
void
data() noexcept { }
void
push_back(bool __x)
{
if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
*this->_M_impl._M_finish++ = __x;
else
_M_insert_aux(end(), __x);
}
void
swap(vector& __x)
{
std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
std::swap(this->_M_impl._M_end_of_storage,
__x._M_impl._M_end_of_storage);
std::__alloc_swap<typename _Base::_Bit_alloc_type>::
_S_do_it(_M_get_Bit_allocator(), __x._M_get_Bit_allocator());
}
static void
swap(reference __x, reference __y) noexcept
{
bool __tmp = __x;
__x = __y;
__y = __tmp;
}
iterator
insert(const_iterator __position, const bool& __x = bool())
{
const difference_type __n = __position - begin();
if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage
&& __position == end())
*this->_M_impl._M_finish++ = __x;
else
_M_insert_aux(__position._M_const_cast(), __x);
return begin() + __n;
}
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
iterator
insert(const_iterator __position,
_InputIterator __first, _InputIterator __last)
{
difference_type __offset = __position - cbegin();
_M_insert_dispatch(__position._M_const_cast(),
__first, __last, __false_type());
return begin() + __offset;
}
iterator
insert(const_iterator __position, size_type __n, const bool& __x)
{
difference_type __offset = __position - cbegin();
_M_fill_insert(__position._M_const_cast(), __n, __x);
return begin() + __offset;
}
iterator
insert(const_iterator __p, initializer_list<bool> __l)
{ return this->insert(__p, __l.begin(), __l.end()); }
void
pop_back()
{ --this->_M_impl._M_finish; }
iterator
erase(const_iterator __position)
{ return _M_erase(__position._M_const_cast()); }
iterator
erase(const_iterator __first, const_iterator __last)
{ return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
void
resize(size_type __new_size, bool __x = bool())
{
if (__new_size < size())
_M_erase_at_end(begin() + difference_type(__new_size));
else
insert(end(), __new_size - size(), __x);
}
void
shrink_to_fit()
{ _M_shrink_to_fit(); }
void
flip() noexcept
{
for (_Bit_type * __p = this->_M_impl._M_start._M_p;
__p != this->_M_impl._M_end_of_storage; ++__p)
*__p = ~*__p;
}
void
clear() noexcept
{ _M_erase_at_end(begin()); }
template<typename... _Args>
void
emplace_back(_Args&&... __args)
{ push_back(bool(__args...)); }
template<typename... _Args>
iterator
emplace(const_iterator __pos, _Args&&... __args)
{ return insert(__pos, bool(__args...)); }
protected:
iterator
_M_copy_aligned(const_iterator __first, const_iterator __last,
iterator __result)
{
_Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
return std::copy(const_iterator(__last._M_p, 0), __last,
iterator(__q, 0));
}
void
_M_initialize(size_type __n)
{
_Bit_type* __q = this->_M_allocate(__n);
this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
this->_M_impl._M_start = iterator(__q, 0);
this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
}
void
_M_reallocate(size_type __n);
bool
_M_shrink_to_fit();
template<typename _Integer>
void
_M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
;
template<typename _InputIterator>
void
_M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
;
template<typename _InputIterator>
void
_M_initialize_range(_InputIterator __first, _InputIterator __last,
std::input_iterator_tag)
;
template<typename _ForwardIterator>
void
_M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
std::forward_iterator_tag)
;
template<typename _Integer>
void
_M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
;
template<class _InputIterator>
void
_M_assign_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
;
void
_M_fill_assign(size_t __n, bool __x)
;
template<typename _InputIterator>
void
_M_assign_aux(_InputIterator __first, _InputIterator __last,
std::input_iterator_tag)
;
template<typename _ForwardIterator>
void
_M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
std::forward_iterator_tag)
;
template<typename _Integer>
void
_M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
__true_type)
;
template<typename _InputIterator>
void
_M_insert_dispatch(iterator __pos,
_InputIterator __first, _InputIterator __last,
__false_type)
;
void
_M_fill_insert(iterator __position, size_type __n, bool __x);
template<typename _InputIterator>
void
_M_insert_range(iterator __pos, _InputIterator __first,
_InputIterator __last, std::input_iterator_tag)
;
template<typename _ForwardIterator>
void
_M_insert_range(iterator __position, _ForwardIterator __first,
_ForwardIterator __last, std::forward_iterator_tag);
void
_M_insert_aux(iterator __position, bool __x);
size_type
_M_check_len(size_type __n, const char* __s) const
;
void
_M_erase_at_end(iterator __pos)
;
iterator
_M_erase(iterator __pos);
iterator
_M_erase(iterator __first, iterator __last);
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc>
struct hash<std::vector<bool, _Alloc>>
: public __hash_base<size_t, std::vector<bool, _Alloc>>
{
size_t
operator()(const std::vector<bool, _Alloc>&) const noexcept;
};
}
#define _VECTOR_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc>
size_t
hash<std::vector<bool, _Alloc>>::
operator()(const std::vector<bool, _Alloc>& __b) const noexcept
{
size_t __hash = 0;
using std::_S_word_bit;
using std::_Bit_type;
const size_t __words = __b.size() / _S_word_bit;
if (__words)
{
const size_t __clength = __words * sizeof(_Bit_type);
__hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength);
}
const size_t __extrabits = __b.size() % _S_word_bit;
if (__extrabits)
{
_Bit_type __hiword = *__b._M_impl._M_finish._M_p;
__hiword &= ~((~static_cast<_Bit_type>(0)) << __extrabits);
const size_t __clength
= (__extrabits + 8 - 1) / 8;
if (__words)
__hash = std::_Hash_impl::hash(&__hiword, __clength, __hash);
else
__hash = std::_Hash_impl::hash(&__hiword, __clength);
}
return __hash;
}
}
namespace boost {
namespace asio {
namespace detail {
}
}
}
namespace boost {
namespace asio {
template <typename Service>
Service& use_service(io_service& ios)
;
template <> detail::io_service_impl& use_service<detail::io_service_impl>(
io_service& ios)
;
template <typename Service>
void add_service(io_service& ios, Service* svc)
;
template <typename Service>
bool has_service(io_service& ios)
;
}
}
#define BOOST_ASIO_DETAIL_TASK_IO_SERVICE_HPP
#define BOOST_ASIO_DETAIL_ATOMIC_COUNT_HPP
#define _GLIBCXX_ATOMIC 1
#define _GLIBCXX_ATOMIC_BASE_H 1
#define _STDBOOL_H
#define _Bool bool
#define bool bool
#define false false
#define true true
#define __bool_true_false_are_defined 1
#define _GLIBCXX_ALWAYS_INLINE inline __attribute__((always_inline))
namespace std __attribute__ ((__visibility__ ("default")))
{
typedef enum memory_order
{
memory_order_relaxed,
memory_order_consume,
memory_order_acquire,
memory_order_release,
memory_order_acq_rel,
memory_order_seq_cst
} memory_order;
enum __memory_order_modifier
{
__memory_order_mask = 0x0ffff,
__memory_order_modifier_mask = 0xffff0000,
__memory_order_hle_acquire = 0x10000,
__memory_order_hle_release = 0x20000
};
constexpr memory_order
operator|(memory_order __m, __memory_order_modifier __mod)
{
return memory_order(__m | int(__mod));
}
constexpr memory_order
operator&(memory_order __m, __memory_order_modifier __mod)
{
return memory_order(__m & int(__mod));
}
constexpr memory_order
__cmpexch_failure_order2(memory_order __m) noexcept
{
return __m == memory_order_acq_rel ? memory_order_acquire
: __m == memory_order_release ? memory_order_relaxed : __m;
}
constexpr memory_order
__cmpexch_failure_order(memory_order __m) noexcept
{
return memory_order(__cmpexch_failure_order2(__m & __memory_order_mask)
| (__m & __memory_order_modifier_mask));
}
inline __attribute__((always_inline)) void
atomic_thread_fence(memory_order __m) noexcept
{ __atomic_thread_fence(__m); }
inline __attribute__((always_inline)) void
atomic_signal_fence(memory_order __m) noexcept
{ __atomic_signal_fence(__m); }
template<typename _Tp>
inline _Tp
kill_dependency(_Tp __y) noexcept
{
_Tp __ret(__y);
return __ret;
}
template<typename _IntTp>
struct __atomic_base;
typedef __atomic_base<char> atomic_char;
typedef __atomic_base<signed char> atomic_schar;
typedef __atomic_base<unsigned char> atomic_uchar;
typedef __atomic_base<short> atomic_short;
typedef __atomic_base<unsigned short> atomic_ushort;
typedef __atomic_base<int> atomic_int;
typedef __atomic_base<unsigned int> atomic_uint;
typedef __atomic_base<long> atomic_long;
typedef __atomic_base<unsigned long> atomic_ulong;
typedef __atomic_base<long long> atomic_llong;
typedef __atomic_base<unsigned long long> atomic_ullong;
typedef __atomic_base<wchar_t> atomic_wchar_t;
typedef __atomic_base<char16_t> atomic_char16_t;
typedef __atomic_base<char32_t> atomic_char32_t;
typedef __atomic_base<char32_t> atomic_char32_t;
typedef __atomic_base<int_least8_t> atomic_int_least8_t;
typedef __atomic_base<uint_least8_t> atomic_uint_least8_t;
typedef __atomic_base<int_least16_t> atomic_int_least16_t;
typedef __atomic_base<uint_least16_t> atomic_uint_least16_t;
typedef __atomic_base<int_least32_t> atomic_int_least32_t;
typedef __atomic_base<uint_least32_t> atomic_uint_least32_t;
typedef __atomic_base<int_least64_t> atomic_int_least64_t;
typedef __atomic_base<uint_least64_t> atomic_uint_least64_t;
typedef __atomic_base<int_fast8_t> atomic_int_fast8_t;
typedef __atomic_base<uint_fast8_t> atomic_uint_fast8_t;
typedef __atomic_base<int_fast16_t> atomic_int_fast16_t;
typedef __atomic_base<uint_fast16_t> atomic_uint_fast16_t;
typedef __atomic_base<int_fast32_t> atomic_int_fast32_t;
typedef __atomic_base<uint_fast32_t> atomic_uint_fast32_t;
typedef __atomic_base<int_fast64_t> atomic_int_fast64_t;
typedef __atomic_base<uint_fast64_t> atomic_uint_fast64_t;
typedef __atomic_base<intptr_t> atomic_intptr_t;
typedef __atomic_base<uintptr_t> atomic_uintptr_t;
typedef __atomic_base<size_t> atomic_size_t;
typedef __atomic_base<intmax_t> atomic_intmax_t;
typedef __atomic_base<uintmax_t> atomic_uintmax_t;
typedef __atomic_base<ptrdiff_t> atomic_ptrdiff_t;
#define ATOMIC_VAR_INIT(_VI) { _VI }
template<typename _Tp>
struct atomic;
template<typename _Tp>
struct atomic<_Tp*>;
typedef bool __atomic_flag_data_type;
extern "C" {
struct __atomic_flag_base
{
__atomic_flag_data_type _M_i;
};
}
#define ATOMIC_FLAG_INIT { 0 }
struct atomic_flag : public __atomic_flag_base
{
atomic_flag() noexcept = default;
~atomic_flag() noexcept = default;
atomic_flag(const atomic_flag&) = delete;
atomic_flag& operator=(const atomic_flag&) = delete;
atomic_flag& operator=(const atomic_flag&) volatile = delete;
constexpr atomic_flag(bool __i) noexcept
: __atomic_flag_base{ _S_init(__i) }
{ }
inline __attribute__((always_inline)) bool
test_and_set(memory_order __m = memory_order_seq_cst) noexcept
{
return __atomic_test_and_set (&_M_i, __m);
}
inline __attribute__((always_inline)) bool
test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept
{
return __atomic_test_and_set (&_M_i, __m);
}
inline __attribute__((always_inline)) void
clear(memory_order __m = memory_order_seq_cst) noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
;
__atomic_clear (&_M_i, __m);
}
inline __attribute__((always_inline)) void
clear(memory_order __m = memory_order_seq_cst) volatile noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
;
__atomic_clear (&_M_i, __m);
}
private:
static constexpr __atomic_flag_data_type
_S_init(bool __i)
{ return __i ? 1 : 0; }
};
template<typename _ITp>
struct __atomic_base
{
private:
typedef _ITp __int_type;
__int_type _M_i;
public:
__atomic_base() noexcept = default;
~__atomic_base() noexcept = default;
__atomic_base(const __atomic_base&) = delete;
__atomic_base& operator=(const __atomic_base&) = delete;
__atomic_base& operator=(const __atomic_base&) volatile = delete;
constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { }
operator __int_type() const noexcept
{ return load(); }
operator __int_type() const volatile noexcept
{ return load(); }
__int_type
operator=(__int_type __i) noexcept
{
store(__i);
return __i;
}
__int_type
operator=(__int_type __i) volatile noexcept
{
store(__i);
return __i;
}
__int_type
operator++(int) noexcept
{ return fetch_add(1); }
__int_type
operator++(int) volatile noexcept
{ return fetch_add(1); }
__int_type
operator--(int) noexcept
{ return fetch_sub(1); }
__int_type
operator--(int) volatile noexcept
{ return fetch_sub(1); }
__int_type
operator++() noexcept
{ return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }
__int_type
operator++() volatile noexcept
{ return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }
__int_type
operator--() noexcept
{ return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }
__int_type
operator--() volatile noexcept
{ return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }
__int_type
operator+=(__int_type __i) noexcept
{ return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator+=(__int_type __i) volatile noexcept
{ return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator-=(__int_type __i) noexcept
{ return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator-=(__int_type __i) volatile noexcept
{ return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator&=(__int_type __i) noexcept
{ return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator&=(__int_type __i) volatile noexcept
{ return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator|=(__int_type __i) noexcept
{ return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator|=(__int_type __i) volatile noexcept
{ return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator^=(__int_type __i) noexcept
{ return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator^=(__int_type __i) volatile noexcept
{ return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }
bool
is_lock_free() const noexcept
{ return __atomic_is_lock_free(sizeof(_M_i), nullptr); }
bool
is_lock_free() const volatile noexcept
{ return __atomic_is_lock_free(sizeof(_M_i), nullptr); }
inline __attribute__((always_inline)) void
store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
;
__atomic_store_n(&_M_i, __i, __m);
}
inline __attribute__((always_inline)) void
store(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
;
__atomic_store_n(&_M_i, __i, __m);
}
inline __attribute__((always_inline)) __int_type
load(memory_order __m = memory_order_seq_cst) const noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
return __atomic_load_n(&_M_i, __m);
}
inline __attribute__((always_inline)) __int_type
load(memory_order __m = memory_order_seq_cst) const volatile noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
return __atomic_load_n(&_M_i, __m);
}
inline __attribute__((always_inline)) __int_type
exchange(__int_type __i,
memory_order __m = memory_order_seq_cst) noexcept
{
return __atomic_exchange_n(&_M_i, __i, __m);
}
inline __attribute__((always_inline)) __int_type
exchange(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
return __atomic_exchange_n(&_M_i, __i, __m);
}
inline __attribute__((always_inline)) bool
compare_exchange_weak(__int_type& __i1, __int_type __i2,
memory_order __m1, memory_order __m2) noexcept
{
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;
;
;
;
return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
}
inline __attribute__((always_inline)) bool
compare_exchange_weak(__int_type& __i1, __int_type __i2,
memory_order __m1,
memory_order __m2) volatile noexcept
{
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;
;
;
;
return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
}
inline __attribute__((always_inline)) bool
compare_exchange_weak(__int_type& __i1, __int_type __i2,
memory_order __m = memory_order_seq_cst) noexcept
{
return compare_exchange_weak(__i1, __i2, __m,
__cmpexch_failure_order(__m));
}
inline __attribute__((always_inline)) bool
compare_exchange_weak(__int_type& __i1, __int_type __i2,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
return compare_exchange_weak(__i1, __i2, __m,
__cmpexch_failure_order(__m));
}
inline __attribute__((always_inline)) bool
compare_exchange_strong(__int_type& __i1, __int_type __i2,
memory_order __m1, memory_order __m2) noexcept
{
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;
;
;
;
return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
}
inline __attribute__((always_inline)) bool
compare_exchange_strong(__int_type& __i1, __int_type __i2,
memory_order __m1,
memory_order __m2) volatile noexcept
{
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;
;
;
;
return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
}
inline __attribute__((always_inline)) bool
compare_exchange_strong(__int_type& __i1, __int_type __i2,
memory_order __m = memory_order_seq_cst) noexcept
{
return compare_exchange_strong(__i1, __i2, __m,
__cmpexch_failure_order(__m));
}
inline __attribute__((always_inline)) bool
compare_exchange_strong(__int_type& __i1, __int_type __i2,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
return compare_exchange_strong(__i1, __i2, __m,
__cmpexch_failure_order(__m));
}
inline __attribute__((always_inline)) __int_type
fetch_add(__int_type __i,
memory_order __m = memory_order_seq_cst) noexcept
{ return __atomic_fetch_add(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_add(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return __atomic_fetch_add(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_sub(__int_type __i,
memory_order __m = memory_order_seq_cst) noexcept
{ return __atomic_fetch_sub(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_sub(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return __atomic_fetch_sub(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_and(__int_type __i,
memory_order __m = memory_order_seq_cst) noexcept
{ return __atomic_fetch_and(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_and(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return __atomic_fetch_and(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_or(__int_type __i,
memory_order __m = memory_order_seq_cst) noexcept
{ return __atomic_fetch_or(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_or(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return __atomic_fetch_or(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_xor(__int_type __i,
memory_order __m = memory_order_seq_cst) noexcept
{ return __atomic_fetch_xor(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_xor(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return __atomic_fetch_xor(&_M_i, __i, __m); }
};
template<typename _PTp>
struct __atomic_base<_PTp*>
{
private:
typedef _PTp* __pointer_type;
__pointer_type _M_p;
constexpr ptrdiff_t
_M_type_size(ptrdiff_t __d) const { return __d * sizeof(_PTp); }
constexpr ptrdiff_t
_M_type_size(ptrdiff_t __d) const volatile { return __d * sizeof(_PTp); }
public:
__atomic_base() noexcept = default;
~__atomic_base() noexcept = default;
__atomic_base(const __atomic_base&) = delete;
__atomic_base& operator=(const __atomic_base&) = delete;
__atomic_base& operator=(const __atomic_base&) volatile = delete;
constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { }
operator __pointer_type() const noexcept
{ return load(); }
operator __pointer_type() const volatile noexcept
{ return load(); }
__pointer_type
operator=(__pointer_type __p) noexcept
{
store(__p);
return __p;
}
__pointer_type
operator=(__pointer_type __p) volatile noexcept
{
store(__p);
return __p;
}
__pointer_type
operator++(int) noexcept
{ return fetch_add(1); }
__pointer_type
operator++(int) volatile noexcept
{ return fetch_add(1); }
__pointer_type
operator--(int) noexcept
{ return fetch_sub(1); }
__pointer_type
operator--(int) volatile noexcept
{ return fetch_sub(1); }
__pointer_type
operator++() noexcept
{ return __atomic_add_fetch(&_M_p, _M_type_size(1),
memory_order_seq_cst); }
__pointer_type
operator++() volatile noexcept
{ return __atomic_add_fetch(&_M_p, _M_type_size(1),
memory_order_seq_cst); }
__pointer_type
operator--() noexcept
{ return __atomic_sub_fetch(&_M_p, _M_type_size(1),
memory_order_seq_cst); }
__pointer_type
operator--() volatile noexcept
{ return __atomic_sub_fetch(&_M_p, _M_type_size(1),
memory_order_seq_cst); }
__pointer_type
operator+=(ptrdiff_t __d) noexcept
{ return __atomic_add_fetch(&_M_p, _M_type_size(__d),
memory_order_seq_cst); }
__pointer_type
operator+=(ptrdiff_t __d) volatile noexcept
{ return __atomic_add_fetch(&_M_p, _M_type_size(__d),
memory_order_seq_cst); }
__pointer_type
operator-=(ptrdiff_t __d) noexcept
{ return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
memory_order_seq_cst); }
__pointer_type
operator-=(ptrdiff_t __d) volatile noexcept
{ return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
memory_order_seq_cst); }
bool
is_lock_free() const noexcept
{ return __atomic_is_lock_free(sizeof(__pointer_type), nullptr); }
bool
is_lock_free() const volatile noexcept
{ return __atomic_is_lock_free(sizeof(__pointer_type), nullptr); }
inline __attribute__((always_inline)) void
store(__pointer_type __p,
memory_order __m = memory_order_seq_cst) noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
;
__atomic_store_n(&_M_p, __p, __m);
}
inline __attribute__((always_inline)) void
store(__pointer_type __p,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
;
__atomic_store_n(&_M_p, __p, __m);
}
inline __attribute__((always_inline)) __pointer_type
load(memory_order __m = memory_order_seq_cst) const noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
return __atomic_load_n(&_M_p, __m);
}
inline __attribute__((always_inline)) __pointer_type
load(memory_order __m = memory_order_seq_cst) const volatile noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
return __atomic_load_n(&_M_p, __m);
}
inline __attribute__((always_inline)) __pointer_type
exchange(__pointer_type __p,
memory_order __m = memory_order_seq_cst) noexcept
{
return __atomic_exchange_n(&_M_p, __p, __m);
}
inline __attribute__((always_inline)) __pointer_type
exchange(__pointer_type __p,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
return __atomic_exchange_n(&_M_p, __p, __m);
}
inline __attribute__((always_inline)) bool
compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
memory_order __m1,
memory_order __m2) noexcept
{
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;
;
;
;
return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
}
inline __attribute__((always_inline)) bool
compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
memory_order __m1,
memory_order __m2) volatile noexcept
{
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;
;
;
;
return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
}
inline __attribute__((always_inline)) __pointer_type
fetch_add(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) noexcept
{ return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); }
inline __attribute__((always_inline)) __pointer_type
fetch_add(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); }
inline __attribute__((always_inline)) __pointer_type
fetch_sub(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) noexcept
{ return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); }
inline __attribute__((always_inline)) __pointer_type
fetch_sub(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); }
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
struct atomic_bool
{
private:
__atomic_base<bool> _M_base;
public:
atomic_bool() noexcept = default;
~atomic_bool() noexcept = default;
atomic_bool(const atomic_bool&) = delete;
atomic_bool& operator=(const atomic_bool&) = delete;
atomic_bool& operator=(const atomic_bool&) volatile = delete;
constexpr atomic_bool(bool __i) noexcept : _M_base(__i) { }
bool
operator=(bool __i) noexcept
{ return _M_base.operator=(__i); }
bool
operator=(bool __i) volatile noexcept
{ return _M_base.operator=(__i); }
operator bool() const noexcept
{ return _M_base.load(); }
operator bool() const volatile noexcept
{ return _M_base.load(); }
bool
is_lock_free() const noexcept { return _M_base.is_lock_free(); }
bool
is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); }
void
store(bool __i, memory_order __m = memory_order_seq_cst) noexcept
{ _M_base.store(__i, __m); }
void
store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept
{ _M_base.store(__i, __m); }
bool
load(memory_order __m = memory_order_seq_cst) const noexcept
{ return _M_base.load(__m); }
bool
load(memory_order __m = memory_order_seq_cst) const volatile noexcept
{ return _M_base.load(__m); }
bool
exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept
{ return _M_base.exchange(__i, __m); }
bool
exchange(bool __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return _M_base.exchange(__i, __m); }
bool
compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
memory_order __m2) noexcept
{ return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
bool
compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
memory_order __m2) volatile noexcept
{ return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
bool
compare_exchange_weak(bool& __i1, bool __i2,
memory_order __m = memory_order_seq_cst) noexcept
{ return _M_base.compare_exchange_weak(__i1, __i2, __m); }
bool
compare_exchange_weak(bool& __i1, bool __i2,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return _M_base.compare_exchange_weak(__i1, __i2, __m); }
bool
compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
memory_order __m2) noexcept
{ return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
bool
compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
memory_order __m2) volatile noexcept
{ return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
bool
compare_exchange_strong(bool& __i1, bool __i2,
memory_order __m = memory_order_seq_cst) noexcept
{ return _M_base.compare_exchange_strong(__i1, __i2, __m); }
bool
compare_exchange_strong(bool& __i1, bool __i2,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return _M_base.compare_exchange_strong(__i1, __i2, __m); }
};
template<typename _Tp>
struct atomic
{
private:
_Tp _M_i;
static_assert(sizeof(_Tp) > 0,
"Incomplete or zero-sized types are not supported");
public:
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(_Tp __i) noexcept : _M_i(__i) { }
operator _Tp() const noexcept
{ return load(); }
operator _Tp() const volatile noexcept
{ return load(); }
_Tp
operator=(_Tp __i) noexcept
{ store(__i); return __i; }
_Tp
operator=(_Tp __i) volatile noexcept
{ store(__i); return __i; }
bool
is_lock_free() const noexcept
{ return __atomic_is_lock_free(sizeof(_M_i), nullptr); }
bool
is_lock_free() const volatile noexcept
{ return __atomic_is_lock_free(sizeof(_M_i), nullptr); }
void
store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
{ __atomic_store(&_M_i, &__i, __m); }
void
store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept
{ __atomic_store(&_M_i, &__i, __m); }
_Tp
load(memory_order __m = memory_order_seq_cst) const noexcept
{
_Tp tmp;
__atomic_load(&_M_i, &tmp, __m);
return tmp;
}
_Tp
load(memory_order __m = memory_order_seq_cst) const volatile noexcept
{
_Tp tmp;
__atomic_load(&_M_i, &tmp, __m);
return tmp;
}
_Tp
exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
{
_Tp tmp;
__atomic_exchange(&_M_i, &__i, &tmp, __m);
return tmp;
}
_Tp
exchange(_Tp __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
_Tp tmp;
__atomic_exchange(&_M_i, &__i, &tmp, __m);
return tmp;
}
bool
compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
memory_order __f) noexcept
{
return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f);
}
bool
compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
memory_order __f) volatile noexcept
{
return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f);
}
bool
compare_exchange_weak(_Tp& __e, _Tp __i,
memory_order __m = memory_order_seq_cst) noexcept
{ return compare_exchange_weak(__e, __i, __m,
__cmpexch_failure_order(__m)); }
bool
compare_exchange_weak(_Tp& __e, _Tp __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return compare_exchange_weak(__e, __i, __m,
__cmpexch_failure_order(__m)); }
bool
compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
memory_order __f) noexcept
{
return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f);
}
bool
compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
memory_order __f) volatile noexcept
{
return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f);
}
bool
compare_exchange_strong(_Tp& __e, _Tp __i,
memory_order __m = memory_order_seq_cst) noexcept
{ return compare_exchange_strong(__e, __i, __m,
__cmpexch_failure_order(__m)); }
bool
compare_exchange_strong(_Tp& __e, _Tp __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return compare_exchange_strong(__e, __i, __m,
__cmpexch_failure_order(__m)); }
};
template<typename _Tp>
struct atomic<_Tp*>
{
typedef _Tp* __pointer_type;
typedef __atomic_base<_Tp*> __base_type;
__base_type _M_b;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }
operator __pointer_type() const noexcept
{ return __pointer_type(_M_b); }
operator __pointer_type() const volatile noexcept
{ return __pointer_type(_M_b); }
__pointer_type
operator=(__pointer_type __p) noexcept
{ return _M_b.operator=(__p); }
__pointer_type
operator=(__pointer_type __p) volatile noexcept
{ return _M_b.operator=(__p); }
__pointer_type
operator++(int) noexcept
{ return _M_b++; }
__pointer_type
operator++(int) volatile noexcept
{ return _M_b++; }
__pointer_type
operator--(int) noexcept
{ return _M_b--; }
__pointer_type
operator--(int) volatile noexcept
{ return _M_b--; }
__pointer_type
operator++() noexcept
{ return ++_M_b; }
__pointer_type
operator++() volatile noexcept
{ return ++_M_b; }
__pointer_type
operator--() noexcept
{ return --_M_b; }
__pointer_type
operator--() volatile noexcept
{ return --_M_b; }
__pointer_type
operator+=(ptrdiff_t __d) noexcept
{ return _M_b.operator+=(__d); }
__pointer_type
operator+=(ptrdiff_t __d) volatile noexcept
{ return _M_b.operator+=(__d); }
__pointer_type
operator-=(ptrdiff_t __d) noexcept
{ return _M_b.operator-=(__d); }
__pointer_type
operator-=(ptrdiff_t __d) volatile noexcept
{ return _M_b.operator-=(__d); }
bool
is_lock_free() const noexcept
{ return _M_b.is_lock_free(); }
bool
is_lock_free() const volatile noexcept
{ return _M_b.is_lock_free(); }
void
store(__pointer_type __p,
memory_order __m = memory_order_seq_cst) noexcept
{ return _M_b.store(__p, __m); }
void
store(__pointer_type __p,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return _M_b.store(__p, __m); }
__pointer_type
load(memory_order __m = memory_order_seq_cst) const noexcept
{ return _M_b.load(__m); }
__pointer_type
load(memory_order __m = memory_order_seq_cst) const volatile noexcept
{ return _M_b.load(__m); }
__pointer_type
exchange(__pointer_type __p,
memory_order __m = memory_order_seq_cst) noexcept
{ return _M_b.exchange(__p, __m); }
__pointer_type
exchange(__pointer_type __p,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return _M_b.exchange(__p, __m); }
bool
compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
memory_order __m1, memory_order __m2) noexcept
{ return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
bool
compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
memory_order __m1,
memory_order __m2) volatile noexcept
{ return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
bool
compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
memory_order __m = memory_order_seq_cst) noexcept
{
return compare_exchange_weak(__p1, __p2, __m,
__cmpexch_failure_order(__m));
}
bool
compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
return compare_exchange_weak(__p1, __p2, __m,
__cmpexch_failure_order(__m));
}
bool
compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
memory_order __m1, memory_order __m2) noexcept
{ return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
bool
compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
memory_order __m1,
memory_order __m2) volatile noexcept
{ return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
bool
compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
memory_order __m = memory_order_seq_cst) noexcept
{
return _M_b.compare_exchange_strong(__p1, __p2, __m,
__cmpexch_failure_order(__m));
}
bool
compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
return _M_b.compare_exchange_strong(__p1, __p2, __m,
__cmpexch_failure_order(__m));
}
__pointer_type
fetch_add(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) noexcept
{ return _M_b.fetch_add(__d, __m); }
__pointer_type
fetch_add(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return _M_b.fetch_add(__d, __m); }
__pointer_type
fetch_sub(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) noexcept
{ return _M_b.fetch_sub(__d, __m); }
__pointer_type
fetch_sub(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return _M_b.fetch_sub(__d, __m); }
};
template<>
struct atomic<bool> : public atomic_bool
{
typedef bool __integral_type;
typedef atomic_bool __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<char> : public atomic_char
{
typedef char __integral_type;
typedef atomic_char __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<signed char> : public atomic_schar
{
typedef signed char __integral_type;
typedef atomic_schar __base_type;
atomic() noexcept= default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<unsigned char> : public atomic_uchar
{
typedef unsigned char __integral_type;
typedef atomic_uchar __base_type;
atomic() noexcept= default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<short> : public atomic_short
{
typedef short __integral_type;
typedef atomic_short __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<unsigned short> : public atomic_ushort
{
typedef unsigned short __integral_type;
typedef atomic_ushort __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<int> : atomic_int
{
typedef int __integral_type;
typedef atomic_int __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<unsigned int> : public atomic_uint
{
typedef unsigned int __integral_type;
typedef atomic_uint __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<long> : public atomic_long
{
typedef long __integral_type;
typedef atomic_long __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<unsigned long> : public atomic_ulong
{
typedef unsigned long __integral_type;
typedef atomic_ulong __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<long long> : public atomic_llong
{
typedef long long __integral_type;
typedef atomic_llong __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<unsigned long long> : public atomic_ullong
{
typedef unsigned long long __integral_type;
typedef atomic_ullong __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<wchar_t> : public atomic_wchar_t
{
typedef wchar_t __integral_type;
typedef atomic_wchar_t __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<char16_t> : public atomic_char16_t
{
typedef char16_t __integral_type;
typedef atomic_char16_t __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<char32_t> : public atomic_char32_t
{
typedef char32_t __integral_type;
typedef atomic_char32_t __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
inline bool
atomic_flag_test_and_set_explicit(atomic_flag* __a,
memory_order __m) noexcept
{ return __a->test_and_set(__m); }
inline bool
atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
memory_order __m) noexcept
{ return __a->test_and_set(__m); }
inline void
atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept
{ __a->clear(__m); }
inline void
atomic_flag_clear_explicit(volatile atomic_flag* __a,
memory_order __m) noexcept
{ __a->clear(__m); }
inline bool
atomic_flag_test_and_set(atomic_flag* __a) noexcept
{ return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
inline bool
atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept
{ return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
inline void
atomic_flag_clear(atomic_flag* __a) noexcept
{ atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
inline void
atomic_flag_clear(volatile atomic_flag* __a) noexcept
{ atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
template<typename _ITp>
inline bool
atomic_is_lock_free(const atomic<_ITp>* __a) noexcept
{ return __a->is_lock_free(); }
template<typename _ITp>
inline bool
atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept
{ return __a->is_lock_free(); }
template<typename _ITp>
inline void
atomic_init(atomic<_ITp>* __a, _ITp __i) noexcept;
template<typename _ITp>
inline void
atomic_init(volatile atomic<_ITp>* __a, _ITp __i) noexcept;
template<typename _ITp>
inline void
atomic_store_explicit(atomic<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ __a->store(__i, __m); }
template<typename _ITp>
inline void
atomic_store_explicit(volatile atomic<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ __a->store(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept
{ return __a->load(__m); }
template<typename _ITp>
inline _ITp
atomic_load_explicit(const volatile atomic<_ITp>* __a,
memory_order __m) noexcept
{ return __a->load(__m); }
template<typename _ITp>
inline _ITp
atomic_exchange_explicit(atomic<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->exchange(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_exchange_explicit(volatile atomic<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->exchange(__i, __m); }
template<typename _ITp>
inline bool
atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2,
memory_order __m1,
memory_order __m2) noexcept
{ return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
template<typename _ITp>
inline bool
atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2,
memory_order __m1,
memory_order __m2) noexcept
{ return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
template<typename _ITp>
inline bool
atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2,
memory_order __m1,
memory_order __m2) noexcept
{ return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
template<typename _ITp>
inline bool
atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2,
memory_order __m1,
memory_order __m2) noexcept
{ return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
template<typename _ITp>
inline void
atomic_store(atomic<_ITp>* __a, _ITp __i) noexcept
{ atomic_store_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline void
atomic_store(volatile atomic<_ITp>* __a, _ITp __i) noexcept
{ atomic_store_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_load(const atomic<_ITp>* __a) noexcept
{ return atomic_load_explicit(__a, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_load(const volatile atomic<_ITp>* __a) noexcept
{ return atomic_load_explicit(__a, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_exchange(atomic<_ITp>* __a, _ITp __i) noexcept
{ return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_exchange(volatile atomic<_ITp>* __a, _ITp __i) noexcept
{ return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline bool
atomic_compare_exchange_weak(atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2) noexcept
{
return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
memory_order_seq_cst,
memory_order_seq_cst);
}
template<typename _ITp>
inline bool
atomic_compare_exchange_weak(volatile atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2) noexcept
{
return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
memory_order_seq_cst,
memory_order_seq_cst);
}
template<typename _ITp>
inline bool
atomic_compare_exchange_strong(atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2) noexcept
{
return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
memory_order_seq_cst,
memory_order_seq_cst);
}
template<typename _ITp>
inline bool
atomic_compare_exchange_strong(volatile atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2) noexcept
{
return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
memory_order_seq_cst,
memory_order_seq_cst);
}
template<typename _ITp>
inline _ITp
atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_add(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_add(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_sub(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_sub(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_and(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_and(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_or(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_or(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_xor(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_xor(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp*
atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
memory_order __m) noexcept
{ return __a->fetch_add(__d, __m); }
template<typename _ITp>
inline _ITp*
atomic_fetch_add_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d,
memory_order __m) noexcept
{ return __a->fetch_add(__d, __m); }
template<typename _ITp>
inline _ITp*
atomic_fetch_add(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
{ return __a->fetch_add(__d); }
template<typename _ITp>
inline _ITp*
atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
{ return __a->fetch_add(__d); }
template<typename _ITp>
inline _ITp*
atomic_fetch_sub_explicit(volatile atomic<_ITp*>* __a,
ptrdiff_t __d, memory_order __m) noexcept
{ return __a->fetch_sub(__d, __m); }
template<typename _ITp>
inline _ITp*
atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
memory_order __m) noexcept
{ return __a->fetch_sub(__d, __m); }
template<typename _ITp>
inline _ITp*
atomic_fetch_sub(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
{ return __a->fetch_sub(__d); }
template<typename _ITp>
inline _ITp*
atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
{ return __a->fetch_sub(__d); }
}
namespace boost {
namespace asio {
namespace detail {
typedef std::atomic<long> atomic_count;
void increment(atomic_count& a, long b) ;
}
}
}
#define BOOST_ASIO_DETAIL_REACTOR_FWD_HPP
namespace boost {
namespace asio {
namespace detail {
typedef class epoll_reactor reactor;
}
}
}
#define BOOST_ASIO_DETAIL_TASK_IO_SERVICE_OPERATION_HPP
#define BOOST_ASIO_DETAIL_HANDLER_TRACKING_HPP
namespace boost {
namespace asio {
namespace detail {
#define BOOST_ASIO_INHERIT_TRACKED_HANDLER
#define BOOST_ASIO_ALSO_INHERIT_TRACKED_HANDLER
#define BOOST_ASIO_HANDLER_TRACKING_INIT (void)0
#define BOOST_ASIO_HANDLER_CREATION(args) (void)0
#define BOOST_ASIO_HANDLER_COMPLETION(args) (void)0
#define BOOST_ASIO_HANDLER_INVOCATION_BEGIN(args) (void)0
#define BOOST_ASIO_HANDLER_INVOCATION_END (void)0
#define BOOST_ASIO_HANDLER_OPERATION(args) (void)0
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_HANDLER_TRACKING_IPP
namespace boost {
namespace asio {
namespace detail {
class task_io_service;
class task_io_service_operation
{
public:
void complete(task_io_service& owner,
const boost::system::error_code& ec, std::size_t bytes_transferred)
;
void destroy()
;
protected:
typedef void (*func_type)(task_io_service*,
task_io_service_operation*,
const boost::system::error_code&, std::size_t);
task_io_service_operation(func_type func)
;
~task_io_service_operation()
;
private:
friend class op_queue_access;
task_io_service_operation* next_;
func_type func_;
protected:
friend class task_io_service;
unsigned int task_result_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
struct task_io_service_thread_info;
class task_io_service
: public boost::asio::detail::service_base<task_io_service>
{
public:
typedef task_io_service_operation operation;
inline task_io_service(boost::asio::io_service& io_service,
std::size_t concurrency_hint = 0);
inline void shutdown_service();
inline void init_task();
inline std::size_t run(boost::system::error_code& ec);
inline std::size_t run_one(boost::system::error_code& ec);
inline std::size_t poll(boost::system::error_code& ec);
inline std::size_t poll_one(boost::system::error_code& ec);
inline void stop();
inline bool stopped() const;
inline void reset();
void work_started()
;
void work_finished()
;
bool can_dispatch()
;
template <typename Handler>
void dispatch(Handler& handler);
template <typename Handler>
void post(Handler& handler);
inline void post_immediate_completion(
operation* op, bool is_continuation);
inline void post_deferred_completion(operation* op);
inline void post_deferred_completions(op_queue<operation>& ops);
inline void abandon_operations(op_queue<operation>& ops);
private:
typedef task_io_service_thread_info thread_info;
inline void do_dispatch(operation* op);
inline std::size_t do_run_one(mutex::scoped_lock& lock,
thread_info& this_thread, const boost::system::error_code& ec);
inline std::size_t do_poll_one(mutex::scoped_lock& lock,
thread_info& this_thread, const boost::system::error_code& ec);
inline void stop_all_threads(mutex::scoped_lock& lock);
inline bool wake_one_idle_thread_and_unlock(
mutex::scoped_lock& lock);
inline void wake_one_thread_and_unlock(
mutex::scoped_lock& lock);
struct task_cleanup;
friend struct task_cleanup;
struct work_cleanup;
friend struct work_cleanup;
const bool one_thread_;
mutable mutex mutex_;
reactor* task_;
struct task_operation : operation
{
task_operation() ;
} task_operation_;
bool task_interrupted_;
atomic_count outstanding_work_;
op_queue<operation> op_queue_;
bool stopped_;
bool shutdown_;
typedef call_stack<task_io_service, thread_info> thread_call_stack;
thread_info* first_idle_thread_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_TASK_IO_SERVICE_HPP
#define BOOST_ASIO_DETAIL_COMPLETION_HANDLER_HPP
#define BOOST_ASIO_DETAIL_FENCED_BLOCK_HPP
#define BOOST_ASIO_DETAIL_GCC_X86_FENCED_BLOCK_HPP
namespace boost {
namespace asio {
namespace detail {
class gcc_x86_fenced_block
: private noncopyable
{
public:
enum half_t { half };
enum full_t { full };
explicit gcc_x86_fenced_block(half_t)
;
explicit gcc_x86_fenced_block(full_t)
;
~gcc_x86_fenced_block()
;
private:
static int barrier()
;
static void lbarrier()
;
static void sbarrier()
;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
typedef gcc_x86_fenced_block fenced_block;
}
}
}
#define BOOST_ASIO_DETAIL_OPERATION_HPP
namespace boost {
namespace asio {
namespace detail {
typedef task_io_service_operation operation;
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Handler>
class completion_handler : public operation
{
public:
struct ptr { Handler* h; void* v; completion_handler* p; ~ptr() ; void reset() ; };
completion_handler(Handler& h)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_TASK_IO_SERVICE_IPP
#define BOOST_ASIO_DETAIL_LIMITS_HPP
#define BOOST_LIMITS
#define _GLIBCXX_NUMERIC_LIMITS 1
#define __glibcxx_integral_traps true
#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(T) ((T)(-1) < 0)
#define __glibcxx_min(T) (__glibcxx_signed (T) ? -__glibcxx_max (T) - 1 : (T)0)
#define __glibcxx_max(T) (__glibcxx_signed (T) ? (((((T)1 << (__glibcxx_digits (T) - 1)) - 1) << 1) + 1) : ~(T)0)
#define __glibcxx_digits(T) (sizeof(T) * __CHAR_BIT__ - __glibcxx_signed (T))
#define __glibcxx_digits10(T) (__glibcxx_digits (T) * 643L / 2136)
#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
};
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;
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;
};
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> { };
template<>
struct numeric_limits<bool>
{
static constexpr bool is_specialized = true;
static constexpr bool
min() noexcept { return false; }
static constexpr bool
max() noexcept { return true; }
static constexpr bool
lowest() noexcept { return min(); }
static constexpr int digits = 1;
static constexpr int digits10 = 0;
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr bool
epsilon() noexcept { return false; }
static constexpr bool
round_error() noexcept { return false; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr bool
infinity() noexcept { return false; }
static constexpr bool
quiet_NaN() noexcept { return false; }
static constexpr bool
signaling_NaN() noexcept { return false; }
static constexpr bool
denorm_min() noexcept { return false; }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<char>
{
static constexpr bool is_specialized = true;
static constexpr char
min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); }
static constexpr char
max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); }
static constexpr char
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = ((char)(-1) < 0);
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr char
epsilon() noexcept { return 0; }
static constexpr char
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr
char infinity() noexcept { return char(); }
static constexpr char
quiet_NaN() noexcept { return char(); }
static constexpr char
signaling_NaN() noexcept { return char(); }
static constexpr char
denorm_min() noexcept { return static_cast<char>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<signed char>
{
static constexpr bool is_specialized = true;
static constexpr signed char
min() noexcept { return -0x7f - 1; }
static constexpr signed char
max() noexcept { return 0x7f; }
static constexpr signed char
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
static constexpr int digits10
= ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr signed char
epsilon() noexcept { return 0; }
static constexpr signed char
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr signed char
infinity() noexcept { return static_cast<signed char>(0); }
static constexpr signed char
quiet_NaN() noexcept { return static_cast<signed char>(0); }
static constexpr signed char
signaling_NaN() noexcept
{ return static_cast<signed char>(0); }
static constexpr signed char
denorm_min() noexcept
{ return static_cast<signed char>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned char>
{
static constexpr bool is_specialized = true;
static constexpr unsigned char
min() noexcept { return 0; }
static constexpr unsigned char
max() noexcept { return 0x7f * 2U + 1; }
static constexpr unsigned char
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
static constexpr int digits10
= ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned char
epsilon() noexcept { return 0; }
static constexpr unsigned char
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned char
infinity() noexcept
{ return static_cast<unsigned char>(0); }
static constexpr unsigned char
quiet_NaN() noexcept
{ return static_cast<unsigned char>(0); }
static constexpr unsigned char
signaling_NaN() noexcept
{ return static_cast<unsigned char>(0); }
static constexpr unsigned char
denorm_min() noexcept
{ return static_cast<unsigned char>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<wchar_t>
{
static constexpr bool is_specialized = true;
static constexpr wchar_t
min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); }
static constexpr wchar_t
max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); }
static constexpr wchar_t
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
static constexpr int digits10
= ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = ((wchar_t)(-1) < 0);
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr wchar_t
epsilon() noexcept { return 0; }
static constexpr wchar_t
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr wchar_t
infinity() noexcept { return wchar_t(); }
static constexpr wchar_t
quiet_NaN() noexcept { return wchar_t(); }
static constexpr wchar_t
signaling_NaN() noexcept { return wchar_t(); }
static constexpr wchar_t
denorm_min() noexcept { return wchar_t(); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<char16_t>
{
static constexpr bool is_specialized = true;
static constexpr char16_t
min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); }
static constexpr char16_t
max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); }
static constexpr char16_t
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0));
static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = ((char16_t)(-1) < 0);
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr char16_t
epsilon() noexcept { return 0; }
static constexpr char16_t
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr char16_t
infinity() noexcept { return char16_t(); }
static constexpr char16_t
quiet_NaN() noexcept { return char16_t(); }
static constexpr char16_t
signaling_NaN() noexcept { return char16_t(); }
static constexpr char16_t
denorm_min() noexcept { return char16_t(); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
template<>
struct numeric_limits<char32_t>
{
static constexpr bool is_specialized = true;
static constexpr char32_t
min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); }
static constexpr char32_t
max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); }
static constexpr char32_t
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0));
static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = ((char32_t)(-1) < 0);
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr char32_t
epsilon() noexcept { return 0; }
static constexpr char32_t
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr char32_t
infinity() noexcept { return char32_t(); }
static constexpr char32_t
quiet_NaN() noexcept { return char32_t(); }
static constexpr char32_t
signaling_NaN() noexcept { return char32_t(); }
static constexpr char32_t
denorm_min() noexcept { return char32_t(); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
template<>
struct numeric_limits<short>
{
static constexpr bool is_specialized = true;
static constexpr short
min() noexcept { return -0x7fff - 1; }
static constexpr short
max() noexcept { return 0x7fff; }
static constexpr short
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr short
epsilon() noexcept { return 0; }
static constexpr short
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr short
infinity() noexcept { return short(); }
static constexpr short
quiet_NaN() noexcept { return short(); }
static constexpr short
signaling_NaN() noexcept { return short(); }
static constexpr short
denorm_min() noexcept { return short(); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned short>
{
static constexpr bool is_specialized = true;
static constexpr unsigned short
min() noexcept { return 0; }
static constexpr unsigned short
max() noexcept { return 0x7fff * 2U + 1; }
static constexpr unsigned short
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
static constexpr int digits10
= ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned short
epsilon() noexcept { return 0; }
static constexpr unsigned short
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned short
infinity() noexcept
{ return static_cast<unsigned short>(0); }
static constexpr unsigned short
quiet_NaN() noexcept
{ return static_cast<unsigned short>(0); }
static constexpr unsigned short
signaling_NaN() noexcept
{ return static_cast<unsigned short>(0); }
static constexpr unsigned short
denorm_min() noexcept
{ return static_cast<unsigned short>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<int>
{
static constexpr bool is_specialized = true;
static constexpr int
min() noexcept { return -0x7fffffff - 1; }
static constexpr int
max() noexcept { return 0x7fffffff; }
static constexpr int
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr int
epsilon() noexcept { return 0; }
static constexpr int
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr int
infinity() noexcept { return static_cast<int>(0); }
static constexpr int
quiet_NaN() noexcept { return static_cast<int>(0); }
static constexpr int
signaling_NaN() noexcept { return static_cast<int>(0); }
static constexpr int
denorm_min() noexcept { return static_cast<int>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned int>
{
static constexpr bool is_specialized = true;
static constexpr unsigned int
min() noexcept { return 0; }
static constexpr unsigned int
max() noexcept { return 0x7fffffff * 2U + 1; }
static constexpr unsigned int
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
static constexpr int digits10
= ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned int
epsilon() noexcept { return 0; }
static constexpr unsigned int
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned int
infinity() noexcept { return static_cast<unsigned int>(0); }
static constexpr unsigned int
quiet_NaN() noexcept
{ return static_cast<unsigned int>(0); }
static constexpr unsigned int
signaling_NaN() noexcept
{ return static_cast<unsigned int>(0); }
static constexpr unsigned int
denorm_min() noexcept
{ return static_cast<unsigned int>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<long>
{
static constexpr bool is_specialized = true;
static constexpr long
min() noexcept { return -0x7fffffffffffffffL - 1; }
static constexpr long
max() noexcept { return 0x7fffffffffffffffL; }
static constexpr long
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr long
epsilon() noexcept { return 0; }
static constexpr long
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr long
infinity() noexcept { return static_cast<long>(0); }
static constexpr long
quiet_NaN() noexcept { return static_cast<long>(0); }
static constexpr long
signaling_NaN() noexcept { return static_cast<long>(0); }
static constexpr long
denorm_min() noexcept { return static_cast<long>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned long>
{
static constexpr bool is_specialized = true;
static constexpr unsigned long
min() noexcept { return 0; }
static constexpr unsigned long
max() noexcept { return 0x7fffffffffffffffL * 2UL + 1; }
static constexpr unsigned long
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
static constexpr int digits10
= ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned long
epsilon() noexcept { return 0; }
static constexpr unsigned long
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned long
infinity() noexcept
{ return static_cast<unsigned long>(0); }
static constexpr unsigned long
quiet_NaN() noexcept
{ return static_cast<unsigned long>(0); }
static constexpr unsigned long
signaling_NaN() noexcept
{ return static_cast<unsigned long>(0); }
static constexpr unsigned long
denorm_min() noexcept
{ return static_cast<unsigned long>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<long long>
{
static constexpr bool is_specialized = true;
static constexpr long long
min() noexcept { return -0x7fffffffffffffffLL - 1; }
static constexpr long long
max() noexcept { return 0x7fffffffffffffffLL; }
static constexpr long long
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(long long) * 8 - ((long long)(-1) < 0));
static constexpr int digits10
= ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr long long
epsilon() noexcept { return 0; }
static constexpr long long
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr long long
infinity() noexcept { return static_cast<long long>(0); }
static constexpr long long
quiet_NaN() noexcept { return static_cast<long long>(0); }
static constexpr long long
signaling_NaN() noexcept
{ return static_cast<long long>(0); }
static constexpr long long
denorm_min() noexcept { return static_cast<long long>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned long long>
{
static constexpr bool is_specialized = true;
static constexpr unsigned long long
min() noexcept { return 0; }
static constexpr unsigned long long
max() noexcept { return 0x7fffffffffffffffLL * 2ULL + 1; }
static constexpr unsigned long long
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
static constexpr int digits10
= ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned long long
epsilon() noexcept { return 0; }
static constexpr unsigned long long
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned long long
infinity() noexcept
{ return static_cast<unsigned long long>(0); }
static constexpr unsigned long long
quiet_NaN() noexcept
{ return static_cast<unsigned long long>(0); }
static constexpr unsigned long long
signaling_NaN() noexcept
{ return static_cast<unsigned long long>(0); }
static constexpr unsigned long long
denorm_min() noexcept
{ return static_cast<unsigned long long>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<float>
{
static constexpr bool is_specialized = true;
static constexpr float
min() noexcept { return 1.17549435082228750797e-38F; }
static constexpr float
max() noexcept { return 3.40282346638528859812e+38F; }
static constexpr float
lowest() noexcept { return -3.40282346638528859812e+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.19209289550781250000e-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.40129846432481707092e-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 double(2.22507385850720138309e-308L); }
static constexpr double
max() noexcept { return double(1.79769313486231570815e+308L); }
static constexpr double
lowest() noexcept { return -double(1.79769313486231570815e+308L); }
static constexpr int digits = 53;
static constexpr int digits10 = 15;
static constexpr int max_digits10
= (2 + (53) * 643L / 2136);
static constexpr bool is_signed = true;
static constexpr bool is_integer = false;
static constexpr bool is_exact = false;
static constexpr int radix = 2;
static constexpr double
epsilon() noexcept { return double(2.22044604925031308085e-16L); }
static constexpr double
round_error() noexcept { return 0.5; }
static constexpr int min_exponent = (-1021);
static constexpr int min_exponent10 = (-307);
static constexpr int max_exponent = 1024;
static constexpr int max_exponent10 = 308;
static constexpr bool has_infinity = 1;
static constexpr bool has_quiet_NaN = 1;
static constexpr bool has_signaling_NaN = has_quiet_NaN;
static constexpr float_denorm_style has_denorm
= bool(1) ? denorm_present : denorm_absent;
static constexpr bool has_denorm_loss
= false;
static constexpr double
infinity() noexcept { return __builtin_huge_val(); }
static constexpr double
quiet_NaN() noexcept { return __builtin_nan(""); }
static constexpr double
signaling_NaN() noexcept { return __builtin_nans(""); }
static constexpr double
denorm_min() noexcept { return double(4.94065645841246544177e-324L); }
static constexpr bool is_iec559
= has_infinity && has_quiet_NaN && has_denorm == denorm_present;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = false;
static constexpr bool tinyness_before
= false;
static constexpr float_round_style round_style
= round_to_nearest;
};
#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.36210314311209350626e-4932L; }
static constexpr long double
max() noexcept { return 1.18973149535723176502e+4932L; }
static constexpr long double
lowest() noexcept { return -1.18973149535723176502e+4932L; }
static constexpr int digits = 64;
static constexpr int digits10 = 18;
static constexpr int max_digits10
= (2 + (64) * 643L / 2136);
static constexpr bool is_signed = true;
static constexpr bool is_integer = false;
static constexpr bool is_exact = false;
static constexpr int radix = 2;
static constexpr long double
epsilon() noexcept { return 1.08420217248550443401e-19L; }
static constexpr long double
round_error() noexcept { return 0.5L; }
static constexpr int min_exponent = (-16381);
static constexpr int min_exponent10 = (-4931);
static constexpr int max_exponent = 16384;
static constexpr int max_exponent10 = 4932;
static constexpr bool has_infinity = 1;
static constexpr bool has_quiet_NaN = 1;
static constexpr bool has_signaling_NaN = has_quiet_NaN;
static constexpr float_denorm_style has_denorm
= bool(1) ? denorm_present : denorm_absent;
static constexpr bool has_denorm_loss
= false;
static constexpr long double
infinity() noexcept { return __builtin_huge_vall(); }
static constexpr long double
quiet_NaN() noexcept { return __builtin_nanl(""); }
static constexpr long double
signaling_NaN() noexcept { return __builtin_nansl(""); }
static constexpr long double
denorm_min() noexcept { return 3.64519953188247460253e-4951L; }
static constexpr bool is_iec559
= has_infinity && has_quiet_NaN && has_denorm == denorm_present;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = false;
static constexpr bool tinyness_before =
false;
static constexpr float_round_style round_style =
round_to_nearest;
};
#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
#define BOOST_ASIO_DETAIL_REACTOR_HPP
#define BOOST_ASIO_DETAIL_EPOLL_REACTOR_HPP
#define BOOST_ASIO_DETAIL_OBJECT_POOL_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Object>
class object_pool;
class object_pool_access
{
public:
template <typename Object>
static Object* create()
;
template <typename Object>
static void destroy(Object* o)
;
template <typename Object>
static Object*& next(Object* o)
;
template <typename Object>
static Object*& prev(Object* o)
;
};
template <typename Object>
class object_pool
: private noncopyable
{
public:
object_pool()
;
~object_pool()
;
Object* first()
;
Object* alloc()
;
void free(Object* o)
;
private:
void destroy_list(Object* list)
;
Object* live_list_;
Object* free_list_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTOR_OP_HPP
namespace boost {
namespace asio {
namespace detail {
class reactor_op
: public operation
{
public:
boost::system::error_code ec_;
std::size_t bytes_transferred_;
bool perform()
;
protected:
typedef bool (*perform_func_type)(reactor_op*);
reactor_op(perform_func_type perform_func, func_type complete_func)
;
private:
perform_func_type perform_func_;
};
}
}
}
#define BOOST_ASIO_DETAIL_SELECT_INTERRUPTER_HPP
#define BOOST_ASIO_DETAIL_EVENTFD_SELECT_INTERRUPTER_HPP
namespace boost {
namespace asio {
namespace detail {
class eventfd_select_interrupter
{
public:
inline eventfd_select_interrupter();
inline ~eventfd_select_interrupter();
inline void recreate();
inline void interrupt();
inline bool reset();
int read_descriptor() const
;
private:
inline void open_descriptors();
inline void close_descriptors();
int read_descriptor_;
int write_descriptor_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_EVENTFD_SELECT_INTERRUPTER_IPP
#define _SYS_STAT_H 1
#define __need_time_t
#define __need_timespec
extern "C" {
#define _BITS_STAT_H 1
#define _STAT_VER_KERNEL 0
#define _STAT_VER_LINUX 1
#define _MKNOD_VER_LINUX 0
#define _STAT_VER _STAT_VER_LINUX
struct stat
{
__dev_t st_dev;
__ino_t st_ino;
__nlink_t st_nlink;
__mode_t st_mode;
__uid_t st_uid;
__gid_t st_gid;
int __pad0;
__dev_t st_rdev;
__off_t st_size;
__blksize_t st_blksize;
__blkcnt_t st_blocks;
struct timespec st_atim;
struct timespec st_mtim;
struct timespec st_ctim;
#define st_atime st_atim.tv_sec
#define st_mtime st_mtim.tv_sec
#define st_ctime st_ctim.tv_sec
__syscall_slong_t __glibc_reserved[3];
};
struct stat64
{
__dev_t st_dev;
__ino64_t st_ino;
__nlink_t st_nlink;
__mode_t st_mode;
__uid_t st_uid;
__gid_t st_gid;
int __pad0;
__dev_t st_rdev;
__off_t st_size;
__blksize_t st_blksize;
__blkcnt64_t st_blocks;
struct timespec st_atim;
struct timespec st_mtim;
struct timespec st_ctim;
__syscall_slong_t __glibc_reserved[3];
};
#define _STATBUF_ST_BLKSIZE
#define _STATBUF_ST_RDEV
#define _STATBUF_ST_NSEC
#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) ((buf)->st_mode - (buf)->st_mode)
#define __S_TYPEISSEM(buf) ((buf)->st_mode - (buf)->st_mode)
#define __S_TYPEISSHM(buf) ((buf)->st_mode - (buf)->st_mode)
#define __S_ISUID 04000
#define __S_ISGID 02000
#define __S_ISVTX 01000
#define __S_IREAD 0400
#define __S_IWRITE 0200
#define __S_IEXEC 0100
#define UTIME_NOW ((1l << 30) - 1l)
#define UTIME_OMIT ((1l << 30) - 2l)
#define S_IFMT __S_IFMT
#define S_IFDIR __S_IFDIR
#define S_IFCHR __S_IFCHR
#define S_IFBLK __S_IFBLK
#define S_IFREG __S_IFREG
#define S_IFIFO __S_IFIFO
#define S_IFLNK __S_IFLNK
#define S_IFSOCK __S_IFSOCK
#define __S_ISTYPE(mode,mask) (((mode) & __S_IFMT) == (mask))
#define S_ISDIR(mode) __S_ISTYPE((mode), __S_IFDIR)
#define S_ISCHR(mode) __S_ISTYPE((mode), __S_IFCHR)
#define S_ISBLK(mode) __S_ISTYPE((mode), __S_IFBLK)
#define S_ISREG(mode) __S_ISTYPE((mode), __S_IFREG)
#define S_ISFIFO(mode) __S_ISTYPE((mode), __S_IFIFO)
#define S_ISLNK(mode) __S_ISTYPE((mode), __S_IFLNK)
#define S_ISSOCK(mode) __S_ISTYPE((mode), __S_IFSOCK)
#define S_TYPEISMQ(buf) __S_TYPEISMQ(buf)
#define S_TYPEISSEM(buf) __S_TYPEISSEM(buf)
#define S_TYPEISSHM(buf) __S_TYPEISSHM(buf)
#define S_ISUID __S_ISUID
#define S_ISGID __S_ISGID
#define S_ISVTX __S_ISVTX
#define S_IRUSR __S_IREAD
#define S_IWUSR __S_IWRITE
#define S_IXUSR __S_IEXEC
#define S_IRWXU (__S_IREAD|__S_IWRITE|__S_IEXEC)
#define S_IREAD S_IRUSR
#define S_IWRITE S_IWUSR
#define S_IEXEC S_IXUSR
#define S_IRGRP (S_IRUSR >> 3)
#define S_IWGRP (S_IWUSR >> 3)
#define S_IXGRP (S_IXUSR >> 3)
#define S_IRWXG (S_IRWXU >> 3)
#define S_IROTH (S_IRGRP >> 3)
#define S_IWOTH (S_IWGRP >> 3)
#define S_IXOTH (S_IXGRP >> 3)
#define S_IRWXO (S_IRWXG >> 3)
#define ACCESSPERMS (S_IRWXU|S_IRWXG|S_IRWXO)
#define ALLPERMS (S_ISUID|S_ISGID|S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO)
#define DEFFILEMODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)
#define S_BLKSIZE 512
extern int stat (const char *__restrict __file,
struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int fstat (int __fd, struct stat *__buf) throw () __attribute__ ((__nonnull__ (2)));
extern int stat64 (const char *__restrict __file,
struct stat64 *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int fstat64 (int __fd, struct stat64 *__buf) throw () __attribute__ ((__nonnull__ (2)));
extern int fstatat (int __fd, const char *__restrict __file,
struct stat *__restrict __buf, int __flag)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern int fstatat64 (int __fd, const char *__restrict __file,
struct stat64 *__restrict __buf, int __flag)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern int lstat (const char *__restrict __file,
struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int lstat64 (const char *__restrict __file,
struct stat64 *__restrict __buf)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int chmod (const char *__file, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (1)));
extern int lchmod (const char *__file, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (1)));
extern int fchmod (int __fd, __mode_t __mode) throw ();
extern int fchmodat (int __fd, const char *__file, __mode_t __mode,
int __flag)
throw () __attribute__ ((__nonnull__ (2))) ;
extern __mode_t umask (__mode_t __mask) throw ();
extern __mode_t getumask (void) throw ();
extern int mkdir (const char *__path, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (1)));
extern int mkdirat (int __fd, const char *__path, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (2)));
extern int mknod (const char *__path, __mode_t __mode, __dev_t __dev)
throw () __attribute__ ((__nonnull__ (1)));
extern int mknodat (int __fd, const char *__path, __mode_t __mode,
__dev_t __dev) throw () __attribute__ ((__nonnull__ (2)));
extern int mkfifo (const char *__path, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (1)));
extern int mkfifoat (int __fd, const char *__path, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (2)));
extern int utimensat (int __fd, const char *__path,
const struct timespec __times[2],
int __flags)
throw () __attribute__ ((__nonnull__ (2)));
extern int futimens (int __fd, const struct timespec __times[2]) throw ();
#define _MKNOD_VER 0
extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf)
throw () __attribute__ ((__nonnull__ (3)));
extern int __xstat (int __ver, const char *__filename,
struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __lxstat (int __ver, const char *__filename,
struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __fxstatat (int __ver, int __fildes, const char *__filename,
struct stat *__stat_buf, int __flag)
throw () __attribute__ ((__nonnull__ (3, 4)));
extern int __fxstat64 (int __ver, int __fildes, struct stat64 *__stat_buf)
throw () __attribute__ ((__nonnull__ (3)));
extern int __xstat64 (int __ver, const char *__filename,
struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __lxstat64 (int __ver, const char *__filename,
struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __fxstatat64 (int __ver, int __fildes, const char *__filename,
struct stat64 *__stat_buf, int __flag)
throw () __attribute__ ((__nonnull__ (3, 4)));
extern int __xmknod (int __ver, const char *__path, __mode_t __mode,
__dev_t *__dev) throw () __attribute__ ((__nonnull__ (2, 4)));
extern int __xmknodat (int __ver, int __fd, const char *__path,
__mode_t __mode, __dev_t *__dev)
throw () __attribute__ ((__nonnull__ (3, 5)));
}
#define _FCNTL_H 1
extern "C" {
#define __O_LARGEFILE 0
#define F_GETLK64 5
#define F_SETLK64 6
#define F_SETLKW64 7
struct flock
{
short int l_type;
short int l_whence;
__off_t l_start;
__off_t l_len;
__pid_t l_pid;
};
struct flock64
{
short int l_type;
short int l_whence;
__off64_t l_start;
__off64_t l_len;
__pid_t l_pid;
};
#define O_ACCMODE 0003
#define O_RDONLY 00
#define O_WRONLY 01
#define O_RDWR 02
#define O_CREAT 0100
#define O_EXCL 0200
#define O_NOCTTY 0400
#define O_TRUNC 01000
#define O_APPEND 02000
#define O_NONBLOCK 04000
#define O_NDELAY O_NONBLOCK
#define O_SYNC 04010000
#define O_FSYNC O_SYNC
#define O_ASYNC 020000
#define __O_DIRECTORY 0200000
#define __O_NOFOLLOW 0400000
#define __O_CLOEXEC 02000000
#define __O_DIRECT 040000
#define __O_NOATIME 01000000
#define __O_PATH 010000000
#define __O_DSYNC 010000
#define __O_TMPFILE 020200000
#define F_GETLK 5
#define F_SETLK 6
#define F_SETLKW 7
#define O_LARGEFILE __O_LARGEFILE
#define O_DIRECTORY __O_DIRECTORY
#define O_NOFOLLOW __O_NOFOLLOW
#define O_CLOEXEC __O_CLOEXEC
#define O_DIRECT __O_DIRECT
#define O_NOATIME __O_NOATIME
#define O_PATH __O_PATH
#define O_TMPFILE __O_TMPFILE
#define O_DSYNC __O_DSYNC
#define O_RSYNC O_SYNC
#define F_DUPFD 0
#define F_GETFD 1
#define F_SETFD 2
#define F_GETFL 3
#define F_SETFL 4
#define __F_SETOWN 8
#define __F_GETOWN 9
#define F_SETOWN __F_SETOWN
#define F_GETOWN __F_GETOWN
#define __F_SETSIG 10
#define __F_GETSIG 11
#define __F_SETOWN_EX 15
#define __F_GETOWN_EX 16
#define F_SETSIG __F_SETSIG
#define F_GETSIG __F_GETSIG
#define F_SETOWN_EX __F_SETOWN_EX
#define F_GETOWN_EX __F_GETOWN_EX
#define F_SETLEASE 1024
#define F_GETLEASE 1025
#define F_NOTIFY 1026
#define F_SETPIPE_SZ 1031
#define F_GETPIPE_SZ 1032
#define F_DUPFD_CLOEXEC 1030
#define FD_CLOEXEC 1
#define F_RDLCK 0
#define F_WRLCK 1
#define F_UNLCK 2
#define F_EXLCK 4
#define F_SHLCK 8
#define LOCK_SH 1
#define LOCK_EX 2
#define LOCK_NB 4
#define LOCK_UN 8
#define LOCK_MAND 32
#define LOCK_READ 64
#define LOCK_WRITE 128
#define LOCK_RW 192
#define DN_ACCESS 0x00000001
#define DN_MODIFY 0x00000002
#define DN_CREATE 0x00000004
#define DN_DELETE 0x00000008
#define DN_RENAME 0x00000010
#define DN_ATTRIB 0x00000020
#define DN_MULTISHOT 0x80000000
enum __pid_type
{
F_OWNER_TID = 0,
F_OWNER_PID,
F_OWNER_PGRP,
F_OWNER_GID = F_OWNER_PGRP
};
struct f_owner_ex
{
enum __pid_type type;
__pid_t pid;
};
#define FAPPEND O_APPEND
#define FFSYNC O_FSYNC
#define FASYNC O_ASYNC
#define FNONBLOCK O_NONBLOCK
#define FNDELAY O_NDELAY
#define __POSIX_FADV_DONTNEED 4
#define __POSIX_FADV_NOREUSE 5
#define POSIX_FADV_NORMAL 0
#define POSIX_FADV_RANDOM 1
#define POSIX_FADV_SEQUENTIAL 2
#define POSIX_FADV_WILLNEED 3
#define POSIX_FADV_DONTNEED __POSIX_FADV_DONTNEED
#define POSIX_FADV_NOREUSE __POSIX_FADV_NOREUSE
#define SYNC_FILE_RANGE_WAIT_BEFORE 1
#define SYNC_FILE_RANGE_WRITE 2
#define SYNC_FILE_RANGE_WAIT_AFTER 4
#define SPLICE_F_MOVE 1
#define SPLICE_F_NONBLOCK 2
#define SPLICE_F_MORE 4
#define SPLICE_F_GIFT 8
#define FALLOC_FL_KEEP_SIZE 1
#define FALLOC_FL_PUNCH_HOLE 2
struct file_handle
{
unsigned int handle_bytes;
int handle_type;
unsigned char f_handle[0];
};
#define MAX_HANDLE_SZ 128
#define AT_FDCWD -100
#define AT_SYMLINK_NOFOLLOW 0x100
#define AT_REMOVEDIR 0x200
#define AT_SYMLINK_FOLLOW 0x400
#define AT_NO_AUTOMOUNT 0x800
#define AT_EMPTY_PATH 0x1000
#define AT_EACCESS 0x200
extern "C" {
extern ssize_t readahead (int __fd, __off64_t __offset, size_t __count)
throw ();
extern int sync_file_range (int __fd, __off64_t __offset, __off64_t __count,
unsigned int __flags);
extern ssize_t vmsplice (int __fdout, const struct iovec *__iov,
size_t __count, unsigned int __flags);
extern ssize_t splice (int __fdin, __off64_t *__offin, int __fdout,
__off64_t *__offout, size_t __len,
unsigned int __flags);
extern ssize_t tee (int __fdin, int __fdout, size_t __len,
unsigned int __flags);
extern int fallocate (int __fd, int __mode, __off_t __offset, __off_t __len);
extern int fallocate64 (int __fd, int __mode, __off64_t __offset,
__off64_t __len);
extern int name_to_handle_at (int __dfd, const char *__name,
struct file_handle *__handle, int *__mnt_id,
int __flags) throw ();
extern int open_by_handle_at (int __mountdirfd, struct file_handle *__handle,
int __flags);
}
#define __need_timespec
#define S_IFMT __S_IFMT
#define S_IFDIR __S_IFDIR
#define S_IFCHR __S_IFCHR
#define S_IFBLK __S_IFBLK
#define S_IFREG __S_IFREG
#define S_IFIFO __S_IFIFO
#define S_IFLNK __S_IFLNK
#define S_IFSOCK __S_IFSOCK
#define S_ISUID __S_ISUID
#define S_ISGID __S_ISGID
#define S_ISVTX __S_ISVTX
#define S_IRUSR __S_IREAD
#define S_IWUSR __S_IWRITE
#define S_IXUSR __S_IEXEC
#define S_IRWXU (__S_IREAD|__S_IWRITE|__S_IEXEC)
#define S_IRGRP (S_IRUSR >> 3)
#define S_IWGRP (S_IWUSR >> 3)
#define S_IXGRP (S_IXUSR >> 3)
#define S_IRWXG (S_IRWXU >> 3)
#define S_IROTH (S_IRGRP >> 3)
#define S_IWOTH (S_IWGRP >> 3)
#define S_IXOTH (S_IXGRP >> 3)
#define S_IRWXO (S_IRWXG >> 3)
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2
extern int fcntl (int __fd, int __cmd, ...);
extern int open (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
extern int open64 (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
extern int openat (int __fd, const char *__file, int __oflag, ...)
__attribute__ ((__nonnull__ (2)));
extern int openat64 (int __fd, const char *__file, int __oflag, ...)
__attribute__ ((__nonnull__ (2)));
extern int creat (const char *__file, mode_t __mode) __attribute__ ((__nonnull__ (1)));
extern int creat64 (const char *__file, mode_t __mode) __attribute__ ((__nonnull__ (1)));
extern int posix_fadvise (int __fd, off_t __offset, off_t __len,
int __advise) throw ();
extern int posix_fadvise64 (int __fd, off64_t __offset, off64_t __len,
int __advise) throw ();
extern int posix_fallocate (int __fd, off_t __offset, off_t __len);
extern int posix_fallocate64 (int __fd, off64_t __offset, off64_t __len);
}
#define _SYS_EVENTFD_H 1
enum
{
EFD_SEMAPHORE = 00000001,
#define EFD_SEMAPHORE EFD_SEMAPHORE
EFD_CLOEXEC = 02000000,
#define EFD_CLOEXEC EFD_CLOEXEC
EFD_NONBLOCK = 00004000
#define EFD_NONBLOCK EFD_NONBLOCK
};
typedef uint64_t eventfd_t;
extern "C" {
extern int eventfd (int __count, int __flags) throw ();
extern int eventfd_read (int __fd, eventfd_t *__value);
extern int eventfd_write (int __fd, eventfd_t __value);
}
#define BOOST_ASIO_DETAIL_CSTDINT_HPP
namespace boost {
namespace asio {
using std::int16_t;
using std::uint16_t;
using std::int32_t;
using std::uint32_t;
using std::int64_t;
using std::uint64_t;
}
}
namespace boost {
namespace asio {
namespace detail {
bool eventfd_select_interrupter::reset()
{
if (write_descriptor_ == read_descriptor_)
{
for (;;)
{
uint64_t counter(0);
(*__errno_location ()) = 0;
int bytes_read = ::read(read_descriptor_, &counter, sizeof(uint64_t));
if (bytes_read < 0 && (*__errno_location ()) == 4)
continue;
bool was_interrupted = (bytes_read > 0);
return was_interrupted;
}
}
else
{
for (;;)
{
char data[1024];
int bytes_read = ::read(read_descriptor_, data, sizeof(data));
if (bytes_read < 0 && (*__errno_location ()) == 4)
continue;
bool was_interrupted = (bytes_read > 0);
while (bytes_read == sizeof(data))
bytes_read = ::read(read_descriptor_, data, sizeof(data));
return was_interrupted;
}
}
}
}
}
}
namespace boost {
namespace asio {
namespace detail {
typedef eventfd_select_interrupter select_interrupter;
}
}
}
#define BOOST_ASIO_DETAIL_SOCKET_TYPES_HPP
#define _SYS_IOCTL_H 1
extern "C" {
#define __ASM_GENERIC_IOCTLS_H
#define _LINUX_IOCTL_H
#define _ASM_GENERIC_IOCTL_H
#define _IOC_NRBITS 8
#define _IOC_TYPEBITS 8
#define _IOC_SIZEBITS 14
#define _IOC_DIRBITS 2
#define _IOC_NRMASK ((1 << _IOC_NRBITS)-1)
#define _IOC_TYPEMASK ((1 << _IOC_TYPEBITS)-1)
#define _IOC_SIZEMASK ((1 << _IOC_SIZEBITS)-1)
#define _IOC_DIRMASK ((1 << _IOC_DIRBITS)-1)
#define _IOC_NRSHIFT 0
#define _IOC_TYPESHIFT (_IOC_NRSHIFT+_IOC_NRBITS)
#define _IOC_SIZESHIFT (_IOC_TYPESHIFT+_IOC_TYPEBITS)
#define _IOC_DIRSHIFT (_IOC_SIZESHIFT+_IOC_SIZEBITS)
#define _IOC_NONE 0U
#define _IOC_WRITE 1U
#define _IOC_READ 2U
#define _IOC(dir,type,nr,size) (((dir) << _IOC_DIRSHIFT) | ((type) << _IOC_TYPESHIFT) | ((nr) << _IOC_NRSHIFT) | ((size) << _IOC_SIZESHIFT))
#define _IOC_TYPECHECK(t) (sizeof(t))
#define _IO(type,nr) _IOC(_IOC_NONE,(type),(nr),0)
#define _IOR(type,nr,size) _IOC(_IOC_READ,(type),(nr),(_IOC_TYPECHECK(size)))
#define _IOW(type,nr,size) _IOC(_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(size)))
#define _IOWR(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(size)))
#define _IOR_BAD(type,nr,size) _IOC(_IOC_READ,(type),(nr),sizeof(size))
#define _IOW_BAD(type,nr,size) _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
#define _IOWR_BAD(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))
#define _IOC_DIR(nr) (((nr) >> _IOC_DIRSHIFT) & _IOC_DIRMASK)
#define _IOC_TYPE(nr) (((nr) >> _IOC_TYPESHIFT) & _IOC_TYPEMASK)
#define _IOC_NR(nr) (((nr) >> _IOC_NRSHIFT) & _IOC_NRMASK)
#define _IOC_SIZE(nr) (((nr) >> _IOC_SIZESHIFT) & _IOC_SIZEMASK)
#define IOC_IN (_IOC_WRITE << _IOC_DIRSHIFT)
#define IOC_OUT (_IOC_READ << _IOC_DIRSHIFT)
#define IOC_INOUT ((_IOC_WRITE|_IOC_READ) << _IOC_DIRSHIFT)
#define IOCSIZE_MASK (_IOC_SIZEMASK << _IOC_SIZESHIFT)
#define IOCSIZE_SHIFT (_IOC_SIZESHIFT)
#define TCGETS 0x5401
#define TCSETS 0x5402
#define TCSETSW 0x5403
#define TCSETSF 0x5404
#define TCGETA 0x5405
#define TCSETA 0x5406
#define TCSETAW 0x5407
#define TCSETAF 0x5408
#define TCSBRK 0x5409
#define TCXONC 0x540A
#define TCFLSH 0x540B
#define TIOCEXCL 0x540C
#define TIOCNXCL 0x540D
#define TIOCSCTTY 0x540E
#define TIOCGPGRP 0x540F
#define TIOCSPGRP 0x5410
#define TIOCOUTQ 0x5411
#define TIOCSTI 0x5412
#define TIOCGWINSZ 0x5413
#define TIOCSWINSZ 0x5414
#define TIOCMGET 0x5415
#define TIOCMBIS 0x5416
#define TIOCMBIC 0x5417
#define TIOCMSET 0x5418
#define TIOCGSOFTCAR 0x5419
#define TIOCSSOFTCAR 0x541A
#define FIONREAD 0x541B
#define TIOCINQ FIONREAD
#define TIOCLINUX 0x541C
#define TIOCCONS 0x541D
#define TIOCGSERIAL 0x541E
#define TIOCSSERIAL 0x541F
#define TIOCPKT 0x5420
#define FIONBIO 0x5421
#define TIOCNOTTY 0x5422
#define TIOCSETD 0x5423
#define TIOCGETD 0x5424
#define TCSBRKP 0x5425
#define TIOCSBRK 0x5427
#define TIOCCBRK 0x5428
#define TIOCGSID 0x5429
#define TCGETS2 _IOR('T', 0x2A, struct termios2)
#define TCSETS2 _IOW('T', 0x2B, struct termios2)
#define TCSETSW2 _IOW('T', 0x2C, struct termios2)
#define TCSETSF2 _IOW('T', 0x2D, struct termios2)
#define TIOCGRS485 0x542E
#define TIOCSRS485 0x542F
#define TIOCGPTN _IOR('T', 0x30, unsigned int)
#define TIOCSPTLCK _IOW('T', 0x31, int)
#define TIOCGDEV _IOR('T', 0x32, unsigned int)
#define TCGETX 0x5432
#define TCSETX 0x5433
#define TCSETXF 0x5434
#define TCSETXW 0x5435
#define TIOCSIG _IOW('T', 0x36, int)
#define TIOCVHANGUP 0x5437
#define TIOCGPKT _IOR('T', 0x38, int)
#define TIOCGPTLCK _IOR('T', 0x39, int)
#define TIOCGEXCL _IOR('T', 0x40, int)
#define FIONCLEX 0x5450
#define FIOCLEX 0x5451
#define FIOASYNC 0x5452
#define TIOCSERCONFIG 0x5453
#define TIOCSERGWILD 0x5454
#define TIOCSERSWILD 0x5455
#define TIOCGLCKTRMIOS 0x5456
#define TIOCSLCKTRMIOS 0x5457
#define TIOCSERGSTRUCT 0x5458
#define TIOCSERGETLSR 0x5459
#define TIOCSERGETMULTI 0x545A
#define TIOCSERSETMULTI 0x545B
#define TIOCMIWAIT 0x545C
#define TIOCGICOUNT 0x545D
#define FIOQSIZE 0x5460
#define TIOCPKT_DATA 0
#define TIOCPKT_FLUSHREAD 1
#define TIOCPKT_FLUSHWRITE 2
#define TIOCPKT_STOP 4
#define TIOCPKT_START 8
#define TIOCPKT_NOSTOP 16
#define TIOCPKT_DOSTOP 32
#define TIOCPKT_IOCTL 64
#define TIOCSER_TEMT 0x01
#define SIOCADDRT 0x890B
#define SIOCDELRT 0x890C
#define SIOCRTMSG 0x890D
#define SIOCGIFNAME 0x8910
#define SIOCSIFLINK 0x8911
#define SIOCGIFCONF 0x8912
#define SIOCGIFFLAGS 0x8913
#define SIOCSIFFLAGS 0x8914
#define SIOCGIFADDR 0x8915
#define SIOCSIFADDR 0x8916
#define SIOCGIFDSTADDR 0x8917
#define SIOCSIFDSTADDR 0x8918
#define SIOCGIFBRDADDR 0x8919
#define SIOCSIFBRDADDR 0x891a
#define SIOCGIFNETMASK 0x891b
#define SIOCSIFNETMASK 0x891c
#define SIOCGIFMETRIC 0x891d
#define SIOCSIFMETRIC 0x891e
#define SIOCGIFMEM 0x891f
#define SIOCSIFMEM 0x8920
#define SIOCGIFMTU 0x8921
#define SIOCSIFMTU 0x8922
#define SIOCSIFNAME 0x8923
#define SIOCSIFHWADDR 0x8924
#define SIOCGIFENCAP 0x8925
#define SIOCSIFENCAP 0x8926
#define SIOCGIFHWADDR 0x8927
#define SIOCGIFSLAVE 0x8929
#define SIOCSIFSLAVE 0x8930
#define SIOCADDMULTI 0x8931
#define SIOCDELMULTI 0x8932
#define SIOCGIFINDEX 0x8933
#define SIOGIFINDEX SIOCGIFINDEX
#define SIOCSIFPFLAGS 0x8934
#define SIOCGIFPFLAGS 0x8935
#define SIOCDIFADDR 0x8936
#define SIOCSIFHWBROADCAST 0x8937
#define SIOCGIFCOUNT 0x8938
#define SIOCGIFBR 0x8940
#define SIOCSIFBR 0x8941
#define SIOCGIFTXQLEN 0x8942
#define SIOCSIFTXQLEN 0x8943
#define SIOCDARP 0x8953
#define SIOCGARP 0x8954
#define SIOCSARP 0x8955
#define SIOCDRARP 0x8960
#define SIOCGRARP 0x8961
#define SIOCSRARP 0x8962
#define SIOCGIFMAP 0x8970
#define SIOCSIFMAP 0x8971
#define SIOCADDDLCI 0x8980
#define SIOCDELDLCI 0x8981
#define SIOCDEVPRIVATE 0x89F0
#define SIOCPROTOPRIVATE 0x89E0
struct winsize
{
unsigned short int ws_row;
unsigned short int ws_col;
unsigned short int ws_xpixel;
unsigned short int ws_ypixel;
};
#define NCC 8
struct termio
{
unsigned short int c_iflag;
unsigned short int c_oflag;
unsigned short int c_cflag;
unsigned short int c_lflag;
unsigned char c_line;
unsigned char c_cc[8];
};
#define TIOCM_LE 0x001
#define TIOCM_DTR 0x002
#define TIOCM_RTS 0x004
#define TIOCM_ST 0x008
#define TIOCM_SR 0x010
#define TIOCM_CTS 0x020
#define TIOCM_CAR 0x040
#define TIOCM_RNG 0x080
#define TIOCM_DSR 0x100
#define TIOCM_CD TIOCM_CAR
#define TIOCM_RI TIOCM_RNG
#define N_TTY 0
#define N_SLIP 1
#define N_MOUSE 2
#define N_PPP 3
#define N_STRIP 4
#define N_AX25 5
#define N_X25 6
#define N_6PACK 7
#define N_MASC 8
#define N_R3964 9
#define N_PROFIBUS_FDL 10
#define N_IRDA 11
#define N_SMSBLOCK 12
#define N_HDLC 13
#define N_SYNC_PPP 14
#define N_HCI 15
#define _SYS_TTYDEFAULTS_H_
#define TTYDEF_IFLAG (BRKINT | ISTRIP | ICRNL | IMAXBEL | IXON | IXANY)
#define TTYDEF_OFLAG (OPOST | ONLCR | XTABS)
#define TTYDEF_LFLAG (ECHO | ICANON | ISIG | IEXTEN | ECHOE|ECHOKE|ECHOCTL)
#define TTYDEF_CFLAG (CREAD | CS7 | PARENB | HUPCL)
#define TTYDEF_SPEED (B9600)
#define CTRL(x) (x&037)
#define CEOF CTRL('d')
#define CEOL _POSIX_VDISABLE
#define CERASE 0177
#define CINTR CTRL('c')
#define CSTATUS _POSIX_VDISABLE
#define CKILL CTRL('u')
#define CMIN 1
#define CQUIT 034
#define CSUSP CTRL('z')
#define CTIME 0
#define CDSUSP CTRL('y')
#define CSTART CTRL('q')
#define CSTOP CTRL('s')
#define CLNEXT CTRL('v')
#define CDISCARD CTRL('o')
#define CWERASE CTRL('w')
#define CREPRINT CTRL('r')
#define CEOT CEOF
#define CBRK CEOL
#define CRPRNT CREPRINT
#define CFLUSH CDISCARD
extern int ioctl (int __fd, unsigned long int __request, ...) throw ();
}
#define _SYS_POLL_H 1
#define POLLIN 0x001
#define POLLPRI 0x002
#define POLLOUT 0x004
#define POLLRDNORM 0x040
#define POLLRDBAND 0x080
#define POLLWRNORM 0x100
#define POLLWRBAND 0x200
#define POLLMSG 0x400
#define POLLREMOVE 0x1000
#define POLLRDHUP 0x2000
#define POLLERR 0x008
#define POLLHUP 0x010
#define POLLNVAL 0x020
#define __need_timespec
typedef unsigned long int nfds_t;
struct pollfd
{
int fd;
short int events;
short int revents;
};
extern "C" {
extern int poll (struct pollfd *__fds, nfds_t __nfds, int __timeout);
extern int ppoll (struct pollfd *__fds, nfds_t __nfds,
const struct timespec *__timeout,
const __sigset_t *__ss);
}
#define _SYS_UN_H 1
extern "C" {
struct sockaddr_un
{
sa_family_t sun_family;
char sun_path[108];
};
#define _STRING_H 1
extern "C" {
#define __need_size_t
#define __need_NULL
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define __CORRECT_ISO_CPP_STRING_H_PROTO
extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *memmove (void *__dest, const void *__src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
int __c, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern int memcmp (const void *__s1, const void *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++"
{
extern void *memchr (void *__s, int __c, size_t __n)
throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const void *memchr (const void *__s, int __c, size_t __n)
throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
}
extern "C++" void *rawmemchr (void *__s, int __c)
throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const void *rawmemchr (const void *__s, int __c)
throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" void *memrchr (void *__s, int __c, size_t __n)
throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const void *memrchr (const void *__s, int __c, size_t __n)
throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strncpy (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strcat (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strncat (char *__restrict __dest, const char *__restrict __src,
size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int strcmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strncmp (const char *__s1, const char *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strcoll (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern size_t strxfrm (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (2)));
extern int strcoll_l (const char *__s1, const char *__s2, __locale_t __l)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
__locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));
extern char *strdup (const char *__s)
throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
extern char *strndup (const char *__string, size_t __n)
throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
#define strdupa(s) (__extension__ ({ const char *__old = (s); size_t __len = strlen (__old) + 1; char *__new = (char *) __builtin_alloca (__len); (char *) memcpy (__new, __old, __len); }))
#define strndupa(s,n) (__extension__ ({ const char *__old = (s); size_t __len = strnlen (__old, (n)); char *__new = (char *) __builtin_alloca (__len + 1); __new[__len] = '\0'; (char *) memcpy (__new, __old, __len); }))
extern "C++"
{
extern char *strchr (char *__s, int __c)
throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *strchr (const char *__s, int __c)
throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
}
extern "C++"
{
extern char *strrchr (char *__s, int __c)
throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *strrchr (const char *__s, int __c)
throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
}
extern "C++" char *strchrnul (char *__s, int __c)
throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const char *strchrnul (const char *__s, int __c)
throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern size_t strcspn (const char *__s, const char *__reject)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern size_t strspn (const char *__s, const char *__accept)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++"
{
extern char *strpbrk (char *__s, const char *__accept)
throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern const char *strpbrk (const char *__s, const char *__accept)
throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
}
extern "C++"
{
extern char *strstr (char *__haystack, const char *__needle)
throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern const char *strstr (const char *__haystack, const char *__needle)
throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
}
extern char *strtok (char *__restrict __s, const char *__restrict __delim)
throw () __attribute__ ((__nonnull__ (2)));
extern char *__strtok_r (char *__restrict __s,
const char *__restrict __delim,
char **__restrict __save_ptr)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
char **__restrict __save_ptr)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern "C++" char *strcasestr (char *__haystack, const char *__needle)
throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++" const char *strcasestr (const char *__haystack,
const char *__needle)
throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern void *memmem (const void *__haystack, size_t __haystacklen,
const void *__needle, size_t __needlelen)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));
extern void *__mempcpy (void *__restrict __dest,
const void *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *mempcpy (void *__restrict __dest,
const void *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern size_t strlen (const char *__s)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern size_t strnlen (const char *__string, size_t __maxlen)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern char *strerror (int __errnum) throw ();
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2))) ;
extern char *strerror_l (int __errnum, __locale_t __l) throw ();
extern void __bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern void bcopy (const void *__src, void *__dest, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern int bcmp (const void *__s1, const void *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++"
{
extern char *index (char *__s, int __c)
throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *index (const char *__s, int __c)
throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
}
extern "C++"
{
extern char *rindex (char *__s, int __c)
throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *rindex (const char *__s, int __c)
throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
}
extern int ffs (int __i) throw () __attribute__ ((__const__));
extern int ffsl (long int __l) throw () __attribute__ ((__const__));
__extension__ extern int ffsll (long long int __ll)
throw () __attribute__ ((__const__));
extern int strcasecmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strcasecmp_l (const char *__s1, const char *__s2,
__locale_t __loc)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
extern int strncasecmp_l (const char *__s1, const char *__s2,
size_t __n, __locale_t __loc)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
extern char *strsep (char **__restrict __stringp,
const char *__restrict __delim)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strsignal (int __sig) throw ();
extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *__stpncpy (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpncpy (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int strverscmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));
extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern "C++" char *basename (char *__filename)
throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
extern "C++" const char *basename (const char *__filename)
throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
}
#define SUN_LEN(ptr) ((size_t) (((struct sockaddr_un *) 0)->sun_path) + strlen ((ptr)->sun_path))
}
#define _NETINET_TCP_H 1
#define TCP_NODELAY 1
#define TCP_MAXSEG 2
#define TCP_CORK 3
#define TCP_KEEPIDLE 4
#define TCP_KEEPINTVL 5
#define TCP_KEEPCNT 6
#define TCP_SYNCNT 7
#define TCP_LINGER2 8
#define TCP_DEFER_ACCEPT 9
#define TCP_WINDOW_CLAMP 10
#define TCP_INFO 11
#define TCP_QUICKACK 12
#define TCP_CONGESTION 13
#define TCP_MD5SIG 14
#define TCP_COOKIE_TRANSACTIONS 15
#define TCP_THIN_LINEAR_TIMEOUTS 16
#define TCP_THIN_DUPACK 17
#define TCP_USER_TIMEOUT 18
#define TCP_REPAIR 19
#define TCP_REPAIR_QUEUE 20
#define TCP_QUEUE_SEQ 21
#define TCP_REPAIR_OPTIONS 22
#define TCP_FASTOPEN 23
#define TCP_TIMESTAMP 24
typedef u_int32_t tcp_seq;
struct tcphdr
{
__extension__ union
{
struct
{
u_int16_t th_sport;
u_int16_t th_dport;
tcp_seq th_seq;
tcp_seq th_ack;
u_int8_t th_x2:4;
u_int8_t th_off:4;
u_int8_t th_flags;
#define TH_FIN 0x01
#define TH_SYN 0x02
#define TH_RST 0x04
#define TH_PUSH 0x08
#define TH_ACK 0x10
#define TH_URG 0x20
u_int16_t th_win;
u_int16_t th_sum;
u_int16_t th_urp;
};
struct
{
u_int16_t source;
u_int16_t dest;
u_int32_t seq;
u_int32_t ack_seq;
u_int16_t res1:4;
u_int16_t doff:4;
u_int16_t fin:1;
u_int16_t syn:1;
u_int16_t rst:1;
u_int16_t psh:1;
u_int16_t ack:1;
u_int16_t urg:1;
u_int16_t res2:2;
u_int16_t window;
u_int16_t check;
u_int16_t urg_ptr;
};
};
};
enum
{
TCP_ESTABLISHED = 1,
TCP_SYN_SENT,
TCP_SYN_RECV,
TCP_FIN_WAIT1,
TCP_FIN_WAIT2,
TCP_TIME_WAIT,
TCP_CLOSE,
TCP_CLOSE_WAIT,
TCP_LAST_ACK,
TCP_LISTEN,
TCP_CLOSING
};
#define TCPOPT_EOL 0
#define TCPOPT_NOP 1
#define TCPOPT_MAXSEG 2
#define TCPOLEN_MAXSEG 4
#define TCPOPT_WINDOW 3
#define TCPOLEN_WINDOW 3
#define TCPOPT_SACK_PERMITTED 4
#define TCPOLEN_SACK_PERMITTED 2
#define TCPOPT_SACK 5
#define TCPOPT_TIMESTAMP 8
#define TCPOLEN_TIMESTAMP 10
#define TCPOLEN_TSTAMP_APPA (TCPOLEN_TIMESTAMP+2)
#define TCPOPT_TSTAMP_HDR (TCPOPT_NOP<<24|TCPOPT_NOP<<16|TCPOPT_TIMESTAMP<<8|TCPOLEN_TIMESTAMP)
#define TCP_MSS 512
#define TCP_MAXWIN 65535
#define TCP_MAX_WINSHIFT 14
#define SOL_TCP 6
#define TCPI_OPT_TIMESTAMPS 1
#define TCPI_OPT_SACK 2
#define TCPI_OPT_WSCALE 4
#define TCPI_OPT_ECN 8
#define TCPI_OPT_ECN_SEEN 16
#define TCPI_OPT_SYN_DATA 32
enum tcp_ca_state
{
TCP_CA_Open = 0,
TCP_CA_Disorder = 1,
TCP_CA_CWR = 2,
TCP_CA_Recovery = 3,
TCP_CA_Loss = 4
};
struct tcp_info
{
u_int8_t tcpi_state;
u_int8_t tcpi_ca_state;
u_int8_t tcpi_retransmits;
u_int8_t tcpi_probes;
u_int8_t tcpi_backoff;
u_int8_t tcpi_options;
u_int8_t tcpi_snd_wscale : 4, tcpi_rcv_wscale : 4;
u_int32_t tcpi_rto;
u_int32_t tcpi_ato;
u_int32_t tcpi_snd_mss;
u_int32_t tcpi_rcv_mss;
u_int32_t tcpi_unacked;
u_int32_t tcpi_sacked;
u_int32_t tcpi_lost;
u_int32_t tcpi_retrans;
u_int32_t tcpi_fackets;
u_int32_t tcpi_last_data_sent;
u_int32_t tcpi_last_ack_sent;
u_int32_t tcpi_last_data_recv;
u_int32_t tcpi_last_ack_recv;
u_int32_t tcpi_pmtu;
u_int32_t tcpi_rcv_ssthresh;
u_int32_t tcpi_rtt;
u_int32_t tcpi_rttvar;
u_int32_t tcpi_snd_ssthresh;
u_int32_t tcpi_snd_cwnd;
u_int32_t tcpi_advmss;
u_int32_t tcpi_reordering;
u_int32_t tcpi_rcv_rtt;
u_int32_t tcpi_rcv_space;
u_int32_t tcpi_total_retrans;
};
#define TCP_MD5SIG_MAXKEYLEN 80
struct tcp_md5sig
{
struct sockaddr_storage tcpm_addr;
u_int16_t __tcpm_pad1;
u_int16_t tcpm_keylen;
u_int32_t __tcpm_pad2;
u_int8_t tcpm_key[80];
};
struct tcp_repair_opt
{
u_int32_t opt_code;
u_int32_t opt_val;
};
enum
{
TCP_NO_QUEUE,
TCP_RECV_QUEUE,
TCP_SEND_QUEUE,
TCP_QUEUES_NR,
};
#define TCP_COOKIE_MIN 8
#define TCP_COOKIE_MAX 16
#define TCP_COOKIE_PAIR_SIZE (2*TCP_COOKIE_MAX)
#define TCP_COOKIE_IN_ALWAYS (1 << 0)
#define TCP_COOKIE_OUT_NEVER (1 << 1)
#define TCP_S_DATA_IN (1 << 2)
#define TCP_S_DATA_OUT (1 << 3)
#define TCP_MSS_DEFAULT 536U
#define TCP_MSS_DESIRED 1220U
struct tcp_cookie_transactions
{
u_int16_t tcpct_flags;
u_int8_t __tcpct_pad1;
u_int8_t tcpct_cookie_desired;
u_int16_t tcpct_s_data_desired;
u_int16_t tcpct_used;
u_int8_t tcpct_value[536U];
};
#define _ARPA_INET_H 1
extern "C" {
extern in_addr_t inet_addr (const char *__cp) throw ();
extern in_addr_t inet_lnaof (struct in_addr __in) throw ();
extern struct in_addr inet_makeaddr (in_addr_t __net, in_addr_t __host)
throw ();
extern in_addr_t inet_netof (struct in_addr __in) throw ();
extern in_addr_t inet_network (const char *__cp) throw ();
extern char *inet_ntoa (struct in_addr __in) throw ();
extern int inet_pton (int __af, const char *__restrict __cp,
void *__restrict __buf) throw ();
extern const char *inet_ntop (int __af, const void *__restrict __cp,
char *__restrict __buf, socklen_t __len)
throw ();
extern int inet_aton (const char *__cp, struct in_addr *__inp) throw ();
extern char *inet_neta (in_addr_t __net, char *__buf, size_t __len) throw ();
extern char *inet_net_ntop (int __af, const void *__cp, int __bits,
char *__buf, size_t __len) throw ();
extern int inet_net_pton (int __af, const char *__cp,
void *__buf, size_t __len) throw ();
extern unsigned int inet_nsap_addr (const char *__cp,
unsigned char *__buf, int __len) throw ();
extern char *inet_nsap_ntoa (int __len, const unsigned char *__cp,
char *__buf) throw ();
}
#define _NET_IF_H 1
#define IF_NAMESIZE 16
struct if_nameindex
{
unsigned int if_index;
char *if_name;
};
enum
{
IFF_UP = 0x1,
#define IFF_UP IFF_UP
IFF_BROADCAST = 0x2,
#define IFF_BROADCAST IFF_BROADCAST
IFF_DEBUG = 0x4,
#define IFF_DEBUG IFF_DEBUG
IFF_LOOPBACK = 0x8,
#define IFF_LOOPBACK IFF_LOOPBACK
IFF_POINTOPOINT = 0x10,
#define IFF_POINTOPOINT IFF_POINTOPOINT
IFF_NOTRAILERS = 0x20,
#define IFF_NOTRAILERS IFF_NOTRAILERS
IFF_RUNNING = 0x40,
#define IFF_RUNNING IFF_RUNNING
IFF_NOARP = 0x80,
#define IFF_NOARP IFF_NOARP
IFF_PROMISC = 0x100,
#define IFF_PROMISC IFF_PROMISC
IFF_ALLMULTI = 0x200,
#define IFF_ALLMULTI IFF_ALLMULTI
IFF_MASTER = 0x400,
#define IFF_MASTER IFF_MASTER
IFF_SLAVE = 0x800,
#define IFF_SLAVE IFF_SLAVE
IFF_MULTICAST = 0x1000,
#define IFF_MULTICAST IFF_MULTICAST
IFF_PORTSEL = 0x2000,
#define IFF_PORTSEL IFF_PORTSEL
IFF_AUTOMEDIA = 0x4000,
#define IFF_AUTOMEDIA IFF_AUTOMEDIA
IFF_DYNAMIC = 0x8000
#define IFF_DYNAMIC IFF_DYNAMIC
};
struct ifaddr
{
struct sockaddr ifa_addr;
union
{
struct sockaddr ifu_broadaddr;
struct sockaddr ifu_dstaddr;
} ifa_ifu;
struct iface *ifa_ifp;
struct ifaddr *ifa_next;
};
#define ifa_broadaddr ifa_ifu.ifu_broadaddr
#define ifa_dstaddr ifa_ifu.ifu_dstaddr
struct ifmap
{
unsigned long int mem_start;
unsigned long int mem_end;
unsigned short int base_addr;
unsigned char irq;
unsigned char dma;
unsigned char port;
};
struct ifreq
{
#define IFHWADDRLEN 6
#define IFNAMSIZ IF_NAMESIZE
union
{
char ifrn_name[16];
} ifr_ifrn;
union
{
struct sockaddr ifru_addr;
struct sockaddr ifru_dstaddr;
struct sockaddr ifru_broadaddr;
struct sockaddr ifru_netmask;
struct sockaddr ifru_hwaddr;
short int ifru_flags;
int ifru_ivalue;
int ifru_mtu;
struct ifmap ifru_map;
char ifru_slave[16];
char ifru_newname[16];
__caddr_t ifru_data;
} ifr_ifru;
};
#define ifr_name ifr_ifrn.ifrn_name
#define ifr_hwaddr ifr_ifru.ifru_hwaddr
#define ifr_addr ifr_ifru.ifru_addr
#define ifr_dstaddr ifr_ifru.ifru_dstaddr
#define ifr_broadaddr ifr_ifru.ifru_broadaddr
#define ifr_netmask ifr_ifru.ifru_netmask
#define ifr_flags ifr_ifru.ifru_flags
#define ifr_metric ifr_ifru.ifru_ivalue
#define ifr_mtu ifr_ifru.ifru_mtu
#define ifr_map ifr_ifru.ifru_map
#define ifr_slave ifr_ifru.ifru_slave
#define ifr_data ifr_ifru.ifru_data
#define ifr_ifindex ifr_ifru.ifru_ivalue
#define ifr_bandwidth ifr_ifru.ifru_ivalue
#define ifr_qlen ifr_ifru.ifru_ivalue
#define ifr_newname ifr_ifru.ifru_newname
#define _IOT_ifreq _IOT(_IOTS(char),IFNAMSIZ,_IOTS(char),16,0,0)
#define _IOT_ifreq_short _IOT(_IOTS(char),IFNAMSIZ,_IOTS(short),1,0,0)
#define _IOT_ifreq_int _IOT(_IOTS(char),IFNAMSIZ,_IOTS(int),1,0,0)
struct ifconf
{
int ifc_len;
union
{
__caddr_t ifcu_buf;
struct ifreq *ifcu_req;
} ifc_ifcu;
};
#define ifc_buf ifc_ifcu.ifcu_buf
#define ifc_req ifc_ifcu.ifcu_req
#define _IOT_ifconf _IOT(_IOTS(struct ifconf),1,0,0,0,0)
extern "C" {
extern unsigned int if_nametoindex (const char *__ifname) throw ();
extern char *if_indextoname (unsigned int __ifindex, char *__ifname) throw ();
extern struct if_nameindex *if_nameindex (void) throw ();
extern void if_freenameindex (struct if_nameindex *__ptr) throw ();
}
namespace boost {
namespace asio {
namespace detail {
typedef int socket_type;
const int invalid_socket = -1;
const int socket_error_retval = -1;
const int max_addr_v4_str_len = 16;
const int max_addr_v6_str_len = 46 + 1 + 16;
typedef sockaddr socket_addr_type;
typedef in_addr in4_addr_type;
typedef ip_mreq in4_mreq_type;
typedef sockaddr_in sockaddr_in4_type;
typedef in6_addr in6_addr_type;
typedef ipv6_mreq in6_mreq_type;
typedef sockaddr_in6 sockaddr_in6_type;
typedef sockaddr_storage sockaddr_storage_type;
typedef sockaddr_un sockaddr_un_type;
typedef addrinfo addrinfo_type;
typedef ::linger linger_type;
typedef int ioctl_arg_type;
typedef uint32_t u_long_type;
typedef uint16_t u_short_type;
typedef ssize_t signed_size_type;
#define BOOST_ASIO_OS_DEF(c) BOOST_ASIO_OS_DEF_ ##c
#define BOOST_ASIO_OS_DEF_AF_UNSPEC AF_UNSPEC
#define BOOST_ASIO_OS_DEF_AF_INET AF_INET
#define BOOST_ASIO_OS_DEF_AF_INET6 AF_INET6
#define BOOST_ASIO_OS_DEF_SOCK_STREAM SOCK_STREAM
#define BOOST_ASIO_OS_DEF_SOCK_DGRAM SOCK_DGRAM
#define BOOST_ASIO_OS_DEF_SOCK_RAW SOCK_RAW
#define BOOST_ASIO_OS_DEF_SOCK_SEQPACKET SOCK_SEQPACKET
#define BOOST_ASIO_OS_DEF_IPPROTO_IP IPPROTO_IP
#define BOOST_ASIO_OS_DEF_IPPROTO_IPV6 IPPROTO_IPV6
#define BOOST_ASIO_OS_DEF_IPPROTO_TCP IPPROTO_TCP
#define BOOST_ASIO_OS_DEF_IPPROTO_UDP IPPROTO_UDP
#define BOOST_ASIO_OS_DEF_IPPROTO_ICMP IPPROTO_ICMP
#define BOOST_ASIO_OS_DEF_IPPROTO_ICMPV6 IPPROTO_ICMPV6
#define BOOST_ASIO_OS_DEF_FIONBIO FIONBIO
#define BOOST_ASIO_OS_DEF_FIONREAD FIONREAD
#define BOOST_ASIO_OS_DEF_INADDR_ANY INADDR_ANY
#define BOOST_ASIO_OS_DEF_MSG_OOB MSG_OOB
#define BOOST_ASIO_OS_DEF_MSG_PEEK MSG_PEEK
#define BOOST_ASIO_OS_DEF_MSG_DONTROUTE MSG_DONTROUTE
#define BOOST_ASIO_OS_DEF_MSG_EOR MSG_EOR
#define BOOST_ASIO_OS_DEF_SHUT_RD SHUT_RD
#define BOOST_ASIO_OS_DEF_SHUT_WR SHUT_WR
#define BOOST_ASIO_OS_DEF_SHUT_RDWR SHUT_RDWR
#define BOOST_ASIO_OS_DEF_SOMAXCONN SOMAXCONN
#define BOOST_ASIO_OS_DEF_SOL_SOCKET SOL_SOCKET
#define BOOST_ASIO_OS_DEF_SO_BROADCAST SO_BROADCAST
#define BOOST_ASIO_OS_DEF_SO_DEBUG SO_DEBUG
#define BOOST_ASIO_OS_DEF_SO_DONTROUTE SO_DONTROUTE
#define BOOST_ASIO_OS_DEF_SO_KEEPALIVE SO_KEEPALIVE
#define BOOST_ASIO_OS_DEF_SO_LINGER SO_LINGER
#define BOOST_ASIO_OS_DEF_SO_SNDBUF SO_SNDBUF
#define BOOST_ASIO_OS_DEF_SO_RCVBUF SO_RCVBUF
#define BOOST_ASIO_OS_DEF_SO_SNDLOWAT SO_SNDLOWAT
#define BOOST_ASIO_OS_DEF_SO_RCVLOWAT SO_RCVLOWAT
#define BOOST_ASIO_OS_DEF_SO_REUSEADDR SO_REUSEADDR
#define BOOST_ASIO_OS_DEF_TCP_NODELAY TCP_NODELAY
#define BOOST_ASIO_OS_DEF_IP_MULTICAST_IF IP_MULTICAST_IF
#define BOOST_ASIO_OS_DEF_IP_MULTICAST_TTL IP_MULTICAST_TTL
#define BOOST_ASIO_OS_DEF_IP_MULTICAST_LOOP IP_MULTICAST_LOOP
#define BOOST_ASIO_OS_DEF_IP_ADD_MEMBERSHIP IP_ADD_MEMBERSHIP
#define BOOST_ASIO_OS_DEF_IP_DROP_MEMBERSHIP IP_DROP_MEMBERSHIP
#define BOOST_ASIO_OS_DEF_IP_TTL IP_TTL
#define BOOST_ASIO_OS_DEF_IPV6_UNICAST_HOPS IPV6_UNICAST_HOPS
#define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_IF IPV6_MULTICAST_IF
#define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_HOPS IPV6_MULTICAST_HOPS
#define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_LOOP IPV6_MULTICAST_LOOP
#define BOOST_ASIO_OS_DEF_IPV6_JOIN_GROUP IPV6_JOIN_GROUP
#define BOOST_ASIO_OS_DEF_IPV6_LEAVE_GROUP IPV6_LEAVE_GROUP
#define BOOST_ASIO_OS_DEF_AI_CANONNAME AI_CANONNAME
#define BOOST_ASIO_OS_DEF_AI_PASSIVE AI_PASSIVE
#define BOOST_ASIO_OS_DEF_AI_NUMERICHOST AI_NUMERICHOST
#define BOOST_ASIO_OS_DEF_AI_NUMERICSERV AI_NUMERICSERV
#define BOOST_ASIO_OS_DEF_AI_V4MAPPED AI_V4MAPPED
#define BOOST_ASIO_OS_DEF_AI_ALL AI_ALL
#define BOOST_ASIO_OS_DEF_AI_ADDRCONFIG AI_ADDRCONFIG
const int max_iov_len = 1024;
const int custom_socket_option_level = 0xA5100000;
const int enable_connection_aborted_option = 1;
const int always_fail_option = 2;
}
}
}
#define BOOST_ASIO_DETAIL_TIMER_QUEUE_BASE_HPP
namespace boost {
namespace asio {
namespace detail {
class timer_queue_base
: private noncopyable
{
public:
timer_queue_base() ;
virtual ~timer_queue_base() ;
virtual bool empty() const = 0;
virtual long wait_duration_msec(long max_duration) const = 0;
virtual long wait_duration_usec(long max_duration) const = 0;
virtual void get_ready_timers(op_queue<operation>& ops) = 0;
virtual void get_all_timers(op_queue<operation>& ops) = 0;
private:
friend class timer_queue_set;
timer_queue_base* next_;
};
template <typename Time_Traits>
class timer_queue;
}
}
}
#define BOOST_ASIO_DETAIL_TIMER_QUEUE_SET_HPP
namespace boost {
namespace asio {
namespace detail {
class timer_queue_set
{
public:
inline timer_queue_set();
inline void insert(timer_queue_base* q);
inline void erase(timer_queue_base* q);
inline bool all_empty() const;
inline long wait_duration_msec(long max_duration) const;
inline long wait_duration_usec(long max_duration) const;
inline void get_ready_timers(op_queue<operation>& ops);
inline void get_all_timers(op_queue<operation>& ops);
private:
timer_queue_base* first_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_TIMER_QUEUE_SET_IPP
namespace boost {
namespace asio {
namespace detail {
bool timer_queue_set::all_empty() const
{
for (timer_queue_base* p = first_; p; p = p->next_)
if (!p->empty())
return false;
return true;
}
}
}
}
#define BOOST_ASIO_DETAIL_WAIT_OP_HPP
namespace boost {
namespace asio {
namespace detail {
class wait_op
: public operation
{
public:
boost::system::error_code ec_;
protected:
wait_op(func_type func)
;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
class epoll_reactor
: public boost::asio::detail::service_base<epoll_reactor>
{
public:
enum op_types { read_op = 0, write_op = 1,
connect_op = 1, except_op = 2, max_ops = 3 };
class descriptor_state : operation
{
friend class epoll_reactor;
friend class object_pool_access;
descriptor_state* next_;
descriptor_state* prev_;
mutex mutex_;
epoll_reactor* reactor_;
int descriptor_;
uint32_t registered_events_;
op_queue<reactor_op> op_queue_[max_ops];
bool shutdown_;
inline descriptor_state();
void set_ready_events(uint32_t events) ;
inline operation* perform_io(uint32_t events);
inline static void do_complete(
io_service_impl* owner, operation* base,
const boost::system::error_code& ec, std::size_t bytes_transferred);
};
typedef descriptor_state* per_descriptor_data;
inline epoll_reactor(boost::asio::io_service& io_service);
inline ~epoll_reactor();
inline void shutdown_service();
inline void fork_service(
boost::asio::io_service::fork_event fork_ev);
inline void init_task();
inline int register_descriptor(socket_type descriptor,
per_descriptor_data& descriptor_data);
inline int register_internal_descriptor(
int op_type, socket_type descriptor,
per_descriptor_data& descriptor_data, reactor_op* op);
inline void move_descriptor(socket_type descriptor,
per_descriptor_data& target_descriptor_data,
per_descriptor_data& source_descriptor_data);
void post_immediate_completion(reactor_op* op, bool is_continuation)
;
inline void start_op(int op_type, socket_type descriptor,
per_descriptor_data& descriptor_data, reactor_op* op,
bool is_continuation, bool allow_speculative);
inline void cancel_ops(socket_type descriptor,
per_descriptor_data& descriptor_data);
inline void deregister_descriptor(socket_type descriptor,
per_descriptor_data& descriptor_data, bool closing);
inline void deregister_internal_descriptor(
socket_type descriptor, per_descriptor_data& descriptor_data);
template <typename Time_Traits>
void add_timer_queue(timer_queue<Time_Traits>& timer_queue);
template <typename Time_Traits>
void remove_timer_queue(timer_queue<Time_Traits>& timer_queue);
template <typename Time_Traits>
void schedule_timer(timer_queue<Time_Traits>& queue,
const typename Time_Traits::time_type& time,
typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op);
template <typename Time_Traits>
std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
typename timer_queue<Time_Traits>::per_timer_data& timer,
std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
inline void run(bool block, op_queue<operation>& ops);
inline void interrupt();
private:
enum { epoll_size = 20000 };
inline static int do_epoll_create();
inline static int do_timerfd_create();
inline descriptor_state* allocate_descriptor_state();
inline void free_descriptor_state(descriptor_state* s);
inline void do_add_timer_queue(timer_queue_base& queue);
inline void do_remove_timer_queue(timer_queue_base& queue);
inline void update_timeout();
inline int get_timeout();
inline int get_timeout(itimerspec& ts);
io_service_impl& io_service_;
mutex mutex_;
select_interrupter interrupter_;
int epoll_fd_;
int timer_fd_;
timer_queue_set timer_queues_;
bool shutdown_;
mutex registered_descriptors_mutex_;
object_pool<descriptor_state> registered_descriptors_;
struct perform_io_cleanup_on_block_exit;
friend struct perform_io_cleanup_on_block_exit;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_EPOLL_REACTOR_HPP
namespace boost {
namespace asio {
namespace detail {
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_EPOLL_REACTOR_IPP
#define _SYS_EPOLL_H 1
enum
{
EPOLL_CLOEXEC = 02000000
#define EPOLL_CLOEXEC EPOLL_CLOEXEC
};
#define __EPOLL_PACKED __attribute__ ((__packed__))
enum EPOLL_EVENTS
{
EPOLLIN = 0x001,
#define EPOLLIN EPOLLIN
EPOLLPRI = 0x002,
#define EPOLLPRI EPOLLPRI
EPOLLOUT = 0x004,
#define EPOLLOUT EPOLLOUT
EPOLLRDNORM = 0x040,
#define EPOLLRDNORM EPOLLRDNORM
EPOLLRDBAND = 0x080,
#define EPOLLRDBAND EPOLLRDBAND
EPOLLWRNORM = 0x100,
#define EPOLLWRNORM EPOLLWRNORM
EPOLLWRBAND = 0x200,
#define EPOLLWRBAND EPOLLWRBAND
EPOLLMSG = 0x400,
#define EPOLLMSG EPOLLMSG
EPOLLERR = 0x008,
#define EPOLLERR EPOLLERR
EPOLLHUP = 0x010,
#define EPOLLHUP EPOLLHUP
EPOLLRDHUP = 0x2000,
#define EPOLLRDHUP EPOLLRDHUP
EPOLLWAKEUP = 1u << 29,
#define EPOLLWAKEUP EPOLLWAKEUP
EPOLLONESHOT = 1u << 30,
#define EPOLLONESHOT EPOLLONESHOT
EPOLLET = 1u << 31
#define EPOLLET EPOLLET
};
#define EPOLL_CTL_ADD 1
#define EPOLL_CTL_DEL 2
#define EPOLL_CTL_MOD 3
typedef union epoll_data
{
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
struct epoll_event
{
uint32_t events;
epoll_data_t data;
} __attribute__ ((__packed__));
extern "C" {
extern int epoll_create (int __size) throw ();
extern int epoll_create1 (int __flags) throw ();
extern int epoll_ctl (int __epfd, int __op, int __fd,
struct epoll_event *__event) throw ();
extern int epoll_wait (int __epfd, struct epoll_event *__events,
int __maxevents, int __timeout);
extern int epoll_pwait (int __epfd, struct epoll_event *__events,
int __maxevents, int __timeout,
const __sigset_t *__ss);
}
#define _SYS_TIMERFD_H 1
enum
{
TFD_CLOEXEC = 02000000,
#define TFD_CLOEXEC TFD_CLOEXEC
TFD_NONBLOCK = 00004000
#define TFD_NONBLOCK TFD_NONBLOCK
};
enum
{
TFD_TIMER_ABSTIME = 1 << 0
#define TFD_TIMER_ABSTIME TFD_TIMER_ABSTIME
};
extern "C" {
extern int timerfd_create (clockid_t __clock_id, int __flags) throw ();
extern int timerfd_settime (int __ufd, int __flags,
const struct itimerspec *__utmr,
struct itimerspec *__otmr) throw ();
extern int timerfd_gettime (int __ufd, struct itimerspec *__otmr) throw ();
}
namespace boost {
namespace asio {
namespace detail {
struct epoll_reactor::perform_io_cleanup_on_block_exit
{
explicit perform_io_cleanup_on_block_exit(epoll_reactor* r)
;
~perform_io_cleanup_on_block_exit()
;
epoll_reactor* reactor_;
op_queue<operation> ops_;
operation* first_op_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
struct task_io_service::task_cleanup
{
~task_cleanup()
;
task_io_service* task_io_service_;
mutex::scoped_lock* lock_;
thread_info* this_thread_;
};
struct task_io_service::work_cleanup
{
~work_cleanup()
;
task_io_service* task_io_service_;
mutex::scoped_lock* lock_;
thread_info* this_thread_;
};
bool task_io_service::stopped() const
{
mutex::scoped_lock lock(mutex_);
return stopped_;
}
bool task_io_service::wake_one_idle_thread_and_unlock(
mutex::scoped_lock& lock)
{
if (first_idle_thread_)
{
thread_info* idle_thread = first_idle_thread_;
first_idle_thread_ = idle_thread->next;
idle_thread->next = 0;
idle_thread->wakeup_event->signal_and_unlock(lock);
return true;
}
return false;
}
}
}
}
namespace boost {
namespace asio {
}
}
#define BOOST_ASIO_IMPL_IO_SERVICE_IPP
#define BOOST_ASIO_DETAIL_SCOPED_PTR_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename T>
class scoped_ptr
{
public:
explicit scoped_ptr(T* p = 0)
;
~scoped_ptr()
;
T* get()
;
T* operator->()
;
T& operator*()
;
void reset(T* p = 0)
;
private:
scoped_ptr(const scoped_ptr&);
scoped_ptr& operator=(const scoped_ptr&);
T* p_;
};
}
}
}
namespace boost {
namespace asio {
bool io_service::stopped() const
{
return impl_.stopped();
}
}
}
namespace boost {
namespace asio {
namespace detail
{
template <typename IoObjectService>
class service_has_move
{
private:
typedef IoObjectService service_type;
typedef typename service_type::implementation_type implementation_type;
template <typename T, typename U>
static auto eval(T* t, U* u) -> decltype(t->move_construct(*u, *u), char());
static char (&eval(...))[2];
public:
static const bool value =
sizeof(service_has_move::eval(
static_cast<service_type*>(0),
static_cast<implementation_type*>(0))) == 1;
};
}
template <typename IoObjectService,
bool Movable = detail::service_has_move<IoObjectService>::value>
class basic_io_object
{
public:
typedef IoObjectService service_type;
typedef typename service_type::implementation_type implementation_type;
boost::asio::io_service& get_io_service()
;
protected:
explicit basic_io_object(boost::asio::io_service& io_service)
;
~basic_io_object()
;
service_type& get_service()
;
const service_type& get_service() const
;
service_type& service;
implementation_type& get_implementation()
;
const implementation_type& get_implementation() const
;
implementation_type implementation;
private:
basic_io_object(const basic_io_object&);
basic_io_object& operator=(const basic_io_object&);
};
template <typename IoObjectService>
class basic_io_object<IoObjectService, true>
{
public:
typedef IoObjectService service_type;
typedef typename service_type::implementation_type implementation_type;
boost::asio::io_service& get_io_service()
;
protected:
explicit basic_io_object(boost::asio::io_service& io_service)
;
basic_io_object(basic_io_object&& other)
;
~basic_io_object()
;
basic_io_object& operator=(basic_io_object&& other)
;
service_type& get_service()
;
const service_type& get_service() const
;
implementation_type& get_implementation()
;
const implementation_type& get_implementation() const
;
implementation_type implementation;
private:
basic_io_object(const basic_io_object&);
void operator=(const basic_io_object&);
IoObjectService* service_;
};
}
}
#define BOOST_ASIO_DETAIL_TYPE_TRAITS_HPP
namespace boost {
namespace asio {
using std::add_const;
using std::enable_if;
using std::is_const;
using std::is_convertible;
using std::is_function;
using std::is_same;
using std::remove_pointer;
using std::remove_reference;
}
}
#define BOOST_ASIO_SOCKET_BASE_HPP
#define BOOST_ASIO_DETAIL_IO_CONTROL_HPP
namespace boost {
namespace asio {
namespace detail {
namespace io_control {
class non_blocking_io
{
public:
non_blocking_io()
;
non_blocking_io(bool value)
;
int name() const
;
void set(bool value)
;
bool get() const
;
detail::ioctl_arg_type* data()
;
const detail::ioctl_arg_type* data() const
;
private:
detail::ioctl_arg_type value_;
};
class bytes_readable
{
public:
bytes_readable()
;
bytes_readable(std::size_t value)
;
int name() const
;
void set(std::size_t value)
;
std::size_t get() const
;
detail::ioctl_arg_type* data()
;
const detail::ioctl_arg_type* data() const
;
private:
detail::ioctl_arg_type value_;
};
}
}
}
}
#define BOOST_ASIO_DETAIL_SOCKET_OPTION_HPP
namespace boost {
namespace asio {
namespace detail {
namespace socket_option {
template <int Level, int Name>
class boolean
{
public:
boolean()
;
explicit boolean(bool v)
;
boolean& operator=(bool v)
;
bool value() const
;
operator bool() const
;
bool operator!() const
;
template <typename Protocol>
int level(const Protocol&) const
;
template <typename Protocol>
int name(const Protocol&) const
;
template <typename Protocol>
int* data(const Protocol&)
;
template <typename Protocol>
const int* data(const Protocol&) const
;
template <typename Protocol>
std::size_t size(const Protocol&) const
;
template <typename Protocol>
void resize(const Protocol&, std::size_t s)
;
private:
int value_;
};
template <int Level, int Name>
class integer
{
public:
integer()
;
explicit integer(int v)
;
integer& operator=(int v)
;
int value() const
;
template <typename Protocol>
int level(const Protocol&) const
;
template <typename Protocol>
int name(const Protocol&) const
;
template <typename Protocol>
int* data(const Protocol&)
;
template <typename Protocol>
const int* data(const Protocol&) const
;
template <typename Protocol>
std::size_t size(const Protocol&) const
;
template <typename Protocol>
void resize(const Protocol&, std::size_t s)
;
private:
int value_;
};
template <int Level, int Name>
class linger
{
public:
linger()
;
linger(bool e, int t)
;
void enabled(bool value)
;
bool enabled() const
;
void timeout (int value)
;
int timeout () const
;
template <typename Protocol>
int level(const Protocol&) const
;
template <typename Protocol>
int name(const Protocol&) const
;
template <typename Protocol>
detail::linger_type* data(const Protocol&)
;
template <typename Protocol>
const detail::linger_type* data(const Protocol&) const
;
template <typename Protocol>
std::size_t size(const Protocol&) const
;
template <typename Protocol>
void resize(const Protocol&, std::size_t s)
;
private:
detail::linger_type value_;
};
}
}
}
}
namespace boost {
namespace asio {
class socket_base
{
public:
enum shutdown_type
{
shutdown_receive = SHUT_RD,
shutdown_send = SHUT_WR,
shutdown_both = SHUT_RDWR
};
typedef int message_flags;
static const int message_peek = MSG_PEEK;
static const int message_out_of_band = MSG_OOB;
static const int message_do_not_route = MSG_DONTROUTE;
static const int message_end_of_record = MSG_EOR;
typedef boost::asio::detail::socket_option::boolean<
1, 6>
broadcast;
typedef boost::asio::detail::socket_option::boolean<
1, 1> debug;
typedef boost::asio::detail::socket_option::boolean<
1, 5>
do_not_route;
typedef boost::asio::detail::socket_option::boolean<
1, 9> keep_alive;
typedef boost::asio::detail::socket_option::integer<
1, 7>
send_buffer_size;
typedef boost::asio::detail::socket_option::integer<
1, 19>
send_low_watermark;
typedef boost::asio::detail::socket_option::integer<
1, 8>
receive_buffer_size;
typedef boost::asio::detail::socket_option::integer<
1, 18>
receive_low_watermark;
typedef boost::asio::detail::socket_option::boolean<
1, 2>
reuse_address;
typedef boost::asio::detail::socket_option::linger<
1, 13>
linger;
typedef boost::asio::detail::socket_option::boolean<
boost::asio::detail::custom_socket_option_level,
boost::asio::detail::enable_connection_aborted_option>
enable_connection_aborted;
typedef boost::asio::detail::io_control::non_blocking_io non_blocking_io;
typedef boost::asio::detail::io_control::bytes_readable bytes_readable;
static const int max_connections = 128;
protected:
~socket_base()
;
};
}
}
namespace boost {
namespace asio {
template <typename Protocol, typename SocketService>
class basic_socket
: public basic_io_object<SocketService>,
public socket_base
{
public:
typedef typename SocketService::native_handle_type native_type;
typedef typename SocketService::native_handle_type native_handle_type;
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
typedef basic_socket<Protocol, SocketService> lowest_layer_type;
explicit basic_socket(boost::asio::io_service& io_service)
;
basic_socket(boost::asio::io_service& io_service,
const protocol_type& protocol)
;
basic_socket(boost::asio::io_service& io_service,
const endpoint_type& endpoint)
;
basic_socket(boost::asio::io_service& io_service,
const protocol_type& protocol, const native_handle_type& native_socket)
;
basic_socket(basic_socket&& other)
;
basic_socket& operator=(basic_socket&& other)
;
template <typename Protocol1, typename SocketService1>
friend class basic_socket;
template <typename Protocol1, typename SocketService1>
basic_socket(basic_socket<Protocol1, SocketService1>&& other,
typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
;
template <typename Protocol1, typename SocketService1>
typename enable_if<is_convertible<Protocol1, Protocol>::value,
basic_socket>::type& operator=(
basic_socket<Protocol1, SocketService1>&& other)
;
lowest_layer_type& lowest_layer()
;
const lowest_layer_type& lowest_layer() const
;
void open(const protocol_type& protocol = protocol_type())
;
boost::system::error_code open(const protocol_type& protocol,
boost::system::error_code& ec)
;
void assign(const protocol_type& protocol,
const native_handle_type& native_socket)
;
boost::system::error_code assign(const protocol_type& protocol,
const native_handle_type& native_socket, boost::system::error_code& ec)
;
bool is_open() const
;
void close()
;
boost::system::error_code close(boost::system::error_code& ec)
;
native_type native()
;
native_handle_type native_handle()
;
void cancel()
;
boost::system::error_code cancel(boost::system::error_code& ec)
;
bool at_mark() const
;
bool at_mark(boost::system::error_code& ec) const
;
std::size_t available() const
;
std::size_t available(boost::system::error_code& ec) const
;
void bind(const endpoint_type& endpoint)
;
boost::system::error_code bind(const endpoint_type& endpoint,
boost::system::error_code& ec)
;
void connect(const endpoint_type& peer_endpoint)
;
boost::system::error_code connect(const endpoint_type& peer_endpoint,
boost::system::error_code& ec)
;
template <typename ConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ConnectHandler, void (boost::system::error_code)>::type>::type
async_connect(const endpoint_type& peer_endpoint,
ConnectHandler&& handler)
;
template <typename SettableSocketOption>
void set_option(const SettableSocketOption& option)
;
template <typename SettableSocketOption>
boost::system::error_code set_option(const SettableSocketOption& option,
boost::system::error_code& ec)
;
template <typename GettableSocketOption>
void get_option(GettableSocketOption& option) const
;
template <typename GettableSocketOption>
boost::system::error_code get_option(GettableSocketOption& option,
boost::system::error_code& ec) const
;
template <typename IoControlCommand>
void io_control(IoControlCommand& command)
;
template <typename IoControlCommand>
boost::system::error_code io_control(IoControlCommand& command,
boost::system::error_code& ec)
;
bool non_blocking() const
;
void non_blocking(bool mode)
;
boost::system::error_code non_blocking(
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking() const
;
void native_non_blocking(bool mode)
;
boost::system::error_code native_non_blocking(
bool mode, boost::system::error_code& ec)
;
endpoint_type local_endpoint() const
;
endpoint_type local_endpoint(boost::system::error_code& ec) const
;
endpoint_type remote_endpoint() const
;
endpoint_type remote_endpoint(boost::system::error_code& ec) const
;
void shutdown(shutdown_type what)
;
boost::system::error_code shutdown(shutdown_type what,
boost::system::error_code& ec)
;
protected:
~basic_socket()
;
};
}
}
#define BOOST_ASIO_DATAGRAM_SOCKET_SERVICE_HPP
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_HPP
#define BOOST_ASIO_BUFFER_HPP
#define _GLIBCXX_CSTRING 1
#undef memchr
#undef memcmp
#undef memcpy
#undef memmove
#undef memset
#undef strcat
#undef strchr
#undef strcmp
#undef strcoll
#undef strcpy
#undef strcspn
#undef strerror
#undef strlen
#undef strncat
#undef strncmp
#undef strncpy
#undef strpbrk
#undef strrchr
#undef strspn
#undef strstr
#undef strtok
#undef strxfrm
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::memchr;
using ::memcmp;
using ::memcpy;
using ::memmove;
using ::memset;
using ::strcat;
using ::strcmp;
using ::strcoll;
using ::strcpy;
using ::strcspn;
using ::strerror;
using ::strlen;
using ::strncat;
using ::strncmp;
using ::strncpy;
using ::strspn;
using ::strtok;
using ::strxfrm;
using ::strchr;
using ::strpbrk;
using ::strrchr;
using ::strstr;
}
#define BOOST_ASIO_DETAIL_ARRAY_FWD_HPP
namespace boost {
template<class T, std::size_t N>
class array;
}
namespace boost {
namespace asio {
class mutable_buffer;
class const_buffer;
namespace detail {
void* buffer_cast_helper(const mutable_buffer&);
const void* buffer_cast_helper(const const_buffer&);
std::size_t buffer_size_helper(const mutable_buffer&);
std::size_t buffer_size_helper(const const_buffer&);
}
class mutable_buffer
{
public:
mutable_buffer()
;
mutable_buffer(void* data, std::size_t size)
;
private:
friend void* boost::asio::detail::buffer_cast_helper(
const mutable_buffer& b);
friend std::size_t boost::asio::detail::buffer_size_helper(
const mutable_buffer& b);
void* data_;
std::size_t size_;
};
namespace detail {
void* buffer_cast_helper(const mutable_buffer& b)
;
std::size_t buffer_size_helper(const mutable_buffer& b)
;
}
class mutable_buffers_1
: public mutable_buffer
{
public:
typedef mutable_buffer value_type;
typedef const mutable_buffer* const_iterator;
mutable_buffers_1(void* data, std::size_t size)
;
explicit mutable_buffers_1(const mutable_buffer& b)
;
const_iterator begin() const
;
const_iterator end() const
;
};
class const_buffer
{
public:
const_buffer()
;
const_buffer(const void* data, std::size_t size)
;
const_buffer(const mutable_buffer& b)
;
private:
friend const void* boost::asio::detail::buffer_cast_helper(
const const_buffer& b);
friend std::size_t boost::asio::detail::buffer_size_helper(
const const_buffer& b);
const void* data_;
std::size_t size_;
};
namespace detail {
const void* buffer_cast_helper(const const_buffer& b)
;
std::size_t buffer_size_helper(const const_buffer& b)
;
}
class const_buffers_1
: public const_buffer
{
public:
typedef const_buffer value_type;
typedef const const_buffer* const_iterator;
const_buffers_1(const void* data, std::size_t size)
;
explicit const_buffers_1(const const_buffer& b)
;
const_iterator begin() const
;
const_iterator end() const
;
};
class null_buffers
{
public:
typedef mutable_buffer value_type;
typedef const mutable_buffer* const_iterator;
const_iterator begin() const
;
const_iterator end() const
;
private:
mutable_buffer buf_;
};
std::size_t buffer_size(const mutable_buffer& b)
;
std::size_t buffer_size(const mutable_buffers_1& b)
;
std::size_t buffer_size(const const_buffer& b)
;
std::size_t buffer_size(const const_buffers_1& b)
;
template <typename BufferSequence>
std::size_t buffer_size(const BufferSequence& b)
;
template <typename PointerToPodType>
PointerToPodType buffer_cast(const mutable_buffer& b)
;
template <typename PointerToPodType>
PointerToPodType buffer_cast(const const_buffer& b)
;
mutable_buffer operator+(const mutable_buffer& b, std::size_t start)
;
mutable_buffer operator+(std::size_t start, const mutable_buffer& b)
;
const_buffer operator+(const const_buffer& b, std::size_t start)
;
const_buffer operator+(std::size_t start, const const_buffer& b)
;
mutable_buffers_1 buffer(const mutable_buffer& b)
;
mutable_buffers_1 buffer(const mutable_buffer& b,
std::size_t max_size_in_bytes)
;
const_buffers_1 buffer(const const_buffer& b)
;
const_buffers_1 buffer(const const_buffer& b,
std::size_t max_size_in_bytes)
;
mutable_buffers_1 buffer(void* data, std::size_t size_in_bytes)
;
const_buffers_1 buffer(const void* data,
std::size_t size_in_bytes)
;
template <typename PodType, std::size_t N>
mutable_buffers_1 buffer(PodType (&data)[N])
;
template <typename PodType, std::size_t N>
mutable_buffers_1 buffer(PodType (&data)[N],
std::size_t max_size_in_bytes)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(const PodType (&data)[N])
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(const PodType (&data)[N],
std::size_t max_size_in_bytes)
;
template <typename PodType, std::size_t N>
mutable_buffers_1 buffer(boost::array<PodType, N>& data)
;
template <typename PodType, std::size_t N>
mutable_buffers_1 buffer(boost::array<PodType, N>& data,
std::size_t max_size_in_bytes)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(boost::array<const PodType, N>& data)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(boost::array<const PodType, N>& data,
std::size_t max_size_in_bytes)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(const boost::array<PodType, N>& data)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(const boost::array<PodType, N>& data,
std::size_t max_size_in_bytes)
;
template <typename PodType, std::size_t N>
mutable_buffers_1 buffer(std::array<PodType, N>& data)
;
template <typename PodType, std::size_t N>
mutable_buffers_1 buffer(std::array<PodType, N>& data,
std::size_t max_size_in_bytes)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(std::array<const PodType, N>& data)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(std::array<const PodType, N>& data,
std::size_t max_size_in_bytes)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(const std::array<PodType, N>& data)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(const std::array<PodType, N>& data,
std::size_t max_size_in_bytes)
;
template <typename PodType, typename Allocator>
mutable_buffers_1 buffer(std::vector<PodType, Allocator>& data)
;
template <typename PodType, typename Allocator>
mutable_buffers_1 buffer(std::vector<PodType, Allocator>& data,
std::size_t max_size_in_bytes)
;
template <typename PodType, typename Allocator>
const_buffers_1 buffer(
const std::vector<PodType, Allocator>& data)
;
template <typename PodType, typename Allocator>
const_buffers_1 buffer(
const std::vector<PodType, Allocator>& data, std::size_t max_size_in_bytes)
;
template <typename Elem, typename Traits, typename Allocator>
const_buffers_1 buffer(
const std::basic_string<Elem, Traits, Allocator>& data)
;
template <typename Elem, typename Traits, typename Allocator>
const_buffers_1 buffer(
const std::basic_string<Elem, Traits, Allocator>& data,
std::size_t max_size_in_bytes)
;
std::size_t buffer_copy(const mutable_buffer& target,
const const_buffer& source)
;
std::size_t buffer_copy(const mutable_buffer& target,
const const_buffers_1& source)
;
std::size_t buffer_copy(const mutable_buffer& target,
const mutable_buffer& source)
;
std::size_t buffer_copy(const mutable_buffer& target,
const mutable_buffers_1& source)
;
template <typename ConstBufferSequence>
std::size_t buffer_copy(const mutable_buffer& target,
const ConstBufferSequence& source)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const const_buffer& source)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const const_buffers_1& source)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const mutable_buffer& source)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const mutable_buffers_1& source)
;
template <typename ConstBufferSequence>
std::size_t buffer_copy(const mutable_buffers_1& target,
const ConstBufferSequence& source)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const const_buffer& source)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const const_buffers_1& source)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const mutable_buffer& source)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const mutable_buffers_1& source)
;
template <typename MutableBufferSequence, typename ConstBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const ConstBufferSequence& source)
;
std::size_t buffer_copy(const mutable_buffer& target,
const const_buffer& source, std::size_t max_bytes_to_copy)
;
std::size_t buffer_copy(const mutable_buffer& target,
const const_buffers_1& source, std::size_t max_bytes_to_copy)
;
std::size_t buffer_copy(const mutable_buffer& target,
const mutable_buffer& source, std::size_t max_bytes_to_copy)
;
std::size_t buffer_copy(const mutable_buffer& target,
const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
;
template <typename ConstBufferSequence>
std::size_t buffer_copy(const mutable_buffer& target,
const ConstBufferSequence& source, std::size_t max_bytes_to_copy)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const const_buffer& source, std::size_t max_bytes_to_copy)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const const_buffers_1& source, std::size_t max_bytes_to_copy)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const mutable_buffer& source, std::size_t max_bytes_to_copy)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
;
template <typename ConstBufferSequence>
std::size_t buffer_copy(const mutable_buffers_1& target,
const ConstBufferSequence& source, std::size_t max_bytes_to_copy)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const const_buffer& source, std::size_t max_bytes_to_copy)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const const_buffers_1& source, std::size_t max_bytes_to_copy)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const mutable_buffer& source, std::size_t max_bytes_to_copy)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
;
template <typename MutableBufferSequence, typename ConstBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const ConstBufferSequence& source, std::size_t max_bytes_to_copy)
;
}
}
#define BOOST_ASIO_DETAIL_BUFFER_SEQUENCE_ADAPTER_HPP
namespace boost {
namespace asio {
namespace detail {
class buffer_sequence_adapter_base
{
protected:
enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len };
typedef iovec native_buffer_type;
static void init_iov_base(void*& base, void* addr)
;
template <typename T>
static void init_iov_base(T& base, void* addr)
;
static void init_native_buffer(iovec& iov,
const boost::asio::mutable_buffer& buffer)
;
static void init_native_buffer(iovec& iov,
const boost::asio::const_buffer& buffer)
;
};
template <typename Buffer, typename Buffers>
class buffer_sequence_adapter
: buffer_sequence_adapter_base
{
public:
explicit buffer_sequence_adapter(const Buffers& buffer_sequence)
;
native_buffer_type* buffers()
;
std::size_t count() const
;
bool all_empty() const
;
static bool all_empty(const Buffers& buffer_sequence)
;
static void validate(const Buffers& buffer_sequence)
;
static Buffer first(const Buffers& buffer_sequence)
;
private:
native_buffer_type buffers_[max_buffers];
std::size_t count_;
std::size_t total_buffer_size_;
};
template <typename Buffer>
class buffer_sequence_adapter<Buffer, boost::asio::mutable_buffers_1>
: buffer_sequence_adapter_base
{
public:
explicit buffer_sequence_adapter(
const boost::asio::mutable_buffers_1& buffer_sequence)
;
native_buffer_type* buffers()
;
std::size_t count() const
;
bool all_empty() const
;
static bool all_empty(const boost::asio::mutable_buffers_1& buffer_sequence)
;
static void validate(const boost::asio::mutable_buffers_1& buffer_sequence)
;
static Buffer first(const boost::asio::mutable_buffers_1& buffer_sequence)
;
private:
native_buffer_type buffer_;
std::size_t total_buffer_size_;
};
template <typename Buffer>
class buffer_sequence_adapter<Buffer, boost::asio::const_buffers_1>
: buffer_sequence_adapter_base
{
public:
explicit buffer_sequence_adapter(
const boost::asio::const_buffers_1& buffer_sequence)
;
native_buffer_type* buffers()
;
std::size_t count() const
;
bool all_empty() const
;
static bool all_empty(const boost::asio::const_buffers_1& buffer_sequence)
;
static void validate(const boost::asio::const_buffers_1& buffer_sequence)
;
static Buffer first(const boost::asio::const_buffers_1& buffer_sequence)
;
private:
native_buffer_type buffer_;
std::size_t total_buffer_size_;
};
template <typename Buffer, typename Elem>
class buffer_sequence_adapter<Buffer, boost::array<Elem, 2> >
: buffer_sequence_adapter_base
{
public:
explicit buffer_sequence_adapter(
const boost::array<Elem, 2>& buffer_sequence)
;
native_buffer_type* buffers()
;
std::size_t count() const
;
bool all_empty() const
;
static bool all_empty(const boost::array<Elem, 2>& buffer_sequence)
;
static void validate(const boost::array<Elem, 2>& buffer_sequence)
;
static Buffer first(const boost::array<Elem, 2>& buffer_sequence)
;
private:
native_buffer_type buffers_[2];
std::size_t total_buffer_size_;
};
template <typename Buffer, typename Elem>
class buffer_sequence_adapter<Buffer, std::array<Elem, 2> >
: buffer_sequence_adapter_base
{
public:
explicit buffer_sequence_adapter(
const std::array<Elem, 2>& buffer_sequence)
;
native_buffer_type* buffers()
;
std::size_t count() const
;
bool all_empty() const
;
static bool all_empty(const std::array<Elem, 2>& buffer_sequence)
;
static void validate(const std::array<Elem, 2>& buffer_sequence)
;
static Buffer first(const std::array<Elem, 2>& buffer_sequence)
;
private:
native_buffer_type buffers_[2];
std::size_t total_buffer_size_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_BUFFER_SEQUENCE_ADAPTER_IPP
#define BOOST_ASIO_DETAIL_REACTIVE_NULL_BUFFERS_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Handler>
class reactive_null_buffers_op : public reactor_op
{
public:
struct ptr { Handler* h; void* v; reactive_null_buffers_op* p; ~ptr() ; void reset() ; };
reactive_null_buffers_op(Handler& handler)
;
static bool do_perform(reactor_op*)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_ACCEPT_OP_HPP
#define BOOST_ASIO_DETAIL_SOCKET_HOLDER_HPP
#define BOOST_ASIO_DETAIL_SOCKET_OPS_HPP
#define BOOST_ASIO_DETAIL_SHARED_PTR_HPP
namespace boost {
namespace asio {
namespace detail {
using std::shared_ptr;
}
}
}
#define BOOST_ASIO_DETAIL_WEAK_PTR_HPP
namespace boost {
namespace asio {
namespace detail {
using std::weak_ptr;
}
}
}
namespace boost {
namespace asio {
namespace detail {
namespace socket_ops {
enum
{
user_set_non_blocking = 1,
internal_non_blocking = 2,
non_blocking = user_set_non_blocking | internal_non_blocking,
enable_connection_aborted = 4,
user_set_linger = 8,
stream_oriented = 16,
datagram_oriented = 32,
possible_dup = 64
};
typedef unsigned char state_type;
struct noop_deleter { void operator()(void*) ; };
typedef shared_ptr<void> shared_cancel_token_type;
typedef weak_ptr<void> weak_cancel_token_type;
inline socket_type accept(socket_type s, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec);
inline socket_type sync_accept(socket_type s,
state_type state, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec);
inline bool non_blocking_accept(socket_type s,
state_type state, socket_addr_type* addr, std::size_t* addrlen,
boost::system::error_code& ec, socket_type& new_socket);
inline int bind(socket_type s, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec);
inline int close(socket_type s, state_type& state,
bool destruction, boost::system::error_code& ec);
inline bool set_user_non_blocking(socket_type s,
state_type& state, bool value, boost::system::error_code& ec);
inline bool set_internal_non_blocking(socket_type s,
state_type& state, bool value, boost::system::error_code& ec);
inline int shutdown(socket_type s,
int what, boost::system::error_code& ec);
inline int connect(socket_type s, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec);
inline void sync_connect(socket_type s, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec);
inline bool non_blocking_connect(socket_type s,
boost::system::error_code& ec);
inline int socketpair(int af, int type, int protocol,
socket_type sv[2], boost::system::error_code& ec);
inline bool sockatmark(socket_type s, boost::system::error_code& ec);
inline size_t available(socket_type s, boost::system::error_code& ec);
inline int listen(socket_type s,
int backlog, boost::system::error_code& ec);
typedef iovec buf;
inline void init_buf(buf& b, void* data, size_t size);
inline void init_buf(buf& b, const void* data, size_t size);
inline signed_size_type recv(socket_type s, buf* bufs,
size_t count, int flags, boost::system::error_code& ec);
inline size_t sync_recv(socket_type s, state_type state, buf* bufs,
size_t count, int flags, bool all_empty, boost::system::error_code& ec);
inline bool non_blocking_recv(socket_type s,
buf* bufs, size_t count, int flags, bool is_stream,
boost::system::error_code& ec, size_t& bytes_transferred);
inline signed_size_type recvfrom(socket_type s, buf* bufs,
size_t count, int flags, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec);
inline size_t sync_recvfrom(socket_type s, state_type state,
buf* bufs, size_t count, int flags, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec);
inline bool non_blocking_recvfrom(socket_type s,
buf* bufs, size_t count, int flags,
socket_addr_type* addr, std::size_t* addrlen,
boost::system::error_code& ec, size_t& bytes_transferred);
inline signed_size_type recvmsg(socket_type s, buf* bufs,
size_t count, int in_flags, int& out_flags,
boost::system::error_code& ec);
inline size_t sync_recvmsg(socket_type s, state_type state,
buf* bufs, size_t count, int in_flags, int& out_flags,
boost::system::error_code& ec);
inline bool non_blocking_recvmsg(socket_type s,
buf* bufs, size_t count, int in_flags, int& out_flags,
boost::system::error_code& ec, size_t& bytes_transferred);
inline signed_size_type send(socket_type s, const buf* bufs,
size_t count, int flags, boost::system::error_code& ec);
inline size_t sync_send(socket_type s, state_type state,
const buf* bufs, size_t count, int flags,
bool all_empty, boost::system::error_code& ec);
inline bool non_blocking_send(socket_type s,
const buf* bufs, size_t count, int flags,
boost::system::error_code& ec, size_t& bytes_transferred);
inline signed_size_type sendto(socket_type s, const buf* bufs,
size_t count, int flags, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec);
inline size_t sync_sendto(socket_type s, state_type state,
const buf* bufs, size_t count, int flags, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec);
inline bool non_blocking_sendto(socket_type s,
const buf* bufs, size_t count, int flags,
const socket_addr_type* addr, std::size_t addrlen,
boost::system::error_code& ec, size_t& bytes_transferred);
inline socket_type socket(int af, int type, int protocol,
boost::system::error_code& ec);
inline int setsockopt(socket_type s, state_type& state,
int level, int optname, const void* optval,
std::size_t optlen, boost::system::error_code& ec);
inline int getsockopt(socket_type s, state_type state,
int level, int optname, void* optval,
size_t* optlen, boost::system::error_code& ec);
inline int getpeername(socket_type s, socket_addr_type* addr,
std::size_t* addrlen, bool cached, boost::system::error_code& ec);
inline int getsockname(socket_type s, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec);
inline int ioctl(socket_type s, state_type& state,
int cmd, ioctl_arg_type* arg, boost::system::error_code& ec);
inline int select(int nfds, fd_set* readfds, fd_set* writefds,
fd_set* exceptfds, timeval* timeout, boost::system::error_code& ec);
inline int poll_read(socket_type s,
state_type state, boost::system::error_code& ec);
inline int poll_write(socket_type s,
state_type state, boost::system::error_code& ec);
inline int poll_connect(socket_type s, boost::system::error_code& ec);
inline const char* inet_ntop(int af, const void* src, char* dest,
size_t length, unsigned long scope_id, boost::system::error_code& ec);
inline int inet_pton(int af, const char* src, void* dest,
unsigned long* scope_id, boost::system::error_code& ec);
inline int gethostname(char* name,
int namelen, boost::system::error_code& ec);
inline boost::system::error_code getaddrinfo(const char* host,
const char* service, const addrinfo_type& hints,
addrinfo_type** result, boost::system::error_code& ec);
inline boost::system::error_code background_getaddrinfo(
const weak_cancel_token_type& cancel_token, const char* host,
const char* service, const addrinfo_type& hints,
addrinfo_type** result, boost::system::error_code& ec);
inline void freeaddrinfo(addrinfo_type* ai);
inline boost::system::error_code getnameinfo(
const socket_addr_type* addr, std::size_t addrlen,
char* host, std::size_t hostlen, char* serv,
std::size_t servlen, int flags, boost::system::error_code& ec);
inline boost::system::error_code sync_getnameinfo(
const socket_addr_type* addr, std::size_t addrlen,
char* host, std::size_t hostlen, char* serv,
std::size_t servlen, int sock_type, boost::system::error_code& ec);
inline boost::system::error_code background_getnameinfo(
const weak_cancel_token_type& cancel_token,
const socket_addr_type* addr, std::size_t addrlen,
char* host, std::size_t hostlen, char* serv,
std::size_t servlen, int sock_type, boost::system::error_code& ec);
inline u_long_type network_to_host_long(u_long_type value);
inline u_long_type host_to_network_long(u_long_type value);
inline u_short_type network_to_host_short(u_short_type value);
inline u_short_type host_to_network_short(u_short_type value);
}
}
}
}
#define BOOST_ASIO_DETAIL_SOCKET_OPS_IPP
#undef __need_error_t
namespace boost {
namespace asio {
namespace detail {
namespace socket_ops {
void clear_last_error()
;
template <typename ReturnType>
ReturnType error_wrapper(ReturnType return_value,
boost::system::error_code& ec)
;
template <typename SockLenType>
socket_type call_accept(SockLenType msghdr::*,
socket_type s, socket_addr_type* addr, std::size_t* addrlen)
;
socket_type accept(socket_type s, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec)
;
socket_type sync_accept(socket_type s, state_type state,
socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec)
;
bool non_blocking_accept(socket_type s,
state_type state, socket_addr_type* addr, std::size_t* addrlen,
boost::system::error_code& ec, socket_type& new_socket)
;
template <typename SockLenType>
int call_bind(SockLenType msghdr::*,
socket_type s, const socket_addr_type* addr, std::size_t addrlen)
;
int bind(socket_type s, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec)
;
int close(socket_type s, state_type& state,
bool destruction, boost::system::error_code& ec)
;
bool set_user_non_blocking(socket_type s,
state_type& state, bool value, boost::system::error_code& ec)
;
bool set_internal_non_blocking(socket_type s,
state_type& state, bool value, boost::system::error_code& ec)
;
int shutdown(socket_type s, int what, boost::system::error_code& ec)
;
template <typename SockLenType>
int call_connect(SockLenType msghdr::*,
socket_type s, const socket_addr_type* addr, std::size_t addrlen)
;
int connect(socket_type s, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec)
;
void sync_connect(socket_type s, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec)
;
bool non_blocking_connect(socket_type s, boost::system::error_code& ec)
;
int socketpair(int af, int type, int protocol,
socket_type sv[2], boost::system::error_code& ec)
;
bool sockatmark(socket_type s, boost::system::error_code& ec)
;
size_t available(socket_type s, boost::system::error_code& ec)
;
int listen(socket_type s, int backlog, boost::system::error_code& ec)
;
void init_buf_iov_base(void*& base, void* addr)
;
template <typename T>
void init_buf_iov_base(T& base, void* addr)
;
typedef iovec buf;
void init_buf(buf& b, void* data, size_t size)
;
void init_buf(buf& b, const void* data, size_t size)
;
void init_msghdr_msg_name(void*& name, socket_addr_type* addr)
;
void init_msghdr_msg_name(void*& name, const socket_addr_type* addr)
;
template <typename T>
void init_msghdr_msg_name(T& name, socket_addr_type* addr)
;
template <typename T>
void init_msghdr_msg_name(T& name, const socket_addr_type* addr)
;
signed_size_type recv(socket_type s, buf* bufs, size_t count,
int flags, boost::system::error_code& ec)
;
size_t sync_recv(socket_type s, state_type state, buf* bufs,
size_t count, int flags, bool all_empty, boost::system::error_code& ec)
;
bool non_blocking_recv(socket_type s,
buf* bufs, size_t count, int flags, bool is_stream,
boost::system::error_code& ec, size_t& bytes_transferred)
;
signed_size_type recvfrom(socket_type s, buf* bufs, size_t count,
int flags, socket_addr_type* addr, std::size_t* addrlen,
boost::system::error_code& ec)
;
size_t sync_recvfrom(socket_type s, state_type state, buf* bufs,
size_t count, int flags, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec)
;
bool non_blocking_recvfrom(socket_type s,
buf* bufs, size_t count, int flags,
socket_addr_type* addr, std::size_t* addrlen,
boost::system::error_code& ec, size_t& bytes_transferred)
;
signed_size_type recvmsg(socket_type s, buf* bufs, size_t count,
int in_flags, int& out_flags, boost::system::error_code& ec)
;
size_t sync_recvmsg(socket_type s, state_type state,
buf* bufs, size_t count, int in_flags, int& out_flags,
boost::system::error_code& ec)
;
bool non_blocking_recvmsg(socket_type s,
buf* bufs, size_t count, int in_flags, int& out_flags,
boost::system::error_code& ec, size_t& bytes_transferred)
;
signed_size_type send(socket_type s, const buf* bufs, size_t count,
int flags, boost::system::error_code& ec)
;
size_t sync_send(socket_type s, state_type state, const buf* bufs,
size_t count, int flags, bool all_empty, boost::system::error_code& ec)
;
bool non_blocking_send(socket_type s,
const buf* bufs, size_t count, int flags,
boost::system::error_code& ec, size_t& bytes_transferred)
;
signed_size_type sendto(socket_type s, const buf* bufs, size_t count,
int flags, const socket_addr_type* addr, std::size_t addrlen,
boost::system::error_code& ec)
;
size_t sync_sendto(socket_type s, state_type state, const buf* bufs,
size_t count, int flags, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec)
;
bool non_blocking_sendto(socket_type s,
const buf* bufs, size_t count, int flags,
const socket_addr_type* addr, std::size_t addrlen,
boost::system::error_code& ec, size_t& bytes_transferred)
;
socket_type socket(int af, int type, int protocol,
boost::system::error_code& ec)
;
template <typename SockLenType>
int call_setsockopt(SockLenType msghdr::*,
socket_type s, int level, int optname,
const void* optval, std::size_t optlen)
;
int setsockopt(socket_type s, state_type& state, int level, int optname,
const void* optval, std::size_t optlen, boost::system::error_code& ec)
;
template <typename SockLenType>
int call_getsockopt(SockLenType msghdr::*,
socket_type s, int level, int optname,
void* optval, std::size_t* optlen)
;
int getsockopt(socket_type s, state_type state, int level, int optname,
void* optval, size_t* optlen, boost::system::error_code& ec)
;
template <typename SockLenType>
int call_getpeername(SockLenType msghdr::*,
socket_type s, socket_addr_type* addr, std::size_t* addrlen)
;
int getpeername(socket_type s, socket_addr_type* addr,
std::size_t* addrlen, bool cached, boost::system::error_code& ec)
;
template <typename SockLenType>
int call_getsockname(SockLenType msghdr::*,
socket_type s, socket_addr_type* addr, std::size_t* addrlen)
;
int getsockname(socket_type s, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec)
;
int ioctl(socket_type s, state_type& state, int cmd,
ioctl_arg_type* arg, boost::system::error_code& ec)
;
int select(int nfds, fd_set* readfds, fd_set* writefds,
fd_set* exceptfds, timeval* timeout, boost::system::error_code& ec)
;
int poll_read(socket_type s, state_type state, boost::system::error_code& ec)
;
int poll_write(socket_type s, state_type state, boost::system::error_code& ec)
;
int poll_connect(socket_type s, boost::system::error_code& ec)
;
const char* inet_ntop(int af, const void* src, char* dest, size_t length,
unsigned long scope_id, boost::system::error_code& ec)
;
int inet_pton(int af, const char* src, void* dest,
unsigned long* scope_id, boost::system::error_code& ec)
;
int gethostname(char* name, int namelen, boost::system::error_code& ec)
;
boost::system::error_code translate_addrinfo_error(int error)
;
boost::system::error_code getaddrinfo(const char* host,
const char* service, const addrinfo_type& hints,
addrinfo_type** result, boost::system::error_code& ec)
;
boost::system::error_code background_getaddrinfo(
const weak_cancel_token_type& cancel_token, const char* host,
const char* service, const addrinfo_type& hints,
addrinfo_type** result, boost::system::error_code& ec)
;
void freeaddrinfo(addrinfo_type* ai)
;
boost::system::error_code getnameinfo(const socket_addr_type* addr,
std::size_t addrlen, char* host, std::size_t hostlen,
char* serv, std::size_t servlen, int flags, boost::system::error_code& ec)
;
boost::system::error_code sync_getnameinfo(
const socket_addr_type* addr, std::size_t addrlen,
char* host, std::size_t hostlen, char* serv,
std::size_t servlen, int sock_type, boost::system::error_code& ec)
;
boost::system::error_code background_getnameinfo(
const weak_cancel_token_type& cancel_token,
const socket_addr_type* addr, std::size_t addrlen,
char* host, std::size_t hostlen, char* serv,
std::size_t servlen, int sock_type, boost::system::error_code& ec)
;
u_long_type network_to_host_long(u_long_type value)
;
u_long_type host_to_network_long(u_long_type value)
;
u_short_type network_to_host_short(u_short_type value)
;
u_short_type host_to_network_short(u_short_type value)
;
}
}
}
}
namespace boost {
namespace asio {
namespace detail {
class socket_holder
: private noncopyable
{
public:
socket_holder()
;
explicit socket_holder(socket_type s)
;
~socket_holder()
;
socket_type get() const
;
void reset()
;
void reset(socket_type s)
;
socket_type release()
;
private:
socket_type socket_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Socket, typename Protocol>
class reactive_socket_accept_op_base : public reactor_op
{
public:
reactive_socket_accept_op_base(socket_type socket,
socket_ops::state_type state, Socket& peer, const Protocol& protocol,
typename Protocol::endpoint* peer_endpoint, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
socket_type socket_;
socket_ops::state_type state_;
Socket& peer_;
Protocol protocol_;
typename Protocol::endpoint* peer_endpoint_;
};
template <typename Socket, typename Protocol, typename Handler>
class reactive_socket_accept_op :
public reactive_socket_accept_op_base<Socket, Protocol>
{
public:
struct ptr { Handler* h; void* v; reactive_socket_accept_op* p; ~ptr() ; void reset() ; };
reactive_socket_accept_op(socket_type socket,
socket_ops::state_type state, Socket& peer, const Protocol& protocol,
typename Protocol::endpoint* peer_endpoint, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_CONNECT_OP_HPP
namespace boost {
namespace asio {
namespace detail {
class reactive_socket_connect_op_base : public reactor_op
{
public:
reactive_socket_connect_op_base(socket_type socket, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
socket_type socket_;
};
template <typename Handler>
class reactive_socket_connect_op : public reactive_socket_connect_op_base
{
public:
struct ptr { Handler* h; void* v; reactive_socket_connect_op* p; ~ptr() ; void reset() ; };
reactive_socket_connect_op(socket_type socket, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECVFROM_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename MutableBufferSequence, typename Endpoint>
class reactive_socket_recvfrom_op_base : public reactor_op
{
public:
reactive_socket_recvfrom_op_base(socket_type socket, int protocol_type,
const MutableBufferSequence& buffers, Endpoint& endpoint,
socket_base::message_flags flags, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
socket_type socket_;
int protocol_type_;
MutableBufferSequence buffers_;
Endpoint& sender_endpoint_;
socket_base::message_flags flags_;
};
template <typename MutableBufferSequence, typename Endpoint, typename Handler>
class reactive_socket_recvfrom_op :
public reactive_socket_recvfrom_op_base<MutableBufferSequence, Endpoint>
{
public:
struct ptr { Handler* h; void* v; reactive_socket_recvfrom_op* p; ~ptr() ; void reset() ; };
reactive_socket_recvfrom_op(socket_type socket, int protocol_type,
const MutableBufferSequence& buffers, Endpoint& endpoint,
socket_base::message_flags flags, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SENDTO_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename ConstBufferSequence, typename Endpoint>
class reactive_socket_sendto_op_base : public reactor_op
{
public:
reactive_socket_sendto_op_base(socket_type socket,
const ConstBufferSequence& buffers, const Endpoint& endpoint,
socket_base::message_flags flags, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
socket_type socket_;
ConstBufferSequence buffers_;
Endpoint destination_;
socket_base::message_flags flags_;
};
template <typename ConstBufferSequence, typename Endpoint, typename Handler>
class reactive_socket_sendto_op :
public reactive_socket_sendto_op_base<ConstBufferSequence, Endpoint>
{
public:
struct ptr { Handler* h; void* v; reactive_socket_sendto_op* p; ~ptr() ; void reset() ; };
reactive_socket_sendto_op(socket_type socket,
const ConstBufferSequence& buffers, const Endpoint& endpoint,
socket_base::message_flags flags, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_BASE_HPP
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECV_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename MutableBufferSequence>
class reactive_socket_recv_op_base : public reactor_op
{
public:
reactive_socket_recv_op_base(socket_type socket,
socket_ops::state_type state, const MutableBufferSequence& buffers,
socket_base::message_flags flags, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
socket_type socket_;
socket_ops::state_type state_;
MutableBufferSequence buffers_;
socket_base::message_flags flags_;
};
template <typename MutableBufferSequence, typename Handler>
class reactive_socket_recv_op :
public reactive_socket_recv_op_base<MutableBufferSequence>
{
public:
struct ptr { Handler* h; void* v; reactive_socket_recv_op* p; ~ptr() ; void reset() ; };
reactive_socket_recv_op(socket_type socket,
socket_ops::state_type state, const MutableBufferSequence& buffers,
socket_base::message_flags flags, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECVMSG_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename MutableBufferSequence>
class reactive_socket_recvmsg_op_base : public reactor_op
{
public:
reactive_socket_recvmsg_op_base(socket_type socket,
const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
socket_base::message_flags& out_flags, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
socket_type socket_;
MutableBufferSequence buffers_;
socket_base::message_flags in_flags_;
socket_base::message_flags& out_flags_;
};
template <typename MutableBufferSequence, typename Handler>
class reactive_socket_recvmsg_op :
public reactive_socket_recvmsg_op_base<MutableBufferSequence>
{
public:
struct ptr { Handler* h; void* v; reactive_socket_recvmsg_op* p; ~ptr() ; void reset() ; };
reactive_socket_recvmsg_op(socket_type socket,
const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
socket_base::message_flags& out_flags, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SEND_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename ConstBufferSequence>
class reactive_socket_send_op_base : public reactor_op
{
public:
reactive_socket_send_op_base(socket_type socket,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
socket_type socket_;
ConstBufferSequence buffers_;
socket_base::message_flags flags_;
};
template <typename ConstBufferSequence, typename Handler>
class reactive_socket_send_op :
public reactive_socket_send_op_base<ConstBufferSequence>
{
public:
struct ptr { Handler* h; void* v; reactive_socket_send_op* p; ~ptr() ; void reset() ; };
reactive_socket_send_op(socket_type socket,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
class reactive_socket_service_base
{
public:
typedef socket_type native_handle_type;
struct base_implementation_type
{
socket_type socket_;
socket_ops::state_type state_;
reactor::per_descriptor_data reactor_data_;
};
inline reactive_socket_service_base(
boost::asio::io_service& io_service);
inline void shutdown_service();
inline void construct(base_implementation_type& impl);
inline void base_move_construct(base_implementation_type& impl,
base_implementation_type& other_impl);
inline void base_move_assign(base_implementation_type& impl,
reactive_socket_service_base& other_service,
base_implementation_type& other_impl);
inline void destroy(base_implementation_type& impl);
bool is_open(const base_implementation_type& impl) const
;
inline boost::system::error_code close(
base_implementation_type& impl, boost::system::error_code& ec);
native_handle_type native_handle(base_implementation_type& impl)
;
inline boost::system::error_code cancel(
base_implementation_type& impl, boost::system::error_code& ec);
bool at_mark(const base_implementation_type& impl,
boost::system::error_code& ec) const
;
std::size_t available(const base_implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code listen(base_implementation_type& impl,
int backlog, boost::system::error_code& ec)
;
template <typename IO_Control_Command>
boost::system::error_code io_control(base_implementation_type& impl,
IO_Control_Command& command, boost::system::error_code& ec)
;
bool non_blocking(const base_implementation_type& impl) const
;
boost::system::error_code non_blocking(base_implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const base_implementation_type& impl) const
;
boost::system::error_code native_non_blocking(base_implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
boost::system::error_code shutdown(base_implementation_type& impl,
socket_base::shutdown_type what, boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
size_t send(base_implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
size_t send(base_implementation_type& impl, const null_buffers&,
socket_base::message_flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename Handler>
void async_send(base_implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, Handler& handler)
;
template <typename Handler>
void async_send(base_implementation_type& impl, const null_buffers&,
socket_base::message_flags, Handler& handler)
;
template <typename MutableBufferSequence>
size_t receive(base_implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
size_t receive(base_implementation_type& impl, const null_buffers&,
socket_base::message_flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename Handler>
void async_receive(base_implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags, Handler& handler)
;
template <typename Handler>
void async_receive(base_implementation_type& impl, const null_buffers&,
socket_base::message_flags flags, Handler& handler)
;
template <typename MutableBufferSequence>
size_t receive_with_flags(base_implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags in_flags,
socket_base::message_flags& out_flags, boost::system::error_code& ec)
;
size_t receive_with_flags(base_implementation_type& impl,
const null_buffers&, socket_base::message_flags,
socket_base::message_flags& out_flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename Handler>
void async_receive_with_flags(base_implementation_type& impl,
const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
socket_base::message_flags& out_flags, Handler& handler)
;
template <typename Handler>
void async_receive_with_flags(base_implementation_type& impl,
const null_buffers&, socket_base::message_flags in_flags,
socket_base::message_flags& out_flags, Handler& handler)
;
protected:
inline boost::system::error_code do_open(
base_implementation_type& impl, int af,
int type, int protocol, boost::system::error_code& ec);
inline boost::system::error_code do_assign(
base_implementation_type& impl, int type,
const native_handle_type& native_socket, boost::system::error_code& ec);
inline void start_op(base_implementation_type& impl, int op_type,
reactor_op* op, bool is_continuation, bool is_non_blocking, bool noop);
inline void start_accept_op(base_implementation_type& impl,
reactor_op* op, bool is_continuation, bool peer_is_open);
inline void start_connect_op(base_implementation_type& impl,
reactor_op* op, bool is_continuation,
const socket_addr_type* addr, size_t addrlen);
reactor& reactor_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_REACTIVE_SOCKET_SERVICE_BASE_IPP
namespace boost {
namespace asio {
namespace detail {
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Protocol>
class reactive_socket_service :
public reactive_socket_service_base
{
public:
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
typedef socket_type native_handle_type;
struct implementation_type :
reactive_socket_service_base::base_implementation_type
{
implementation_type()
;
protocol_type protocol_;
};
reactive_socket_service(boost::asio::io_service& io_service)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
reactive_socket_service_base& other_service,
implementation_type& other_impl)
;
template <typename Protocol1>
void converting_move_construct(implementation_type& impl,
typename reactive_socket_service<
Protocol1>::implementation_type& other_impl)
;
boost::system::error_code open(implementation_type& impl,
const protocol_type& protocol, boost::system::error_code& ec)
;
boost::system::error_code assign(implementation_type& impl,
const protocol_type& protocol, const native_handle_type& native_socket,
boost::system::error_code& ec)
;
native_handle_type native_handle(implementation_type& impl)
;
boost::system::error_code bind(implementation_type& impl,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
template <typename Option>
boost::system::error_code set_option(implementation_type& impl,
const Option& option, boost::system::error_code& ec)
;
template <typename Option>
boost::system::error_code get_option(const implementation_type& impl,
Option& option, boost::system::error_code& ec) const
;
endpoint_type local_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
endpoint_type remote_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
template <typename ConstBufferSequence>
size_t send_to(implementation_type& impl, const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags,
boost::system::error_code& ec)
;
size_t send_to(implementation_type& impl, const null_buffers&,
const endpoint_type&, socket_base::message_flags,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename Handler>
void async_send_to(implementation_type& impl,
const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags,
Handler& handler)
;
template <typename Handler>
void async_send_to(implementation_type& impl, const null_buffers&,
const endpoint_type&, socket_base::message_flags, Handler& handler)
;
template <typename MutableBufferSequence>
size_t receive_from(implementation_type& impl,
const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint, socket_base::message_flags flags,
boost::system::error_code& ec)
;
size_t receive_from(implementation_type& impl, const null_buffers&,
endpoint_type& sender_endpoint, socket_base::message_flags,
boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename Handler>
void async_receive_from(implementation_type& impl,
const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
socket_base::message_flags flags, Handler& handler)
;
template <typename Handler>
void async_receive_from(implementation_type& impl,
const null_buffers&, endpoint_type& sender_endpoint,
socket_base::message_flags flags, Handler& handler)
;
template <typename Socket>
boost::system::error_code accept(implementation_type& impl,
Socket& peer, endpoint_type* peer_endpoint, boost::system::error_code& ec)
;
template <typename Socket, typename Handler>
void async_accept(implementation_type& impl, Socket& peer,
endpoint_type* peer_endpoint, Handler& handler)
;
boost::system::error_code connect(implementation_type& impl,
const endpoint_type& peer_endpoint, boost::system::error_code& ec)
;
template <typename Handler>
void async_connect(implementation_type& impl,
const endpoint_type& peer_endpoint, Handler& handler)
;
};
}
}
}
namespace boost {
namespace asio {
template <typename Protocol>
class datagram_socket_service
: public boost::asio::detail::service_base<datagram_socket_service<Protocol> >
{
public:
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
private:
typedef detail::reactive_socket_service<Protocol> service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
typedef typename service_impl_type::native_handle_type native_type;
typedef typename service_impl_type::native_handle_type native_handle_type;
explicit datagram_socket_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
datagram_socket_service& other_service,
implementation_type& other_impl)
;
template <typename Protocol1>
void converting_move_construct(implementation_type& impl,
typename datagram_socket_service<
Protocol1>::implementation_type& other_impl,
typename enable_if<is_convertible<
Protocol1, Protocol>::value>::type* = 0)
;
void destroy(implementation_type& impl)
;
boost::system::error_code open(implementation_type& impl,
const protocol_type& protocol, boost::system::error_code& ec)
;
boost::system::error_code assign(implementation_type& impl,
const protocol_type& protocol, const native_handle_type& native_socket,
boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_type native(implementation_type& impl)
;
native_handle_type native_handle(implementation_type& impl)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
bool at_mark(const implementation_type& impl,
boost::system::error_code& ec) const
;
std::size_t available(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code bind(implementation_type& impl,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
boost::system::error_code connect(implementation_type& impl,
const endpoint_type& peer_endpoint, boost::system::error_code& ec)
;
template <typename ConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ConnectHandler, void (boost::system::error_code)>::type>::type
async_connect(implementation_type& impl,
const endpoint_type& peer_endpoint,
ConnectHandler&& handler)
;
template <typename SettableSocketOption>
boost::system::error_code set_option(implementation_type& impl,
const SettableSocketOption& option, boost::system::error_code& ec)
;
template <typename GettableSocketOption>
boost::system::error_code get_option(const implementation_type& impl,
GettableSocketOption& option, boost::system::error_code& ec) const
;
template <typename IoControlCommand>
boost::system::error_code io_control(implementation_type& impl,
IoControlCommand& command, boost::system::error_code& ec)
;
bool non_blocking(const implementation_type& impl) const
;
boost::system::error_code non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const implementation_type& impl) const
;
boost::system::error_code native_non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
endpoint_type local_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
endpoint_type remote_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code shutdown(implementation_type& impl,
socket_base::shutdown_type what, boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t send(implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(implementation_type& impl, const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename ConstBufferSequence>
std::size_t send_to(implementation_type& impl,
const ConstBufferSequence& buffers, const endpoint_type& destination,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send_to(implementation_type& impl,
const ConstBufferSequence& buffers, const endpoint_type& destination,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags,
ReadHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive_from(implementation_type& impl,
const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive_from(implementation_type& impl,
const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
socket_base::message_flags flags,
ReadHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename Protocol,
typename DatagramSocketService = datagram_socket_service<Protocol> >
class basic_datagram_socket
: public basic_socket<Protocol, DatagramSocketService>
{
public:
typedef typename DatagramSocketService::native_handle_type native_type;
typedef typename DatagramSocketService::native_handle_type native_handle_type;
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
explicit basic_datagram_socket(boost::asio::io_service& io_service)
;
basic_datagram_socket(boost::asio::io_service& io_service,
const protocol_type& protocol)
;
basic_datagram_socket(boost::asio::io_service& io_service,
const endpoint_type& endpoint)
;
basic_datagram_socket(boost::asio::io_service& io_service,
const protocol_type& protocol, const native_handle_type& native_socket)
;
basic_datagram_socket(basic_datagram_socket&& other)
;
basic_datagram_socket& operator=(basic_datagram_socket&& other)
;
template <typename Protocol1, typename DatagramSocketService1>
basic_datagram_socket(
basic_datagram_socket<Protocol1, DatagramSocketService1>&& other,
typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
;
template <typename Protocol1, typename DatagramSocketService1>
typename enable_if<is_convertible<Protocol1, Protocol>::value,
basic_datagram_socket>::type& operator=(
basic_datagram_socket<Protocol1, DatagramSocketService1>&& other)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename ConstBufferSequence>
std::size_t send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination)
;
template <typename ConstBufferSequence>
std::size_t send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags)
;
template <typename ConstBufferSequence>
std::size_t send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination,
WriteHandler&& handler)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags,
ReadHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint)
;
template <typename MutableBufferSequence>
std::size_t receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint, socket_base::message_flags flags)
;
template <typename MutableBufferSequence>
std::size_t receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint, socket_base::message_flags flags,
boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint,
ReadHandler&& handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint, socket_base::message_flags flags,
ReadHandler&& handler)
;
};
}
}
#define BOOST_ASIO_BASIC_DEADLINE_TIMER_HPP
#define BOOST_ASIO_DEADLINE_TIMER_SERVICE_HPP
#define BOOST_ASIO_DETAIL_DEADLINE_TIMER_SERVICE_HPP
#define BOOST_ASIO_DETAIL_TIMER_QUEUE_HPP
#define BOOST_ASIO_DETAIL_DATE_TIME_FWD_HPP
namespace boost {
namespace date_time {
template<class T, class TimeSystem>
class base_time;
}
namespace posix_time {
class ptime;
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Time_Traits>
class timer_queue
: public timer_queue_base
{
public:
typedef typename Time_Traits::time_type time_type;
typedef typename Time_Traits::duration_type duration_type;
class per_timer_data
{
public:
per_timer_data() ;
private:
friend class timer_queue;
op_queue<wait_op> op_queue_;
std::size_t heap_index_;
per_timer_data* next_;
per_timer_data* prev_;
};
timer_queue()
;
bool enqueue_timer(const time_type& time, per_timer_data& timer, wait_op* op)
;
virtual bool empty() const
;
virtual long wait_duration_msec(long max_duration) const
;
virtual long wait_duration_usec(long max_duration) const
;
virtual void get_ready_timers(op_queue<operation>& ops)
;
virtual void get_all_timers(op_queue<operation>& ops)
;
std::size_t cancel_timer(per_timer_data& timer, op_queue<operation>& ops,
std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)())
;
private:
void up_heap(std::size_t index)
;
void down_heap(std::size_t index)
;
void swap_heap(std::size_t index1, std::size_t index2)
;
void remove_timer(per_timer_data& timer)
;
template <typename Time_Type>
static bool is_positive_infinity(const Time_Type&)
;
template <typename T, typename TimeSystem>
static bool is_positive_infinity(
const boost::date_time::base_time<T, TimeSystem>& time)
;
template <typename Duration>
long to_msec(const Duration& d, long max_duration) const
;
template <typename Duration>
long to_usec(const Duration& d, long max_duration) const
;
per_timer_data* timers_;
struct heap_entry
{
time_type time_;
per_timer_data* timer_;
};
std::vector<heap_entry> heap_;
};
}
}
}
#define BOOST_ASIO_DETAIL_TIMER_SCHEDULER_HPP
#define BOOST_ASIO_DETAIL_TIMER_SCHEDULER_FWD_HPP
namespace boost {
namespace asio {
namespace detail {
typedef class epoll_reactor timer_scheduler;
}
}
}
#define BOOST_ASIO_DETAIL_WAIT_HANDLER_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Handler>
class wait_handler : public wait_op
{
public:
struct ptr { Handler* h; void* v; wait_handler* p; ~ptr() ; void reset() ; };
wait_handler(Handler& h)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Time_Traits>
class deadline_timer_service
{
public:
typedef typename Time_Traits::time_type time_type;
typedef typename Time_Traits::duration_type duration_type;
struct implementation_type
: private boost::asio::detail::noncopyable
{
time_type expiry;
bool might_have_pending_waits;
typename timer_queue<Time_Traits>::per_timer_data timer_data;
};
deadline_timer_service(boost::asio::io_service& io_service)
;
~deadline_timer_service()
;
void shutdown_service()
;
void construct(implementation_type& impl)
;
void destroy(implementation_type& impl)
;
std::size_t cancel(implementation_type& impl, boost::system::error_code& ec)
;
std::size_t cancel_one(implementation_type& impl,
boost::system::error_code& ec)
;
time_type expires_at(const implementation_type& impl) const
;
std::size_t expires_at(implementation_type& impl,
const time_type& expiry_time, boost::system::error_code& ec)
;
duration_type expires_from_now(const implementation_type& impl) const
;
std::size_t expires_from_now(implementation_type& impl,
const duration_type& expiry_time, boost::system::error_code& ec)
;
void wait(implementation_type& impl, boost::system::error_code& ec)
;
template <typename Handler>
void async_wait(implementation_type& impl, Handler& handler)
;
private:
template <typename Duration>
void do_wait(const Duration& timeout, boost::system::error_code& ec)
;
timer_queue<Time_Traits> timer_queue_;
timer_scheduler& scheduler_;
};
}
}
}
#define BOOST_ASIO_TIME_TRAITS_HPP
#define POSIX_TIME_TYPES_HPP___
#define DATE_TIME_TIME_CLOCK_HPP___
#define DATE_TIME_C_TIME_HPP___
#define _GLIBCXX_CTIME 1
#undef clock
#undef difftime
#undef mktime
#undef time
#undef asctime
#undef ctime
#undef gmtime
#undef localtime
#undef strftime
namespace std
{
using ::clock_t;
using ::time_t;
using ::tm;
using ::clock;
using ::difftime;
using ::mktime;
using ::time;
using ::asctime;
using ::ctime;
using ::gmtime;
using ::localtime;
using ::strftime;
}
#define DATE_TIME_COMPILER_CONFIG_HPP___
#define DATE_TIME_LOCALE_CONFIG_HPP___
#define BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK
#define BOOST_DATE_TIME_OPTIONAL_GREGORIAN_TYPES
#define BOOST_DATE_TIME_UNREACHABLE_EXPRESSION(x) std::abort()
#define BOOST_DATE_TIME_DECL
#define BOOST_LIB_NAME boost_date_time
#undef BOOST_LIB_NAME
#define BOOST_DATE_TIME_HAS_REENTRANT_STD_FUNCTIONS
#define _SYS_TIME_H 1
#define __need_time_t
#define __need_timeval
#undef __need_timeval
extern "C" {
#define TIMEVAL_TO_TIMESPEC(tv,ts) { (ts)->tv_sec = (tv)->tv_sec; (ts)->tv_nsec = (tv)->tv_usec * 1000; }
#define TIMESPEC_TO_TIMEVAL(tv,ts) { (tv)->tv_sec = (ts)->tv_sec; (tv)->tv_usec = (ts)->tv_nsec / 1000; }
struct timezone
{
int tz_minuteswest;
int tz_dsttime;
};
typedef struct timezone *__restrict __timezone_ptr_t;
extern int gettimeofday (struct timeval *__restrict __tv,
__timezone_ptr_t __tz) throw () __attribute__ ((__nonnull__ (1)));
extern int settimeofday (const struct timeval *__tv,
const struct timezone *__tz)
throw ();
extern int adjtime (const struct timeval *__delta,
struct timeval *__olddelta) throw ();
enum __itimer_which
{
ITIMER_REAL = 0,
#define ITIMER_REAL ITIMER_REAL
ITIMER_VIRTUAL = 1,
#define ITIMER_VIRTUAL ITIMER_VIRTUAL
ITIMER_PROF = 2
#define ITIMER_PROF ITIMER_PROF
};
struct itimerval
{
struct timeval it_interval;
struct timeval it_value;
};
typedef int __itimer_which_t;
extern int getitimer (__itimer_which_t __which,
struct itimerval *__value) throw ();
extern int setitimer (__itimer_which_t __which,
const struct itimerval *__restrict __new,
struct itimerval *__restrict __old) throw ();
extern int utimes (const char *__file, const struct timeval __tvp[2])
throw () __attribute__ ((__nonnull__ (1)));
extern int lutimes (const char *__file, const struct timeval __tvp[2])
throw () __attribute__ ((__nonnull__ (1)));
extern int futimes (int __fd, const struct timeval __tvp[2]) throw ();
extern int futimesat (int __fd, const char *__file,
const struct timeval __tvp[2]) throw ();
#define timerisset(tvp) ((tvp)->tv_sec || (tvp)->tv_usec)
#define timerclear(tvp) ((tvp)->tv_sec = (tvp)->tv_usec = 0)
#define timercmp(a,b,CMP) (((a)->tv_sec == (b)->tv_sec) ? ((a)->tv_usec CMP (b)->tv_usec) : ((a)->tv_sec CMP (b)->tv_sec))
#define timeradd(a,b,result) do { (result)->tv_sec = (a)->tv_sec + (b)->tv_sec; (result)->tv_usec = (a)->tv_usec + (b)->tv_usec; if ((result)->tv_usec >= 1000000) { ++(result)->tv_sec; (result)->tv_usec -= 1000000; } } while (0)
#define timersub(a,b,result) do { (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; (result)->tv_usec = (a)->tv_usec - (b)->tv_usec; if ((result)->tv_usec < 0) { --(result)->tv_sec; (result)->tv_usec += 1000000; } } while (0)
}
namespace boost {
namespace date_time {
struct c_time {
public:
static std::tm* localtime(const std::time_t* t, std::tm* result)
;
static std::tm* gmtime(const std::time_t* t, std::tm* result)
;
};
}}
#define BOOST_SHARED_PTR_HPP_INCLUDED
#define BOOST_SMART_PTR_SHARED_PTR_HPP_INCLUDED
#define BOOST_CONFIG_MEMORY
#define BOOST_TR1_NO_RECURSION
#define BOOST_CONFIG_NO_MEMORY_RECURSION
#undef BOOST_TR1_NO_RECURSION
#undef BOOST_CONFIG_NO_MEMORY_RECURSION
#undef BOOST_ASSERT
#undef _ASSERT_H
#undef assert
#undef __ASSERT_VOID_CAST
#undef assert_perror
#define _ASSERT_H 1
#define __ASSERT_VOID_CAST static_cast<void>
#define assert(expr) (__ASSERT_VOID_CAST (0))
#define assert_perror(errnum) (__ASSERT_VOID_CAST (0))
#define BOOST_ASSERT(expr) assert(expr)
#undef BOOST_ASSERT_MSG
#define BOOST_ASSERT_MSG(expr,msg) ((void)0)
#undef BOOST_VERIFY
#define BOOST_VERIFY(expr) ((void)(expr))
#define BOOST_CHECKED_DELETE_HPP_INCLUDED
namespace boost
{
template<class T> void checked_delete(T * x)
;
template<class T> void checked_array_delete(T * x)
;
template<class T> struct checked_deleter
{
typedef void result_type;
typedef T * argument_type;
void operator()(T * x) const
;
};
template<class T> struct checked_array_deleter
{
typedef void result_type;
typedef T * argument_type;
void operator()(T * x) const
;
};
}
#define BOOST_SMART_PTR_DETAIL_SHARED_COUNT_HPP_INCLUDED
#define BOOST_SMART_PTR_BAD_WEAK_PTR_HPP_INCLUDED
namespace boost
{
class bad_weak_ptr: public std::exception
{
public:
virtual char const * what() const throw()
;
};
}
#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_HPP_INCLUDED
#define BOOST_SMART_PTR_DETAIL_SP_HAS_SYNC_HPP_INCLUDED
#define BOOST_SP_HAS_SYNC
#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_GCC_X86_HPP_INCLUDED
#define BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED
namespace boost
{
namespace detail
{
typedef std::type_info sp_typeinfo;
}
}
#define BOOST_SP_TYPEID(T) typeid(T)
namespace boost
{
namespace detail
{
int atomic_exchange_and_add( int * pw, int dv )
;
void atomic_increment( int * pw )
;
int atomic_conditional_increment( int * pw )
;
class sp_counted_base
{
private:
sp_counted_base( sp_counted_base const & );
sp_counted_base & operator= ( sp_counted_base const & );
int use_count_;
int weak_count_;
public:
sp_counted_base()
;
virtual ~sp_counted_base()
;
virtual void dispose() = 0;
virtual void destroy()
;
virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
virtual void * get_untyped_deleter() = 0;
void add_ref_copy()
;
bool add_ref_lock()
;
void release()
;
void weak_add_ref()
;
void weak_release()
;
long use_count() const
;
};
}
}
#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_IMPL_HPP_INCLUDED
namespace boost
{
namespace detail
{
template<class X> class sp_counted_impl_p: public sp_counted_base
{
private:
X * px_;
sp_counted_impl_p( sp_counted_impl_p const & );
sp_counted_impl_p & operator= ( sp_counted_impl_p const & );
typedef sp_counted_impl_p<X> this_type;
public:
explicit sp_counted_impl_p( X * px )
;
virtual void dispose()
;
virtual void * get_deleter( detail::sp_typeinfo const & )
;
virtual void * get_untyped_deleter()
;
};
template<class P, class D> class sp_counted_impl_pd: public sp_counted_base
{
private:
P ptr;
D del;
sp_counted_impl_pd( sp_counted_impl_pd const & );
sp_counted_impl_pd & operator= ( sp_counted_impl_pd const & );
typedef sp_counted_impl_pd<P, D> this_type;
public:
sp_counted_impl_pd( P p, D & d )
;
sp_counted_impl_pd( P p )
;
virtual void dispose()
;
virtual void * get_deleter( detail::sp_typeinfo const & ti )
;
virtual void * get_untyped_deleter()
;
};
template<class P, class D, class A> class sp_counted_impl_pda: public sp_counted_base
{
private:
P p_;
D d_;
A a_;
sp_counted_impl_pda( sp_counted_impl_pda const & );
sp_counted_impl_pda & operator= ( sp_counted_impl_pda const & );
typedef sp_counted_impl_pda<P, D, A> this_type;
public:
sp_counted_impl_pda( P p, D & d, A a )
;
sp_counted_impl_pda( P p, A a )
;
virtual void dispose()
;
virtual void destroy()
;
virtual void * get_deleter( detail::sp_typeinfo const & ti )
;
virtual void * get_untyped_deleter()
;
};
}
}
#define BOOST_UTILITY_ADDRESSOF_HPP
namespace boost
{
namespace detail
{
template<class T> struct addr_impl_ref
{
T & v_;
addr_impl_ref( T & v ) ;
operator T& () const ;
private:
addr_impl_ref & operator=(const addr_impl_ref &);
};
template<class T> struct addressof_impl
{
static T * f( T & v, long )
;
static T * f( T * v, int )
;
};
}
template<class T> T * addressof( T & v )
;
}
namespace boost
{
namespace detail
{
struct sp_nothrow_tag {};
template< class D > struct sp_inplace_tag
{
};
template< class T > class sp_reference_wrapper
{
public:
explicit sp_reference_wrapper( T & t)
;
template< class Y > void operator()( Y * p ) const
;
private:
T * t_;
};
template< class D > struct sp_convert_reference
{
typedef D type;
};
template< class D > struct sp_convert_reference< D& >
{
typedef sp_reference_wrapper< D > type;
};
class weak_count;
class shared_count
{
private:
sp_counted_base * pi_;
friend class weak_count;
public:
shared_count()
;
template<class Y> explicit shared_count( Y * p )
;
template<class P, class D> shared_count( P p, D d )
;
template< class P, class D > shared_count( P p, sp_inplace_tag<D> )
;
template<class P, class D, class A> shared_count( P p, D d, A a )
;
template< class P, class D, class A > shared_count( P p, sp_inplace_tag< D >, A a )
;
template<class Y>
explicit shared_count( std::auto_ptr<Y> & r )
;
template<class Y, class D>
explicit shared_count( std::unique_ptr<Y, D> & r )
;
~shared_count()
;
shared_count(shared_count const & r)
;
shared_count(shared_count && r)
;
explicit shared_count(weak_count const & r);
shared_count( weak_count const & r, sp_nothrow_tag );
shared_count & operator= (shared_count const & r)
;
void swap(shared_count & r)
;
long use_count() const
;
bool unique() const
;
bool empty() const
;
friend bool operator==(shared_count const & a, shared_count const & b)
;
friend bool operator<(shared_count const & a, shared_count const & b)
;
void * get_deleter( sp_typeinfo const & ti ) const
;
void * get_untyped_deleter() const
;
};
class weak_count
{
private:
sp_counted_base * pi_;
friend class shared_count;
public:
weak_count()
;
weak_count(shared_count const & r)
;
weak_count(weak_count const & r)
;
weak_count(weak_count && r)
;
~weak_count()
;
weak_count & operator= (shared_count const & r)
;
weak_count & operator= (weak_count const & r)
;
void swap(weak_count & r)
;
long use_count() const
;
bool empty() const
;
friend bool operator==(weak_count const & a, weak_count const & b)
;
friend bool operator<(weak_count const & a, weak_count const & b)
;
};
}
}
#define BOOST_SMART_PTR_DETAIL_SP_CONVERTIBLE_HPP_INCLUDED
namespace boost
{
namespace detail
{
template< class Y, class T > struct sp_convertible
{
typedef char (&yes) [1];
typedef char (&no) [2];
static yes f( T* );
static no f( ... );
enum _vt { value = sizeof( (f)( static_cast<Y*>(0) ) ) == sizeof(yes) };
};
template< class Y, class T > struct sp_convertible< Y, T[] >
{
enum _vt { value = false };
};
template< class Y, class T > struct sp_convertible< Y[], T[] >
{
enum _vt { value = sp_convertible< Y[1], T[1] >::value };
};
template< class Y, std::size_t N, class T > struct sp_convertible< Y[N], T[] >
{
enum _vt { value = sp_convertible< Y[1], T[1] >::value };
};
struct sp_empty
{
};
template< bool > struct sp_enable_if_convertible_impl;
template<> struct sp_enable_if_convertible_impl<true>
{
typedef sp_empty type;
};
template<> struct sp_enable_if_convertible_impl<false>
{
};
template< class Y, class T > struct sp_enable_if_convertible: public sp_enable_if_convertible_impl< sp_convertible< Y, T >::value >
{
};
}
}
#define BOOST_SMART_PTR_DETAIL_SP_NULLPTR_T_HPP_INCLUDED
namespace boost
{
namespace detail
{
typedef std::nullptr_t sp_nullptr_t;
}
}
#define BOOST_SMART_PTR_DETAIL_SPINLOCK_POOL_HPP_INCLUDED
#define BOOST_SMART_PTR_DETAIL_SPINLOCK_HPP_INCLUDED
#define BOOST_SMART_PTR_DETAIL_SPINLOCK_SYNC_HPP_INCLUDED
#define BOOST_SMART_PTR_DETAIL_YIELD_K_HPP_INCLUDED
#define BOOST_SMT_PAUSE __asm__ __volatile__( "rep; nop" : : : "memory" );
namespace boost
{
namespace detail
{
void yield( unsigned k )
;
}
}
namespace boost
{
namespace detail
{
class spinlock
{
public:
int v_;
public:
bool try_lock()
;
void lock()
;
void unlock()
;
public:
class scoped_lock
{
private:
spinlock & sp_;
scoped_lock( scoped_lock const & );
scoped_lock & operator=( scoped_lock const & );
public:
explicit scoped_lock( spinlock & sp )
;
~scoped_lock()
;
};
};
}
}
#define BOOST_DETAIL_SPINLOCK_INIT {0}
namespace boost
{
namespace detail
{
template< int I > class spinlock_pool
{
private:
static spinlock pool_[ 41 ];
public:
static spinlock & spinlock_for( void const * pv )
;
class scoped_lock
{
private:
spinlock & sp_;
scoped_lock( scoped_lock const & );
scoped_lock & operator=( scoped_lock const & );
public:
explicit scoped_lock( void const * pv )
;
~scoped_lock()
;
};
};
template< int I > spinlock spinlock_pool< I >::pool_[ 41 ] =
{
{0}, {0}, {0}, {0}, {0},
{0}, {0}, {0}, {0}, {0},
{0}, {0}, {0}, {0}, {0},
{0}, {0}, {0}, {0}, {0},
{0}, {0}, {0}, {0}, {0},
{0}, {0}, {0}, {0}, {0},
{0}, {0}, {0}, {0}, {0},
{0}, {0}, {0}, {0}, {0},
{0}
};
}
}
#define BOOST_MEMORY_ORDER_HPP_INCLUDED
namespace boost
{
enum memory_order
{
memory_order_relaxed = 0,
memory_order_acquire = 1,
memory_order_release = 2,
memory_order_acq_rel = 3,
memory_order_seq_cst = 7,
memory_order_consume = 8
};
}
#define _GLIBCXX_ALGORITHM 1
#define _STL_ALGO_H 1
#define _GLIBCXX_ALGORITHMFWD_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _IIter, typename _Predicate>
bool
all_of(_IIter, _IIter, _Predicate);
template<typename _IIter, typename _Predicate>
bool
any_of(_IIter, _IIter, _Predicate);
template<typename _FIter, typename _Tp>
bool
binary_search(_FIter, _FIter, const _Tp&);
template<typename _FIter, typename _Tp, typename _Compare>
bool
binary_search(_FIter, _FIter, const _Tp&, _Compare);
template<typename _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);
template<typename _FIter>
void
rotate(_FIter, _FIter, _FIter);
template<typename _FIter, typename _OIter>
_OIter
rotate_copy(_FIter, _FIter, _FIter, _OIter);
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);
template<typename _Tp>
void
swap(_Tp&, _Tp&)
noexcept(__and_<is_nothrow_move_constructible<_Tp>,
is_nothrow_move_assignable<_Tp>>::value)
;
template<typename _Tp, size_t _Nm>
void
swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
noexcept(noexcept(swap(*__a, *__b)))
;
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);
}
#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)
;
template<typename _RandomAccessIterator, typename _Distance>
bool
__is_heap(_RandomAccessIterator __first, _Distance __n)
;
template<typename _RandomAccessIterator, typename _Compare,
typename _Distance>
bool
__is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
;
template<typename _RandomAccessIterator>
bool
__is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
bool
__is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
typename _Compare>
void
__push_heap(_RandomAccessIterator __first,
_Distance __holeIndex, _Distance __topIndex, _Tp __value,
_Compare __comp)
;
template<typename _RandomAccessIterator>
void
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Distance,
typename _Tp, typename _Compare>
void
__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
_Distance __len, _Tp __value, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_RandomAccessIterator __result, _Compare __comp)
;
template<typename _RandomAccessIterator>
void
pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
pop_heap(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator>
void
make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator>
void
sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator>
_RandomAccessIterator
is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
_RandomAccessIterator
is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator>
bool
is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
bool
is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
}
#define _GLIBCXX_RANDOM 1
#define _MATH_H 1
extern "C" {
#define HUGE_VAL (__builtin_huge_val())
#define HUGE_VALF (__builtin_huge_valf())
#define HUGE_VALL (__builtin_huge_vall())
#define INFINITY (__builtin_inff())
#define NAN (__builtin_nanf (""))
#define _MATH_H_MATHDEF 1
typedef float float_t;
typedef double double_t;
#define FP_ILOGB0 (-2147483647 - 1)
#define FP_ILOGBNAN (-2147483647 - 1)
#define __MATHCALL(function,suffix,args) __MATHDECL (_Mdouble_,function,suffix, args)
#define __MATHDECL(type,function,suffix,args) __MATHDECL_1(type, function,suffix, args); __MATHDECL_1(type, __CONCAT(__,function),suffix, args)
#define __MATHCALLX(function,suffix,args,attrib) __MATHDECLX (_Mdouble_,function,suffix, args, attrib)
#define __MATHDECLX(type,function,suffix,args,attrib) __MATHDECL_1(type, function,suffix, args) __attribute__ (attrib); __MATHDECL_1(type, __CONCAT(__,function),suffix, args) __attribute__ (attrib)
#define __MATHDECL_1(type,function,suffix,args) extern type __MATH_PRECNAME(function,suffix) args __THROW
#define _Mdouble_ double
#define __MATH_PRECNAME(name,r) __CONCAT(name,r)
#define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_STD
#define _Mdouble_END_NAMESPACE __END_NAMESPACE_STD
extern double acos (double __x) throw (); extern double __acos (double __x) throw ();
extern double asin (double __x) throw (); extern double __asin (double __x) throw ();
extern double atan (double __x) throw (); extern double __atan (double __x) throw ();
extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();
extern double cos (double __x) throw (); extern double __cos (double __x) throw ();
extern double sin (double __x) throw (); extern double __sin (double __x) throw ();
extern double tan (double __x) throw (); extern double __tan (double __x) throw ();
extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();
extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();
extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();
extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ();
extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();
extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();
extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();
extern double exp (double __x) throw (); extern double __exp (double __x) throw ();
extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();
extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();
extern double log (double __x) throw (); extern double __log (double __x) throw ();
extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();
extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw () __attribute__ ((__nonnull__ (2)));
extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();
extern double pow10 (double __x) throw (); extern double __pow10 (double __x) throw ();
extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();
extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();
extern double logb (double __x) throw (); extern double __logb (double __x) throw ();
extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();
extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();
extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();
extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();
extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();
extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();
extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));
extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));
extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));
extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();
extern int __isinf (double __value) throw () __attribute__ ((__const__));
extern int __finite (double __value) throw () __attribute__ ((__const__));
extern int isinf (double __value) throw () __attribute__ ((__const__));
extern int finite (double __value) throw () __attribute__ ((__const__));
extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();
extern double significand (double __x) throw (); extern double __significand (double __x) throw ();
extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));
extern double nan (const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (const char *__tagb) throw () __attribute__ ((__const__));
extern int __isnan (double __value) throw () __attribute__ ((__const__));
extern int isnan (double __value) throw () __attribute__ ((__const__));
extern double j0 (double) throw (); extern double __j0 (double) throw ();
extern double j1 (double) throw (); extern double __j1 (double) throw ();
extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
extern double y0 (double) throw (); extern double __y0 (double) throw ();
extern double y1 (double) throw (); extern double __y1 (double) throw ();
extern double yn (int, double) throw (); extern double __yn (int, double) throw ();
extern double erf (double) throw (); extern double __erf (double) throw ();
extern double erfc (double) throw (); extern double __erfc (double) throw ();
extern double lgamma (double) throw (); extern double __lgamma (double) throw ();
extern double tgamma (double) throw (); extern double __tgamma (double) throw ();
extern double gamma (double) throw (); extern double __gamma (double) throw ();
extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();
extern double rint (double __x) throw (); extern double __rint (double __x) throw ();
extern double nextafter (double __x, double __y) throw () __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) throw () __attribute__ ((__const__));
extern double nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) throw () __attribute__ ((__const__));
extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();
extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();
extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();
extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();
extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();
extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));
extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));
extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();
extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
__extension__
extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();
extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
__extension__
extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();
extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();
extern double fmax (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmax (double __x, double __y) throw () __attribute__ ((__const__));
extern double fmin (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmin (double __x, double __y) throw () __attribute__ ((__const__));
extern int __fpclassify (double __value) throw ()
__attribute__ ((__const__));
extern int __signbit (double __value) throw ()
__attribute__ ((__const__));
extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();
extern int __issignaling (double __value) throw ()
__attribute__ ((__const__));
extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
#undef _Mdouble_
#undef _Mdouble_BEGIN_NAMESPACE
#undef _Mdouble_END_NAMESPACE
#undef __MATH_PRECNAME
#define _Mfloat_ float
#define _Mdouble_ _Mfloat_
#define __MATH_PRECNAME(name,r) name ##f ##r
#define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_C99
#define _Mdouble_END_NAMESPACE __END_NAMESPACE_C99
extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();
extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();
extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();
extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();
extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();
extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();
extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();
extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();
extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();
extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();
extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw ();
extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();
extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();
extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();
extern float expf (float __x) throw (); extern float __expf (float __x) throw ();
extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();
extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();
extern float logf (float __x) throw (); extern float __logf (float __x) throw ();
extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();
extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw () __attribute__ ((__nonnull__ (2)));
extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();
extern float pow10f (float __x) throw (); extern float __pow10f (float __x) throw ();
extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();
extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();
extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();
extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();
extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();
extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();
extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();
extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();
extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();
extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));
extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));
extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));
extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();
extern int __isinff (float __value) throw () __attribute__ ((__const__));
extern int __finitef (float __value) throw () __attribute__ ((__const__));
extern int isinff (float __value) throw () __attribute__ ((__const__));
extern int finitef (float __value) throw () __attribute__ ((__const__));
extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();
extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();
extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));
extern float nanf (const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (const char *__tagb) throw () __attribute__ ((__const__));
extern int __isnanf (float __value) throw () __attribute__ ((__const__));
extern int isnanf (float __value) throw () __attribute__ ((__const__));
extern float j0f (float) throw (); extern float __j0f (float) throw ();
extern float j1f (float) throw (); extern float __j1f (float) throw ();
extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
extern float y0f (float) throw (); extern float __y0f (float) throw ();
extern float y1f (float) throw (); extern float __y1f (float) throw ();
extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();
extern float erff (float) throw (); extern float __erff (float) throw ();
extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();
extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();
extern float gammaf (float) throw (); extern float __gammaf (float) throw ();
extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();
extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();
extern float nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) throw () __attribute__ ((__const__));
extern float nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__));
extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();
extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();
extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();
extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();
extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();
extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));
extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));
extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();
extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
__extension__
extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();
extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
__extension__
extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();
extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();
extern float fmaxf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) throw () __attribute__ ((__const__));
extern float fminf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminf (float __x, float __y) throw () __attribute__ ((__const__));
extern int __fpclassifyf (float __value) throw ()
__attribute__ ((__const__));
extern int __signbitf (float __value) throw ()
__attribute__ ((__const__));
extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();
extern int __issignalingf (float __value) throw ()
__attribute__ ((__const__));
extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
#undef _Mdouble_
#undef _Mdouble_BEGIN_NAMESPACE
#undef _Mdouble_END_NAMESPACE
#undef __MATH_PRECNAME
#define _Mlong_double_ long double
#define _Mdouble_ _Mlong_double_
#define __MATH_PRECNAME(name,r) name ##l ##r
#define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_C99
#define _Mdouble_END_NAMESPACE __END_NAMESPACE_C99
#define __MATH_DECLARE_LDOUBLE 1
extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();
extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();
extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();
extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();
extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();
extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();
extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();
extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();
extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();
extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();
extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw ();
extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();
extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();
extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();
extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();
extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();
extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();
extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();
extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();
extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw () __attribute__ ((__nonnull__ (2)));
extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();
extern long double pow10l (long double __x) throw (); extern long double __pow10l (long double __x) throw ();
extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();
extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();
extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();
extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();
extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();
extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();
extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();
extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();
extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();
extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));
extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));
extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));
extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();
extern int __isinfl (long double __value) throw () __attribute__ ((__const__));
extern int __finitel (long double __value) throw () __attribute__ ((__const__));
extern int isinfl (long double __value) throw () __attribute__ ((__const__));
extern int finitel (long double __value) throw () __attribute__ ((__const__));
extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();
extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();
extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern long double nanl (const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (const char *__tagb) throw () __attribute__ ((__const__));
extern int __isnanl (long double __value) throw () __attribute__ ((__const__));
extern int isnanl (long double __value) throw () __attribute__ ((__const__));
extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();
extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();
extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();
extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();
extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();
extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();
extern long double nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern long double nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();
extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();
extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();
extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();
extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();
extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));
extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));
extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();
extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
__extension__
extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();
extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
__extension__
extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();
extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();
extern long double fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern long double fminl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern int __fpclassifyl (long double __value) throw ()
__attribute__ ((__const__));
extern int __signbitl (long double __value) throw ()
__attribute__ ((__const__));
extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();
extern int __issignalingl (long double __value) throw ()
__attribute__ ((__const__));
extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
#undef _Mdouble_
#undef _Mdouble_BEGIN_NAMESPACE
#undef _Mdouble_END_NAMESPACE
#undef __MATH_PRECNAME
#undef __MATHDECL_1
#undef __MATHDECL
#undef __MATHCALL
extern int signgam;
enum
{
FP_NAN =
#define FP_NAN 0
0,
FP_INFINITE =
#define FP_INFINITE 1
1,
FP_ZERO =
#define FP_ZERO 2
2,
FP_SUBNORMAL =
#define FP_SUBNORMAL 3
3,
FP_NORMAL =
#define FP_NORMAL 4
4
};
#define fpclassify(x) (sizeof (x) == sizeof (float) ? __fpclassifyf (x) : sizeof (x) == sizeof (double) ? __fpclassify (x) : __fpclassifyl (x))
#define signbit(x) (sizeof (x) == sizeof (float) ? __signbitf (x) : sizeof (x) == sizeof (double) ? __signbit (x) : __signbitl (x))
#define isfinite(x) (sizeof (x) == sizeof (float) ? __finitef (x) : sizeof (x) == sizeof (double) ? __finite (x) : __finitel (x))
#define isnormal(x) (fpclassify (x) == FP_NORMAL)
#define isnan(x) (sizeof (x) == sizeof (float) ? __isnanf (x) : sizeof (x) == sizeof (double) ? __isnan (x) : __isnanl (x))
#define isinf(x) (sizeof (x) == sizeof (float) ? __isinff (x) : sizeof (x) == sizeof (double) ? __isinf (x) : __isinfl (x))
#define MATH_ERRNO 1
#define MATH_ERREXCEPT 2
#define math_errhandling (MATH_ERRNO | MATH_ERREXCEPT)
#define issignaling(x) (sizeof (x) == sizeof (float) ? __issignalingf (x) : sizeof (x) == sizeof (double) ? __issignaling (x) : __issignalingl (x))
typedef enum
{
_IEEE_ = -1,
_SVID_,
_XOPEN_,
_POSIX_,
_ISOC_
} _LIB_VERSION_TYPE;
extern _LIB_VERSION_TYPE _LIB_VERSION;
struct __exception
{
int type;
char *name;
double arg1;
double arg2;
double retval;
};
extern int matherr (struct __exception *__exc) throw ();
#define X_TLOSS 1.41484755040568800000e+16
#define DOMAIN 1
#define SING 2
#define OVERFLOW 3
#define UNDERFLOW 4
#define TLOSS 5
#define PLOSS 6
#define HUGE 3.40282347e+38F
#define M_E 2.7182818284590452354
#define M_LOG2E 1.4426950408889634074
#define M_LOG10E 0.43429448190325182765
#define M_LN2 0.69314718055994530942
#define M_LN10 2.30258509299404568402
#define M_PI 3.14159265358979323846
#define M_PI_2 1.57079632679489661923
#define M_PI_4 0.78539816339744830962
#define M_1_PI 0.31830988618379067154
#define M_2_PI 0.63661977236758134308
#define M_2_SQRTPI 1.12837916709551257390
#define M_SQRT2 1.41421356237309504880
#define M_SQRT1_2 0.70710678118654752440
#define M_El 2.718281828459045235360287471352662498L
#define M_LOG2El 1.442695040888963407359924681001892137L
#define M_LOG10El 0.434294481903251827651128918916605082L
#define M_LN2l 0.693147180559945309417232121458176568L
#define M_LN10l 2.302585092994045684017991454684364208L
#define M_PIl 3.141592653589793238462643383279502884L
#define M_PI_2l 1.570796326794896619231321691639751442L
#define M_PI_4l 0.785398163397448309615660845819875721L
#define M_1_PIl 0.318309886183790671537767526745028724L
#define M_2_PIl 0.636619772367581343075535053490057448L
#define M_2_SQRTPIl 1.128379167095512573896158903121545172L
#define M_SQRT2l 1.414213562373095048801688724209698079L
#define M_SQRT1_2l 0.707106781186547524400844362104849039L
#define __NO_MATH_INLINES 1
#define isgreater(x,y) __builtin_isgreater(x, y)
#define isgreaterequal(x,y) __builtin_isgreaterequal(x, y)
#define isless(x,y) __builtin_isless(x, y)
#define islessequal(x,y) __builtin_islessequal(x, y)
#define islessgreater(x,y) __builtin_islessgreater(x, y)
#define isunordered(u,v) __builtin_isunordered(u, v)
}
#define _GLIBCXX_CMATH 1
#undef abs
#undef div
#undef acos
#undef asin
#undef atan
#undef atan2
#undef ceil
#undef cos
#undef cosh
#undef exp
#undef fabs
#undef floor
#undef fmod
#undef frexp
#undef ldexp
#undef log
#undef log10
#undef modf
#undef pow
#undef sin
#undef sinh
#undef sqrt
#undef tan
#undef tanh
namespace std __attribute__ ((__visibility__ ("default")))
{
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); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
abs(_Tp __x)
{ return __builtin_fabs(__x); }
using ::acos;
inline constexpr float
acos(float __x)
{ return __builtin_acosf(__x); }
inline constexpr long double
acos(long double __x)
{ return __builtin_acosl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
acos(_Tp __x)
{ return __builtin_acos(__x); }
using ::asin;
inline constexpr float
asin(float __x)
{ return __builtin_asinf(__x); }
inline constexpr long double
asin(long double __x)
{ return __builtin_asinl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
asin(_Tp __x)
{ return __builtin_asin(__x); }
using ::atan;
inline constexpr float
atan(float __x)
{ return __builtin_atanf(__x); }
inline constexpr long double
atan(long double __x)
{ return __builtin_atanl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
atan(_Tp __x)
{ return __builtin_atan(__x); }
using ::atan2;
inline constexpr float
atan2(float __y, float __x)
{ return __builtin_atan2f(__y, __x); }
inline constexpr long double
atan2(long double __y, long double __x)
{ return __builtin_atan2l(__y, __x); }
template<typename _Tp, typename _Up>
inline constexpr
typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
atan2(_Tp __y, _Up __x)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return atan2(__type(__y), __type(__x));
}
using ::ceil;
inline constexpr float
ceil(float __x)
{ return __builtin_ceilf(__x); }
inline constexpr long double
ceil(long double __x)
{ return __builtin_ceill(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
ceil(_Tp __x)
{ return __builtin_ceil(__x); }
using ::cos;
inline constexpr float
cos(float __x)
{ return __builtin_cosf(__x); }
inline constexpr long double
cos(long double __x)
{ return __builtin_cosl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
cos(_Tp __x)
{ return __builtin_cos(__x); }
using ::cosh;
inline constexpr float
cosh(float __x)
{ return __builtin_coshf(__x); }
inline constexpr long double
cosh(long double __x)
{ return __builtin_coshl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
cosh(_Tp __x)
{ return __builtin_cosh(__x); }
using ::exp;
inline constexpr float
exp(float __x)
{ return __builtin_expf(__x); }
inline constexpr long double
exp(long double __x)
{ return __builtin_expl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
exp(_Tp __x)
{ return __builtin_exp(__x); }
using ::fabs;
inline constexpr float
fabs(float __x)
{ return __builtin_fabsf(__x); }
inline constexpr long double
fabs(long double __x)
{ return __builtin_fabsl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
fabs(_Tp __x)
{ return __builtin_fabs(__x); }
using ::floor;
inline constexpr float
floor(float __x)
{ return __builtin_floorf(__x); }
inline constexpr long double
floor(long double __x)
{ return __builtin_floorl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
floor(_Tp __x)
{ return __builtin_floor(__x); }
using ::fmod;
inline constexpr float
fmod(float __x, float __y)
{ return __builtin_fmodf(__x, __y); }
inline constexpr long double
fmod(long double __x, long double __y)
{ return __builtin_fmodl(__x, __y); }
template<typename _Tp, typename _Up>
inline constexpr
typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
fmod(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return fmod(__type(__x), __type(__y));
}
using ::frexp;
float
frexp(float __x, int* __exp)
;
long double
frexp(long double __x, int* __exp)
;
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
frexp(_Tp __x, int* __exp)
{ return __builtin_frexp(__x, __exp); }
using ::ldexp;
inline constexpr float
ldexp(float __x, int __exp)
{ return __builtin_ldexpf(__x, __exp); }
inline constexpr long double
ldexp(long double __x, int __exp)
{ return __builtin_ldexpl(__x, __exp); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
ldexp(_Tp __x, int __exp)
{ return __builtin_ldexp(__x, __exp); }
using ::log;
inline constexpr float
log(float __x)
{ return __builtin_logf(__x); }
inline constexpr long double
log(long double __x)
{ return __builtin_logl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log(_Tp __x)
{ return __builtin_log(__x); }
using ::log10;
inline constexpr float
log10(float __x)
{ return __builtin_log10f(__x); }
inline constexpr long double
log10(long double __x)
{ return __builtin_log10l(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log10(_Tp __x)
{ return __builtin_log10(__x); }
using ::modf;
float
modf(float __x, float* __iptr)
;
long double
modf(long double __x, long double* __iptr)
;
using ::pow;
inline constexpr float
pow(float __x, float __y)
{ return __builtin_powf(__x, __y); }
inline constexpr long double
pow(long double __x, long double __y)
{ return __builtin_powl(__x, __y); }
template<typename _Tp, typename _Up>
inline constexpr
typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
pow(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return pow(__type(__x), __type(__y));
}
using ::sin;
inline constexpr float
sin(float __x)
{ return __builtin_sinf(__x); }
inline constexpr long double
sin(long double __x)
{ return __builtin_sinl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
sin(_Tp __x)
{ return __builtin_sin(__x); }
using ::sinh;
inline constexpr float
sinh(float __x)
{ return __builtin_sinhf(__x); }
inline constexpr long double
sinh(long double __x)
{ return __builtin_sinhl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
sinh(_Tp __x)
{ return __builtin_sinh(__x); }
using ::sqrt;
inline constexpr float
sqrt(float __x)
{ return __builtin_sqrtf(__x); }
inline constexpr long double
sqrt(long double __x)
{ return __builtin_sqrtl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
sqrt(_Tp __x)
{ return __builtin_sqrt(__x); }
using ::tan;
inline constexpr float
tan(float __x)
{ return __builtin_tanf(__x); }
inline constexpr long double
tan(long double __x)
{ return __builtin_tanl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
tan(_Tp __x)
{ return __builtin_tan(__x); }
using ::tanh;
inline constexpr float
tanh(float __x)
{ return __builtin_tanhf(__x); }
inline constexpr long double
tanh(long double __x)
{ return __builtin_tanhl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
tanh(_Tp __x)
{ return __builtin_tanh(__x); }
}
#undef fpclassify
#undef isfinite
#undef isinf
#undef isnan
#undef isnormal
#undef signbit
#undef isgreater
#undef isgreaterequal
#undef isless
#undef islessequal
#undef islessgreater
#undef isunordered
namespace std __attribute__ ((__visibility__ ("default")))
{
constexpr int
fpclassify(float __x)
{ return __builtin_fpclassify(0, 1, 4,
3, 2, __x); }
constexpr int
fpclassify(double __x)
{ return __builtin_fpclassify(0, 1, 4,
3, 2, __x); }
constexpr int
fpclassify(long double __x)
{ return __builtin_fpclassify(0, 1, 4,
3, 2, __x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
int>::__type
fpclassify(_Tp __x)
{ return __x != 0 ? 4 : 2; }
constexpr bool
isfinite(float __x)
{ return __builtin_isfinite(__x); }
constexpr bool
isfinite(double __x)
{ return __builtin_isfinite(__x); }
constexpr bool
isfinite(long double __x)
{ return __builtin_isfinite(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
isfinite(_Tp __x)
{ return true; }
constexpr bool
isinf(float __x)
{ return __builtin_isinf(__x); }
constexpr bool
isinf(double __x)
{ return __builtin_isinf(__x); }
constexpr bool
isinf(long double __x)
{ return __builtin_isinf(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
isinf(_Tp __x)
{ return false; }
constexpr bool
isnan(float __x)
{ return __builtin_isnan(__x); }
constexpr bool
isnan(double __x)
{ return __builtin_isnan(__x); }
constexpr bool
isnan(long double __x)
{ return __builtin_isnan(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
isnan(_Tp __x)
{ return false; }
constexpr bool
isnormal(float __x)
{ return __builtin_isnormal(__x); }
constexpr bool
isnormal(double __x)
{ return __builtin_isnormal(__x); }
constexpr bool
isnormal(long double __x)
{ return __builtin_isnormal(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
isnormal(_Tp __x)
{ return __x != 0 ? true : false; }
constexpr bool
signbit(float __x)
{ return __builtin_signbitf(__x); }
constexpr bool
signbit(double __x)
{ return __builtin_signbit(__x); }
constexpr bool
signbit(long double __x)
{ return __builtin_signbitl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
signbit(_Tp __x)
{ return __x < 0 ? true : false; }
constexpr bool
isgreater(float __x, float __y)
{ return __builtin_isgreater(__x, __y); }
constexpr bool
isgreater(double __x, double __y)
{ return __builtin_isgreater(__x, __y); }
constexpr bool
isgreater(long double __x, long double __y)
{ return __builtin_isgreater(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
isgreater(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_isgreater(__type(__x), __type(__y));
}
constexpr bool
isgreaterequal(float __x, float __y)
{ return __builtin_isgreaterequal(__x, __y); }
constexpr bool
isgreaterequal(double __x, double __y)
{ return __builtin_isgreaterequal(__x, __y); }
constexpr bool
isgreaterequal(long double __x, long double __y)
{ return __builtin_isgreaterequal(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
isgreaterequal(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_isgreaterequal(__type(__x), __type(__y));
}
constexpr bool
isless(float __x, float __y)
{ return __builtin_isless(__x, __y); }
constexpr bool
isless(double __x, double __y)
{ return __builtin_isless(__x, __y); }
constexpr bool
isless(long double __x, long double __y)
{ return __builtin_isless(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
isless(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_isless(__type(__x), __type(__y));
}
constexpr bool
islessequal(float __x, float __y)
{ return __builtin_islessequal(__x, __y); }
constexpr bool
islessequal(double __x, double __y)
{ return __builtin_islessequal(__x, __y); }
constexpr bool
islessequal(long double __x, long double __y)
{ return __builtin_islessequal(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
islessequal(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_islessequal(__type(__x), __type(__y));
}
constexpr bool
islessgreater(float __x, float __y)
{ return __builtin_islessgreater(__x, __y); }
constexpr bool
islessgreater(double __x, double __y)
{ return __builtin_islessgreater(__x, __y); }
constexpr bool
islessgreater(long double __x, long double __y)
{ return __builtin_islessgreater(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
islessgreater(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_islessgreater(__type(__x), __type(__y));
}
constexpr bool
isunordered(float __x, float __y)
{ return __builtin_isunordered(__x, __y); }
constexpr bool
isunordered(double __x, double __y)
{ return __builtin_isunordered(__x, __y); }
constexpr bool
isunordered(long double __x, long double __y)
{ return __builtin_isunordered(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
isunordered(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_isunordered(__type(__x), __type(__y));
}
}
#undef acosh
#undef acoshf
#undef acoshl
#undef asinh
#undef asinhf
#undef asinhl
#undef atanh
#undef atanhf
#undef atanhl
#undef cbrt
#undef cbrtf
#undef cbrtl
#undef copysign
#undef copysignf
#undef copysignl
#undef erf
#undef erff
#undef erfl
#undef erfc
#undef erfcf
#undef erfcl
#undef exp2
#undef exp2f
#undef exp2l
#undef expm1
#undef expm1f
#undef expm1l
#undef fdim
#undef fdimf
#undef fdiml
#undef fma
#undef fmaf
#undef fmal
#undef fmax
#undef fmaxf
#undef fmaxl
#undef fmin
#undef fminf
#undef fminl
#undef hypot
#undef hypotf
#undef hypotl
#undef ilogb
#undef ilogbf
#undef ilogbl
#undef lgamma
#undef lgammaf
#undef lgammal
#undef llrint
#undef llrintf
#undef llrintl
#undef llround
#undef llroundf
#undef llroundl
#undef log1p
#undef log1pf
#undef log1pl
#undef log2
#undef log2f
#undef log2l
#undef logb
#undef logbf
#undef logbl
#undef lrint
#undef lrintf
#undef lrintl
#undef lround
#undef lroundf
#undef lroundl
#undef nan
#undef nanf
#undef nanl
#undef nearbyint
#undef nearbyintf
#undef nearbyintl
#undef nextafter
#undef nextafterf
#undef nextafterl
#undef nexttoward
#undef nexttowardf
#undef nexttowardl
#undef remainder
#undef remainderf
#undef remainderl
#undef remquo
#undef remquof
#undef remquol
#undef rint
#undef rintf
#undef rintl
#undef round
#undef roundf
#undef roundl
#undef scalbln
#undef scalblnf
#undef scalblnl
#undef scalbn
#undef scalbnf
#undef scalbnl
#undef tgamma
#undef tgammaf
#undef tgammal
#undef trunc
#undef truncf
#undef truncl
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::double_t;
using ::float_t;
using ::acosh;
using ::acoshf;
using ::acoshl;
using ::asinh;
using ::asinhf;
using ::asinhl;
using ::atanh;
using ::atanhf;
using ::atanhl;
using ::cbrt;
using ::cbrtf;
using ::cbrtl;
using ::copysign;
using ::copysignf;
using ::copysignl;
using ::erf;
using ::erff;
using ::erfl;
using ::erfc;
using ::erfcf;
using ::erfcl;
using ::exp2;
using ::exp2f;
using ::exp2l;
using ::expm1;
using ::expm1f;
using ::expm1l;
using ::fdim;
using ::fdimf;
using ::fdiml;
using ::fma;
using ::fmaf;
using ::fmal;
using ::fmax;
using ::fmaxf;
using ::fmaxl;
using ::fmin;
using ::fminf;
using ::fminl;
using ::hypot;
using ::hypotf;
using ::hypotl;
using ::ilogb;
using ::ilogbf;
using ::ilogbl;
using ::lgamma;
using ::lgammaf;
using ::lgammal;
using ::llrint;
using ::llrintf;
using ::llrintl;
using ::llround;
using ::llroundf;
using ::llroundl;
using ::log1p;
using ::log1pf;
using ::log1pl;
using ::log2;
using ::log2f;
using ::log2l;
using ::logb;
using ::logbf;
using ::logbl;
using ::lrint;
using ::lrintf;
using ::lrintl;
using ::lround;
using ::lroundf;
using ::lroundl;
using ::nan;
using ::nanf;
using ::nanl;
using ::nearbyint;
using ::nearbyintf;
using ::nearbyintl;
using ::nextafter;
using ::nextafterf;
using ::nextafterl;
using ::nexttoward;
using ::nexttowardf;
using ::nexttowardl;
using ::remainder;
using ::remainderf;
using ::remainderl;
using ::remquo;
using ::remquof;
using ::remquol;
using ::rint;
using ::rintf;
using ::rintl;
using ::round;
using ::roundf;
using ::roundl;
using ::scalbln;
using ::scalblnf;
using ::scalblnl;
using ::scalbn;
using ::scalbnf;
using ::scalbnl;
using ::tgamma;
using ::tgammaf;
using ::tgammal;
using ::trunc;
using ::truncf;
using ::truncl;
constexpr float
acosh(float __x)
{ return __builtin_acoshf(__x); }
constexpr long double
acosh(long double __x)
{ return __builtin_acoshl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
acosh(_Tp __x)
{ return __builtin_acosh(__x); }
constexpr float
asinh(float __x)
{ return __builtin_asinhf(__x); }
constexpr long double
asinh(long double __x)
{ return __builtin_asinhl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
asinh(_Tp __x)
{ return __builtin_asinh(__x); }
constexpr float
atanh(float __x)
{ return __builtin_atanhf(__x); }
constexpr long double
atanh(long double __x)
{ return __builtin_atanhl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
atanh(_Tp __x)
{ return __builtin_atanh(__x); }
constexpr float
cbrt(float __x)
{ return __builtin_cbrtf(__x); }
constexpr long double
cbrt(long double __x)
{ return __builtin_cbrtl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
cbrt(_Tp __x)
{ return __builtin_cbrt(__x); }
constexpr float
copysign(float __x, float __y)
{ return __builtin_copysignf(__x, __y); }
constexpr long double
copysign(long double __x, long double __y)
{ return __builtin_copysignl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
copysign(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return copysign(__type(__x), __type(__y));
}
constexpr float
erf(float __x)
{ return __builtin_erff(__x); }
constexpr long double
erf(long double __x)
{ return __builtin_erfl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
erf(_Tp __x)
{ return __builtin_erf(__x); }
constexpr float
erfc(float __x)
{ return __builtin_erfcf(__x); }
constexpr long double
erfc(long double __x)
{ return __builtin_erfcl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
erfc(_Tp __x)
{ return __builtin_erfc(__x); }
constexpr float
exp2(float __x)
{ return __builtin_exp2f(__x); }
constexpr long double
exp2(long double __x)
{ return __builtin_exp2l(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
exp2(_Tp __x)
{ return __builtin_exp2(__x); }
constexpr float
expm1(float __x)
{ return __builtin_expm1f(__x); }
constexpr long double
expm1(long double __x)
{ return __builtin_expm1l(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
expm1(_Tp __x)
{ return __builtin_expm1(__x); }
constexpr float
fdim(float __x, float __y)
{ return __builtin_fdimf(__x, __y); }
constexpr long double
fdim(long double __x, long double __y)
{ return __builtin_fdiml(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
fdim(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return fdim(__type(__x), __type(__y));
}
constexpr float
fma(float __x, float __y, float __z)
{ return __builtin_fmaf(__x, __y, __z); }
constexpr long double
fma(long double __x, long double __y, long double __z)
{ return __builtin_fmal(__x, __y, __z); }
template<typename _Tp, typename _Up, typename _Vp>
constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
fma(_Tp __x, _Up __y, _Vp __z)
{
typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
return fma(__type(__x), __type(__y), __type(__z));
}
constexpr float
fmax(float __x, float __y)
{ return __builtin_fmaxf(__x, __y); }
constexpr long double
fmax(long double __x, long double __y)
{ return __builtin_fmaxl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
fmax(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return fmax(__type(__x), __type(__y));
}
constexpr float
fmin(float __x, float __y)
{ return __builtin_fminf(__x, __y); }
constexpr long double
fmin(long double __x, long double __y)
{ return __builtin_fminl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
fmin(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return fmin(__type(__x), __type(__y));
}
constexpr float
hypot(float __x, float __y)
{ return __builtin_hypotf(__x, __y); }
constexpr long double
hypot(long double __x, long double __y)
{ return __builtin_hypotl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
hypot(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return hypot(__type(__x), __type(__y));
}
constexpr int
ilogb(float __x)
{ return __builtin_ilogbf(__x); }
constexpr int
ilogb(long double __x)
{ return __builtin_ilogbl(__x); }
template<typename _Tp>
constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
int>::__type
ilogb(_Tp __x)
{ return __builtin_ilogb(__x); }
constexpr float
lgamma(float __x)
{ return __builtin_lgammaf(__x); }
constexpr long double
lgamma(long double __x)
{ return __builtin_lgammal(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
lgamma(_Tp __x)
{ return __builtin_lgamma(__x); }
constexpr long long
llrint(float __x)
{ return __builtin_llrintf(__x); }
constexpr long long
llrint(long double __x)
{ return __builtin_llrintl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
long long>::__type
llrint(_Tp __x)
{ return __builtin_llrint(__x); }
constexpr long long
llround(float __x)
{ return __builtin_llroundf(__x); }
constexpr long long
llround(long double __x)
{ return __builtin_llroundl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
long long>::__type
llround(_Tp __x)
{ return __builtin_llround(__x); }
constexpr float
log1p(float __x)
{ return __builtin_log1pf(__x); }
constexpr long double
log1p(long double __x)
{ return __builtin_log1pl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log1p(_Tp __x)
{ return __builtin_log1p(__x); }
constexpr float
log2(float __x)
{ return __builtin_log2f(__x); }
constexpr long double
log2(long double __x)
{ return __builtin_log2l(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log2(_Tp __x)
{ return __builtin_log2(__x); }
constexpr float
logb(float __x)
{ return __builtin_logbf(__x); }
constexpr long double
logb(long double __x)
{ return __builtin_logbl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
logb(_Tp __x)
{ return __builtin_logb(__x); }
constexpr long
lrint(float __x)
{ return __builtin_lrintf(__x); }
constexpr long
lrint(long double __x)
{ return __builtin_lrintl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
long>::__type
lrint(_Tp __x)
{ return __builtin_lrint(__x); }
constexpr long
lround(float __x)
{ return __builtin_lroundf(__x); }
constexpr long
lround(long double __x)
{ return __builtin_lroundl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
long>::__type
lround(_Tp __x)
{ return __builtin_lround(__x); }
constexpr float
nearbyint(float __x)
{ return __builtin_nearbyintf(__x); }
constexpr long double
nearbyint(long double __x)
{ return __builtin_nearbyintl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
nearbyint(_Tp __x)
{ return __builtin_nearbyint(__x); }
constexpr float
nextafter(float __x, float __y)
{ return __builtin_nextafterf(__x, __y); }
constexpr long double
nextafter(long double __x, long double __y)
{ return __builtin_nextafterl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
nextafter(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return nextafter(__type(__x), __type(__y));
}
constexpr float
nexttoward(float __x, long double __y)
{ return __builtin_nexttowardf(__x, __y); }
constexpr long double
nexttoward(long double __x, long double __y)
{ return __builtin_nexttowardl(__x, __y); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
nexttoward(_Tp __x, long double __y)
{ return __builtin_nexttoward(__x, __y); }
constexpr float
remainder(float __x, float __y)
{ return __builtin_remainderf(__x, __y); }
constexpr long double
remainder(long double __x, long double __y)
{ return __builtin_remainderl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
remainder(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return remainder(__type(__x), __type(__y));
}
inline float
remquo(float __x, float __y, int* __pquo)
{ return __builtin_remquof(__x, __y, __pquo); }
inline long double
remquo(long double __x, long double __y, int* __pquo)
{ return __builtin_remquol(__x, __y, __pquo); }
template<typename _Tp, typename _Up>
inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
remquo(_Tp __x, _Up __y, int* __pquo)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return remquo(__type(__x), __type(__y), __pquo);
}
constexpr float
rint(float __x)
{ return __builtin_rintf(__x); }
constexpr long double
rint(long double __x)
{ return __builtin_rintl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
rint(_Tp __x)
{ return __builtin_rint(__x); }
constexpr float
round(float __x)
{ return __builtin_roundf(__x); }
constexpr long double
round(long double __x)
{ return __builtin_roundl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
round(_Tp __x)
{ return __builtin_round(__x); }
constexpr float
scalbln(float __x, long __ex)
{ return __builtin_scalblnf(__x, __ex); }
constexpr long double
scalbln(long double __x, long __ex)
{ return __builtin_scalblnl(__x, __ex); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
scalbln(_Tp __x, long __ex)
{ return __builtin_scalbln(__x, __ex); }
constexpr float
scalbn(float __x, int __ex)
{ return __builtin_scalbnf(__x, __ex); }
constexpr long double
scalbn(long double __x, int __ex)
{ return __builtin_scalbnl(__x, __ex); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
scalbn(_Tp __x, int __ex)
{ return __builtin_scalbn(__x, __ex); }
constexpr float
tgamma(float __x)
{ return __builtin_tgammaf(__x); }
constexpr long double
tgamma(long double __x)
{ return __builtin_tgammal(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
tgamma(_Tp __x)
{ return __builtin_tgamma(__x); }
constexpr float
trunc(float __x)
{ return __builtin_truncf(__x); }
constexpr long double
trunc(long double __x)
{ return __builtin_truncl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
trunc(_Tp __x)
{ return __builtin_trunc(__x); }
}
#define _RANDOM_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _RealType, size_t __bits,
typename _UniformRandomNumberGenerator>
_RealType
generate_canonical(_UniformRandomNumberGenerator& __g);
namespace __detail
{
template<typename _UIntType, size_t __w,
bool = __w < static_cast<size_t>
(std::numeric_limits<_UIntType>::digits)>
struct _Shift
{ static const _UIntType __value = 0; };
template<typename _UIntType, size_t __w>
struct _Shift<_UIntType, __w, true>
{ static const _UIntType __value = _UIntType(1) << __w; };
template<int __s,
int __which = ((__s <= 8 * sizeof (int))
+ (__s <= 8 * sizeof (long))
+ (__s <= 8 * sizeof (long long))
+ (__s <= 128))>
struct _Select_uint_least_t
{
static_assert(__which < 0,
"sorry, would be too much trouble for a slow result");
};
template<int __s>
struct _Select_uint_least_t<__s, 4>
{ typedef unsigned int type; };
template<int __s>
struct _Select_uint_least_t<__s, 3>
{ typedef unsigned long type; };
template<int __s>
struct _Select_uint_least_t<__s, 2>
{ typedef unsigned long long type; };
template<int __s>
struct _Select_uint_least_t<__s, 1>
{ typedef unsigned __int128 type; };
template<typename _Tp, _Tp __m, _Tp __a, _Tp __c,
bool __big_enough = (!(__m & (__m - 1))
|| (_Tp(-1) - __c) / __a >= __m - 1),
bool __schrage_ok = __m % __a < __m / __a>
struct _Mod
{
typedef typename _Select_uint_least_t<std::__lg(__a)
+ std::__lg(__m) + 2>::type _Tp2;
static _Tp
__calc(_Tp __x)
;
};
template<typename _Tp, _Tp __m, _Tp __a, _Tp __c>
struct _Mod<_Tp, __m, __a, __c, false, true>
{
static _Tp
__calc(_Tp __x);
};
template<typename _Tp, _Tp __m, _Tp __a, _Tp __c, bool __s>
struct _Mod<_Tp, __m, __a, __c, true, __s>
{
static _Tp
__calc(_Tp __x)
;
};
template<typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0>
_Tp
__mod(_Tp __x)
;
template<typename _Tp>
bool
_Power_of_2(_Tp __x)
;;
template<typename _Engine, typename _DInputType>
struct _Adaptor
{
static_assert(std::is_floating_point<_DInputType>::value,
"template argument not a floating point type");
public:
_Adaptor(_Engine& __g) ;
_DInputType
min() const
;
_DInputType
max() const
;
_DInputType
operator()()
;
private:
_Engine& _M_g;
};
}
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
class linear_congruential_engine
{
static_assert(std::is_unsigned<_UIntType>::value, "template argument "
"substituting _UIntType not an unsigned integral type");
static_assert(__m == 0u || (__a < __m && __c < __m),
"template argument substituting __m out of bounds");
public:
typedef _UIntType result_type;
static constexpr result_type multiplier = __a;
static constexpr result_type increment = __c;
static constexpr result_type modulus = __m;
static constexpr result_type default_seed = 1u;
explicit
linear_congruential_engine(result_type __s = default_seed)
;
template<typename _Sseq, typename = typename
std::enable_if<!std::is_same<_Sseq, linear_congruential_engine>::value>
::type>
explicit
linear_congruential_engine(_Sseq& __q)
;
void
seed(result_type __s = default_seed);
template<typename _Sseq>
typename std::enable_if<std::is_class<_Sseq>::value>::type
seed(_Sseq& __q);
static constexpr result_type
min()
{ return __c == 0u ? 1u : 0u; }
static constexpr result_type
max()
{ return __m - 1u; }
void
discard(unsigned long long __z)
{
for (; __z != 0ULL; --__z)
(*this)();
}
result_type
operator()()
{
_M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x);
return _M_x;
}
friend bool
operator==(const linear_congruential_engine& __lhs,
const linear_congruential_engine& __rhs)
{ return __lhs._M_x == __rhs._M_x; }
template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
_UIntType1 __m1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::linear_congruential_engine<_UIntType1,
__a1, __c1, __m1>& __lcr);
template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
_UIntType1 __m1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::linear_congruential_engine<_UIntType1, __a1,
__c1, __m1>& __lcr);
private:
_UIntType _M_x;
};
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
bool
operator!=(const std::linear_congruential_engine<_UIntType, __a,
__c, __m>& __lhs,
const std::linear_congruential_engine<_UIntType, __a,
__c, __m>& __rhs)
;
template<typename _UIntType, size_t __w,
size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t,
_UIntType __c, size_t __l, _UIntType __f>
class mersenne_twister_engine
{
static_assert(std::is_unsigned<_UIntType>::value, "template argument "
"substituting _UIntType not an unsigned integral type");
static_assert(1u <= __m && __m <= __n,
"template argument substituting __m out of bounds");
static_assert(__r <= __w, "template argument substituting "
"__r out of bound");
static_assert(__u <= __w, "template argument substituting "
"__u out of bound");
static_assert(__s <= __w, "template argument substituting "
"__s out of bound");
static_assert(__t <= __w, "template argument substituting "
"__t out of bound");
static_assert(__l <= __w, "template argument substituting "
"__l out of bound");
static_assert(__w <= std::numeric_limits<_UIntType>::digits,
"template argument substituting __w out of bound");
static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1),
"template argument substituting __a out of bound");
static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1),
"template argument substituting __b out of bound");
static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1),
"template argument substituting __c out of bound");
static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1),
"template argument substituting __d out of bound");
static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1),
"template argument substituting __f out of bound");
public:
typedef _UIntType result_type;
static constexpr size_t word_size = __w;
static constexpr size_t state_size = __n;
static constexpr size_t shift_size = __m;
static constexpr size_t mask_bits = __r;
static constexpr result_type xor_mask = __a;
static constexpr size_t tempering_u = __u;
static constexpr result_type tempering_d = __d;
static constexpr size_t tempering_s = __s;
static constexpr result_type tempering_b = __b;
static constexpr size_t tempering_t = __t;
static constexpr result_type tempering_c = __c;
static constexpr size_t tempering_l = __l;
static constexpr result_type initialization_multiplier = __f;
static constexpr result_type default_seed = 5489u;
explicit
mersenne_twister_engine(result_type __sd = default_seed)
;
template<typename _Sseq, typename = typename
std::enable_if<!std::is_same<_Sseq, mersenne_twister_engine>::value>
::type>
explicit
mersenne_twister_engine(_Sseq& __q)
;
void
seed(result_type __sd = default_seed);
template<typename _Sseq>
typename std::enable_if<std::is_class<_Sseq>::value>::type
seed(_Sseq& __q);
static constexpr result_type
min()
{ return 0; };
static constexpr result_type
max()
{ return __detail::_Shift<_UIntType, __w>::__value - 1; }
void
discard(unsigned long long __z);
result_type
operator()();
friend bool
operator==(const mersenne_twister_engine& __lhs,
const mersenne_twister_engine& __rhs)
;
template<typename _UIntType1,
size_t __w1, size_t __n1,
size_t __m1, size_t __r1,
_UIntType1 __a1, size_t __u1,
_UIntType1 __d1, size_t __s1,
_UIntType1 __b1, size_t __t1,
_UIntType1 __c1, size_t __l1, _UIntType1 __f1,
typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::mersenne_twister_engine<_UIntType1, __w1, __n1,
__m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
__l1, __f1>& __x);
template<typename _UIntType1,
size_t __w1, size_t __n1,
size_t __m1, size_t __r1,
_UIntType1 __a1, size_t __u1,
_UIntType1 __d1, size_t __s1,
_UIntType1 __b1, size_t __t1,
_UIntType1 __c1, size_t __l1, _UIntType1 __f1,
typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::mersenne_twister_engine<_UIntType1, __w1, __n1, __m1,
__r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
__l1, __f1>& __x);
private:
void _M_gen_rand();
_UIntType _M_x[state_size];
size_t _M_p;
};
template<typename _UIntType, size_t __w,
size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t,
_UIntType __c, size_t __l, _UIntType __f>
bool
operator!=(const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
__r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs,
const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
__r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs)
;
template<typename _UIntType, size_t __w, size_t __s, size_t __r>
class subtract_with_carry_engine
{
static_assert(std::is_unsigned<_UIntType>::value, "template argument "
"substituting _UIntType not an unsigned integral type");
static_assert(0u < __s && __s < __r,
"template argument substituting __s out of bounds");
static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
"template argument substituting __w out of bounds");
public:
typedef _UIntType result_type;
static constexpr size_t word_size = __w;
static constexpr size_t short_lag = __s;
static constexpr size_t long_lag = __r;
static constexpr result_type default_seed = 19780503u;
explicit
subtract_with_carry_engine(result_type __sd = default_seed)
;
template<typename _Sseq, typename = typename
std::enable_if<!std::is_same<_Sseq, subtract_with_carry_engine>::value>
::type>
explicit
subtract_with_carry_engine(_Sseq& __q)
;
void
seed(result_type __sd = default_seed);
template<typename _Sseq>
typename std::enable_if<std::is_class<_Sseq>::value>::type
seed(_Sseq& __q);
static constexpr result_type
min()
{ return 0; }
static constexpr result_type
max()
{ return __detail::_Shift<_UIntType, __w>::__value - 1; }
void
discard(unsigned long long __z)
{
for (; __z != 0ULL; --__z)
(*this)();
}
result_type
operator()();
friend bool
operator==(const subtract_with_carry_engine& __lhs,
const subtract_with_carry_engine& __rhs)
;
template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::subtract_with_carry_engine<_UIntType1, __w1,
__s1, __r1>& __x);
template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::subtract_with_carry_engine<_UIntType1, __w1,
__s1, __r1>& __x);
private:
_UIntType _M_x[long_lag];
_UIntType _M_carry;
size_t _M_p;
};
template<typename _UIntType, size_t __w, size_t __s, size_t __r>
bool
operator!=(const std::subtract_with_carry_engine<_UIntType, __w,
__s, __r>& __lhs,
const std::subtract_with_carry_engine<_UIntType, __w,
__s, __r>& __rhs)
;
template<typename _RandomNumberEngine, size_t __p, size_t __r>
class discard_block_engine
{
static_assert(1 <= __r && __r <= __p,
"template argument substituting __r out of bounds");
public:
typedef typename _RandomNumberEngine::result_type result_type;
static constexpr size_t block_size = __p;
static constexpr size_t used_block = __r;
discard_block_engine()
: _M_b(), _M_n(0) { }
explicit
discard_block_engine(const _RandomNumberEngine& __rng)
: _M_b(__rng), _M_n(0) { }
explicit
discard_block_engine(_RandomNumberEngine&& __rng)
: _M_b(std::move(__rng)), _M_n(0) { }
explicit
discard_block_engine(result_type __s)
: _M_b(__s), _M_n(0) { }
template<typename _Sseq, typename = typename
std::enable_if<!std::is_same<_Sseq, discard_block_engine>::value
&& !std::is_same<_Sseq, _RandomNumberEngine>::value>
::type>
explicit
discard_block_engine(_Sseq& __q)
: _M_b(__q), _M_n(0)
{ }
void
seed()
;
void
seed(result_type __s)
;
template<typename _Sseq>
void
seed(_Sseq& __q)
;
const _RandomNumberEngine&
base() const noexcept
{ return _M_b; }
static constexpr result_type
min()
{ return _RandomNumberEngine::min(); }
static constexpr result_type
max()
{ return _RandomNumberEngine::max(); }
void
discard(unsigned long long __z)
{
for (; __z != 0ULL; --__z)
(*this)();
}
result_type
operator()();
friend bool
operator==(const discard_block_engine& __lhs,
const discard_block_engine& __rhs)
;
template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::discard_block_engine<_RandomNumberEngine1,
__p1, __r1>& __x);
template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::discard_block_engine<_RandomNumberEngine1,
__p1, __r1>& __x);
private:
_RandomNumberEngine _M_b;
size_t _M_n;
};
template<typename _RandomNumberEngine, size_t __p, size_t __r>
bool
operator!=(const std::discard_block_engine<_RandomNumberEngine, __p,
__r>& __lhs,
const std::discard_block_engine<_RandomNumberEngine, __p,
__r>& __rhs)
;
template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
class independent_bits_engine
{
static_assert(std::is_unsigned<_UIntType>::value, "template argument "
"substituting _UIntType not an unsigned integral type");
static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
"template argument substituting __w out of bounds");
public:
typedef _UIntType result_type;
independent_bits_engine() ;
explicit
independent_bits_engine(const _RandomNumberEngine& __rng) ;
explicit
independent_bits_engine(_RandomNumberEngine&& __rng) ;
explicit
independent_bits_engine(result_type __s) ;
template<typename _Sseq, typename = typename
std::enable_if<!std::is_same<_Sseq, independent_bits_engine>::value
&& !std::is_same<_Sseq, _RandomNumberEngine>::value>
::type>
explicit
independent_bits_engine(_Sseq& __q)
;
void
seed()
;
void
seed(result_type __s)
;
template<typename _Sseq>
void
seed(_Sseq& __q)
;
const _RandomNumberEngine&
base() const noexcept
{ return _M_b; }
static constexpr result_type
min()
{ return 0U; }
static constexpr result_type
max()
{ return __detail::_Shift<_UIntType, __w>::__value - 1; }
void
discard(unsigned long long __z)
{
for (; __z != 0ULL; --__z)
(*this)();
}
result_type
operator()();
friend bool
operator==(const independent_bits_engine& __lhs,
const independent_bits_engine& __rhs)
;
template<typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::independent_bits_engine<_RandomNumberEngine,
__w, _UIntType>& __x)
;
private:
_RandomNumberEngine _M_b;
};
template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
bool
operator!=(const std::independent_bits_engine<_RandomNumberEngine, __w,
_UIntType>& __lhs,
const std::independent_bits_engine<_RandomNumberEngine, __w,
_UIntType>& __rhs)
;
template<typename _RandomNumberEngine, size_t __w, typename _UIntType,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::independent_bits_engine<_RandomNumberEngine,
__w, _UIntType>& __x)
;
template<typename _RandomNumberEngine, size_t __k>
class shuffle_order_engine
{
static_assert(1u <= __k, "template argument substituting "
"__k out of bound");
public:
typedef typename _RandomNumberEngine::result_type result_type;
static constexpr size_t table_size = __k;
shuffle_order_engine()
;
explicit
shuffle_order_engine(const _RandomNumberEngine& __rng)
;
explicit
shuffle_order_engine(_RandomNumberEngine&& __rng)
;
explicit
shuffle_order_engine(result_type __s)
;
template<typename _Sseq, typename = typename
std::enable_if<!std::is_same<_Sseq, shuffle_order_engine>::value
&& !std::is_same<_Sseq, _RandomNumberEngine>::value>
::type>
explicit
shuffle_order_engine(_Sseq& __q)
;
void
seed()
;
void
seed(result_type __s)
;
template<typename _Sseq>
void
seed(_Sseq& __q)
;
const _RandomNumberEngine&
base() const noexcept
{ return _M_b; }
static constexpr result_type
min()
{ return _RandomNumberEngine::min(); }
static constexpr result_type
max()
{ return _RandomNumberEngine::max(); }
void
discard(unsigned long long __z)
{
for (; __z != 0ULL; --__z)
(*this)();
}
result_type
operator()();
friend bool
operator==(const shuffle_order_engine& __lhs,
const shuffle_order_engine& __rhs)
;
template<typename _RandomNumberEngine1, size_t __k1,
typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::shuffle_order_engine<_RandomNumberEngine1,
__k1>& __x);
template<typename _RandomNumberEngine1, size_t __k1,
typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::shuffle_order_engine<_RandomNumberEngine1, __k1>& __x);
private:
void _M_initialize()
;
_RandomNumberEngine _M_b;
result_type _M_v[__k];
result_type _M_y;
};
template<typename _RandomNumberEngine, size_t __k>
bool
operator!=(const std::shuffle_order_engine<_RandomNumberEngine,
__k>& __lhs,
const std::shuffle_order_engine<_RandomNumberEngine,
__k>& __rhs)
;
typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
minstd_rand0;
typedef linear_congruential_engine<uint_fast32_t, 48271UL, 0UL, 2147483647UL>
minstd_rand;
typedef mersenne_twister_engine<
uint_fast32_t,
32, 624, 397, 31,
0x9908b0dfUL, 11,
0xffffffffUL, 7,
0x9d2c5680UL, 15,
0xefc60000UL, 18, 1812433253UL> mt19937;
typedef mersenne_twister_engine<
uint_fast64_t,
64, 312, 156, 31,
0xb5026f5aa96619e9ULL, 29,
0x5555555555555555ULL, 17,
0x71d67fffeda60000ULL, 37,
0xfff7eee000000000ULL, 43,
6364136223846793005ULL> mt19937_64;
typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>
ranlux24_base;
typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>
ranlux48_base;
typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
typedef minstd_rand0 default_random_engine;
class random_device
{
public:
typedef unsigned int result_type;
explicit
random_device(const std::string& __token = "default")
;
~random_device()
;
static constexpr result_type
min()
{ return std::numeric_limits<result_type>::min(); }
static constexpr result_type
max()
{ return std::numeric_limits<result_type>::max(); }
double
entropy() const noexcept
{ return 0.0; }
result_type
operator()()
{
return this->_M_getval();
}
random_device(const random_device&) = delete;
void operator=(const random_device&) = delete;
private:
void _M_init(const std::string& __token);
void _M_init_pretr1(const std::string& __token);
void _M_fini();
result_type _M_getval();
result_type _M_getval_pretr1();
union
{
void* _M_file;
mt19937 _M_mt;
};
};
template<typename _IntType = int>
class uniform_int_distribution
{
static_assert(std::is_integral<_IntType>::value,
"template argument not 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())
;
result_type
a() const
;
result_type
b() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_IntType _M_a;
_IntType _M_b;
};
public:
explicit
uniform_int_distribution(_IntType __a = 0,
_IntType __b = std::numeric_limits<_IntType>::max())
;
explicit
uniform_int_distribution(const param_type& __p)
;
void
reset() ;
result_type
a() const
;
result_type
b() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const uniform_int_distribution& __d1,
const uniform_int_distribution& __d2)
;
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>
bool
operator!=(const std::uniform_int_distribution<_IntType>& __d1,
const std::uniform_int_distribution<_IntType>& __d2)
;
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>&,
const std::uniform_int_distribution<_IntType>&);
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>&,
std::uniform_int_distribution<_IntType>&);
template<typename _RealType = double>
class uniform_real_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef uniform_real_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __a = _RealType(0),
_RealType __b = _RealType(1))
;
result_type
a() const
;
result_type
b() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_a;
_RealType _M_b;
};
public:
explicit
uniform_real_distribution(_RealType __a = _RealType(0),
_RealType __b = _RealType(1))
;
explicit
uniform_real_distribution(const param_type& __p)
;
void
reset() ;
result_type
a() const
;
result_type
b() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const uniform_real_distribution& __d1,
const uniform_real_distribution& __d2)
;
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>
bool
operator!=(const std::uniform_real_distribution<_IntType>& __d1,
const std::uniform_real_distribution<_IntType>& __d2)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>&,
const std::uniform_real_distribution<_RealType>&);
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>&,
std::uniform_real_distribution<_RealType>&);
template<typename _RealType = double>
class normal_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef normal_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __mean = _RealType(0),
_RealType __stddev = _RealType(1))
;
_RealType
mean() const
;
_RealType
stddev() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_mean;
_RealType _M_stddev;
};
public:
explicit
normal_distribution(result_type __mean = result_type(0),
result_type __stddev = result_type(1))
;
explicit
normal_distribution(const param_type& __p)
;
void
reset()
;
_RealType
mean() const
;
_RealType
stddev() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _RealType1>
friend bool
operator==(const std::normal_distribution<_RealType1>& __d1,
const std::normal_distribution<_RealType1>& __d2);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::normal_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::normal_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
result_type _M_saved;
bool _M_saved_available;
};
template<typename _RealType>
bool
operator!=(const std::normal_distribution<_RealType>& __d1,
const std::normal_distribution<_RealType>& __d2)
;
template<typename _RealType = double>
class lognormal_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef lognormal_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __m = _RealType(0),
_RealType __s = _RealType(1))
;
_RealType
m() const
;
_RealType
s() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_m;
_RealType _M_s;
};
explicit
lognormal_distribution(_RealType __m = _RealType(0),
_RealType __s = _RealType(1))
;
explicit
lognormal_distribution(const param_type& __p)
;
void
reset()
;
_RealType
m() const
;
_RealType
s() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const lognormal_distribution& __d1,
const lognormal_distribution& __d2)
;
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::lognormal_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::lognormal_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
std::normal_distribution<result_type> _M_nd;
};
template<typename _RealType>
bool
operator!=(const std::lognormal_distribution<_RealType>& __d1,
const std::lognormal_distribution<_RealType>& __d2)
;
template<typename _RealType = double>
class gamma_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef gamma_distribution<_RealType> distribution_type;
friend class gamma_distribution<_RealType>;
explicit
param_type(_RealType __alpha_val = _RealType(1),
_RealType __beta_val = _RealType(1))
;
_RealType
alpha() const
;
_RealType
beta() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
void
_M_initialize();
_RealType _M_alpha;
_RealType _M_beta;
_RealType _M_malpha, _M_a2;
};
public:
explicit
gamma_distribution(_RealType __alpha_val = _RealType(1),
_RealType __beta_val = _RealType(1))
;
explicit
gamma_distribution(const param_type& __p)
;
void
reset()
;
_RealType
alpha() const
;
_RealType
beta() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const gamma_distribution& __d1,
const gamma_distribution& __d2)
;
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::gamma_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::gamma_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
std::normal_distribution<result_type> _M_nd;
};
template<typename _RealType>
bool
operator!=(const std::gamma_distribution<_RealType>& __d1,
const std::gamma_distribution<_RealType>& __d2)
;
template<typename _RealType = double>
class chi_squared_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef chi_squared_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __n = _RealType(1))
;
_RealType
n() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_n;
};
explicit
chi_squared_distribution(_RealType __n = _RealType(1))
;
explicit
chi_squared_distribution(const param_type& __p)
;
void
reset()
;
_RealType
n() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const chi_squared_distribution& __d1,
const chi_squared_distribution& __d2)
;
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::chi_squared_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::chi_squared_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const typename
std::gamma_distribution<result_type>::param_type& __p);
param_type _M_param;
std::gamma_distribution<result_type> _M_gd;
};
template<typename _RealType>
bool
operator!=(const std::chi_squared_distribution<_RealType>& __d1,
const std::chi_squared_distribution<_RealType>& __d2)
;
template<typename _RealType = double>
class cauchy_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef cauchy_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __a = _RealType(0),
_RealType __b = _RealType(1))
;
_RealType
a() const
;
_RealType
b() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_a;
_RealType _M_b;
};
explicit
cauchy_distribution(_RealType __a = _RealType(0),
_RealType __b = _RealType(1))
;
explicit
cauchy_distribution(const param_type& __p)
;
void
reset()
;
_RealType
a() const
;
_RealType
b() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const cauchy_distribution& __d1,
const cauchy_distribution& __d2)
;
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
template<typename _RealType>
bool
operator!=(const std::cauchy_distribution<_RealType>& __d1,
const std::cauchy_distribution<_RealType>& __d2)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::cauchy_distribution<_RealType>& __x);
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::cauchy_distribution<_RealType>& __x);
template<typename _RealType = double>
class fisher_f_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef fisher_f_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __m = _RealType(1),
_RealType __n = _RealType(1))
;
_RealType
m() const
;
_RealType
n() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_m;
_RealType _M_n;
};
explicit
fisher_f_distribution(_RealType __m = _RealType(1),
_RealType __n = _RealType(1))
;
explicit
fisher_f_distribution(const param_type& __p)
;
void
reset()
;
_RealType
m() const
;
_RealType
n() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const fisher_f_distribution& __d1,
const fisher_f_distribution& __d2)
;
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::fisher_f_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::fisher_f_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
std::gamma_distribution<result_type> _M_gd_x, _M_gd_y;
};
template<typename _RealType>
bool
operator!=(const std::fisher_f_distribution<_RealType>& __d1,
const std::fisher_f_distribution<_RealType>& __d2)
;
template<typename _RealType = double>
class student_t_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef student_t_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __n = _RealType(1))
;
_RealType
n() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_n;
};
explicit
student_t_distribution(_RealType __n = _RealType(1))
;
explicit
student_t_distribution(const param_type& __p)
;
void
reset()
;
_RealType
n() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const student_t_distribution& __d1,
const student_t_distribution& __d2)
;
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::student_t_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::student_t_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
std::normal_distribution<result_type> _M_nd;
std::gamma_distribution<result_type> _M_gd;
};
template<typename _RealType>
bool
operator!=(const std::student_t_distribution<_RealType>& __d1,
const std::student_t_distribution<_RealType>& __d2)
;
class bernoulli_distribution
{
public:
typedef bool result_type;
struct param_type
{
typedef bernoulli_distribution distribution_type;
explicit
param_type(double __p = 0.5)
;
double
p() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
double _M_p;
};
public:
explicit
bernoulli_distribution(double __p = 0.5)
;
explicit
bernoulli_distribution(const param_type& __p)
;
void
reset() ;
double
p() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng, const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const bernoulli_distribution& __d1,
const bernoulli_distribution& __d2)
;
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
bool
operator!=(const std::bernoulli_distribution& __d1,
const std::bernoulli_distribution& __d2)
;
template<typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::bernoulli_distribution& __x);
template<typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::bernoulli_distribution& __x)
{
double __p;
__is >> __p;
__x.param(bernoulli_distribution::param_type(__p));
return __is;
}
template<typename _IntType = int>
class binomial_distribution
{
static_assert(std::is_integral<_IntType>::value,
"template argument not an integral type");
public:
typedef _IntType result_type;
struct param_type
{
typedef binomial_distribution<_IntType> distribution_type;
friend class binomial_distribution<_IntType>;
explicit
param_type(_IntType __t = _IntType(1), double __p = 0.5)
: _M_t(__t), _M_p(__p)
{
;
_M_initialize();
}
_IntType
t() const
{ return _M_t; }
double
p() const
{ return _M_p; }
friend bool
operator==(const param_type& __p1, const param_type& __p2)
{ return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; }
private:
void
_M_initialize();
_IntType _M_t;
double _M_p;
double _M_q;
double _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
_M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
bool _M_easy;
};
explicit
binomial_distribution(_IntType __t = _IntType(1),
double __p = 0.5)
: _M_param(__t, __p), _M_nd()
{ }
explicit
binomial_distribution(const param_type& __p)
: _M_param(__p), _M_nd()
{ }
void
reset()
{ _M_nd.reset(); }
_IntType
t() const
{ return _M_param.t(); }
double
p() const
{ return _M_param.p(); }
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const binomial_distribution& __d1,
const binomial_distribution& __d2)
;
template<typename _IntType1,
typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::binomial_distribution<_IntType1>& __x);
template<typename _IntType1,
typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::binomial_distribution<_IntType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _UniformRandomNumberGenerator>
result_type
_M_waiting(_UniformRandomNumberGenerator& __urng,
_IntType __t, double __q);
param_type _M_param;
std::normal_distribution<double> _M_nd;
};
template<typename _IntType>
bool
operator!=(const std::binomial_distribution<_IntType>& __d1,
const std::binomial_distribution<_IntType>& __d2)
;
template<typename _IntType = int>
class geometric_distribution
{
static_assert(std::is_integral<_IntType>::value,
"template argument not an integral type");
public:
typedef _IntType result_type;
struct param_type
{
typedef geometric_distribution<_IntType> distribution_type;
friend class geometric_distribution<_IntType>;
explicit
param_type(double __p = 0.5)
;
double
p() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
void
_M_initialize()
;
double _M_p;
double _M_log_1_p;
};
explicit
geometric_distribution(double __p = 0.5)
;
explicit
geometric_distribution(const param_type& __p)
;
void
reset() ;
double
p() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const geometric_distribution& __d1,
const geometric_distribution& __d2)
;
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>
bool
operator!=(const std::geometric_distribution<_IntType>& __d1,
const std::geometric_distribution<_IntType>& __d2)
;
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::geometric_distribution<_IntType>& __x);
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::geometric_distribution<_IntType>& __x);
template<typename _IntType = int>
class negative_binomial_distribution
{
static_assert(std::is_integral<_IntType>::value,
"template argument not an integral type");
public:
typedef _IntType result_type;
struct param_type
{
typedef negative_binomial_distribution<_IntType> distribution_type;
explicit
param_type(_IntType __k = 1, double __p = 0.5)
;
_IntType
k() const
;
double
p() const
{ return _M_p; }
friend bool
operator==(const param_type& __p1, const param_type& __p2)
{ return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; }
private:
_IntType _M_k;
double _M_p;
};
explicit
negative_binomial_distribution(_IntType __k = 1, double __p = 0.5)
: _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p)
{ }
explicit
negative_binomial_distribution(const param_type& __p)
: _M_param(__p), _M_gd(__p.k(), (1.0 - __p.p()) / __p.p())
{ }
void
reset()
;
_IntType
k() const
;
double
p() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng);
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const negative_binomial_distribution& __d1,
const negative_binomial_distribution& __d2)
;
template<typename _IntType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::negative_binomial_distribution<_IntType1>& __x);
template<typename _IntType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::negative_binomial_distribution<_IntType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
std::gamma_distribution<double> _M_gd;
};
template<typename _IntType>
bool
operator!=(const std::negative_binomial_distribution<_IntType>& __d1,
const std::negative_binomial_distribution<_IntType>& __d2)
;
template<typename _IntType = int>
class poisson_distribution
{
static_assert(std::is_integral<_IntType>::value,
"template argument not an integral type");
public:
typedef _IntType result_type;
struct param_type
{
typedef poisson_distribution<_IntType> distribution_type;
friend class poisson_distribution<_IntType>;
explicit
param_type(double __mean = 1.0)
;
double
mean() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
void
_M_initialize();
double _M_mean;
double _M_lm_thr;
double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
};
explicit
poisson_distribution(double __mean = 1.0)
: _M_param(__mean), _M_nd()
{ }
explicit
poisson_distribution(const param_type& __p)
: _M_param(__p), _M_nd()
{ }
void
reset()
{ _M_nd.reset(); }
double
mean() const
{ return _M_param.mean(); }
param_type
param() const
{ return _M_param; }
void
param(const param_type& __param)
{ _M_param = __param; }
result_type
min() const
{ return 0; }
result_type
max() const
{ return std::numeric_limits<result_type>::max(); }
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
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)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const poisson_distribution& __d1,
const poisson_distribution& __d2)
;
template<typename _IntType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::poisson_distribution<_IntType1>& __x);
template<typename _IntType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::poisson_distribution<_IntType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
std::normal_distribution<double> _M_nd;
};
template<typename _IntType>
bool
operator!=(const std::poisson_distribution<_IntType>& __d1,
const std::poisson_distribution<_IntType>& __d2)
;
template<typename _RealType = double>
class exponential_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef exponential_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __lambda = _RealType(1))
;
_RealType
lambda() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_lambda;
};
public:
explicit
exponential_distribution(const result_type& __lambda = result_type(1))
;
explicit
exponential_distribution(const param_type& __p)
;
void
reset() ;
_RealType
lambda() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const exponential_distribution& __d1,
const exponential_distribution& __d2)
;
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
template<typename _RealType>
bool
operator!=(const std::exponential_distribution<_RealType>& __d1,
const std::exponential_distribution<_RealType>& __d2)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::exponential_distribution<_RealType>& __x);
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::exponential_distribution<_RealType>& __x);
template<typename _RealType = double>
class weibull_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef weibull_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __a = _RealType(1),
_RealType __b = _RealType(1))
;
_RealType
a() const
;
_RealType
b() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_a;
_RealType _M_b;
};
explicit
weibull_distribution(_RealType __a = _RealType(1),
_RealType __b = _RealType(1))
;
explicit
weibull_distribution(const param_type& __p)
;
void
reset()
;
_RealType
a() const
;
_RealType
b() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const weibull_distribution& __d1,
const weibull_distribution& __d2)
;
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
template<typename _RealType>
bool
operator!=(const std::weibull_distribution<_RealType>& __d1,
const std::weibull_distribution<_RealType>& __d2)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::weibull_distribution<_RealType>& __x);
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::weibull_distribution<_RealType>& __x);
template<typename _RealType = double>
class extreme_value_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef extreme_value_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __a = _RealType(0),
_RealType __b = _RealType(1))
;
_RealType
a() const
;
_RealType
b() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_a;
_RealType _M_b;
};
explicit
extreme_value_distribution(_RealType __a = _RealType(0),
_RealType __b = _RealType(1))
;
explicit
extreme_value_distribution(const param_type& __p)
;
void
reset()
;
_RealType
a() const
;
_RealType
b() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
friend bool
operator==(const extreme_value_distribution& __d1,
const extreme_value_distribution& __d2)
{ return __d1._M_param == __d2._M_param; }
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
template<typename _RealType>
inline bool
operator!=(const std::extreme_value_distribution<_RealType>& __d1,
const std::extreme_value_distribution<_RealType>& __d2)
{ return !(__d1 == __d2); }
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::extreme_value_distribution<_RealType>& __x);
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::extreme_value_distribution<_RealType>& __x);
template<typename _IntType = int>
class discrete_distribution
{
static_assert(std::is_integral<_IntType>::value,
"template argument not an integral type");
public:
typedef _IntType result_type;
struct param_type
{
typedef discrete_distribution<_IntType> distribution_type;
friend class discrete_distribution<_IntType>;
param_type()
: _M_prob(), _M_cp()
{ }
template<typename _InputIterator>
param_type(_InputIterator __wbegin,
_InputIterator __wend)
: _M_prob(__wbegin, __wend), _M_cp()
{ _M_initialize(); }
param_type(initializer_list<double> __wil)
: _M_prob(__wil.begin(), __wil.end()), _M_cp()
{ _M_initialize(); }
template<typename _Func>
param_type(size_t __nw, double __xmin, double __xmax,
_Func __fw);
param_type(const param_type&) = default;
param_type& operator=(const param_type&) = default;
std::vector<double>
probabilities() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
void
_M_initialize();
std::vector<double> _M_prob;
std::vector<double> _M_cp;
};
discrete_distribution()
;
template<typename _InputIterator>
discrete_distribution(_InputIterator __wbegin,
_InputIterator __wend)
;
discrete_distribution(initializer_list<double> __wl)
;
template<typename _Func>
discrete_distribution(size_t __nw, double __xmin, double __xmax,
_Func __fw)
;
explicit
discrete_distribution(const param_type& __p)
;
void
reset()
;
std::vector<double>
probabilities() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
friend bool
operator==(const discrete_distribution& __d1,
const discrete_distribution& __d2)
{ return __d1._M_param == __d2._M_param; }
template<typename _IntType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::discrete_distribution<_IntType1>& __x);
template<typename _IntType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::discrete_distribution<_IntType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
template<typename _IntType>
inline bool
operator!=(const std::discrete_distribution<_IntType>& __d1,
const std::discrete_distribution<_IntType>& __d2)
{ return !(__d1 == __d2); }
template<typename _RealType = double>
class piecewise_constant_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef piecewise_constant_distribution<_RealType> distribution_type;
friend class piecewise_constant_distribution<_RealType>;
param_type()
: _M_int(), _M_den(), _M_cp()
{ }
template<typename _InputIteratorB, typename _InputIteratorW>
param_type(_InputIteratorB __bfirst,
_InputIteratorB __bend,
_InputIteratorW __wbegin);
template<typename _Func>
param_type(initializer_list<_RealType> __bi, _Func __fw);
template<typename _Func>
param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
_Func __fw);
param_type(const param_type&) = default;
param_type& operator=(const param_type&) = default;
std::vector<_RealType>
intervals() const
{
if (_M_int.empty())
{
std::vector<_RealType> __tmp(2);
__tmp[1] = _RealType(1);
return __tmp;
}
else
return _M_int;
}
std::vector<double>
densities() const
{ return _M_den.empty() ? std::vector<double>(1, 1.0) : _M_den; }
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
void
_M_initialize();
std::vector<_RealType> _M_int;
std::vector<double> _M_den;
std::vector<double> _M_cp;
};
explicit
piecewise_constant_distribution()
;
template<typename _InputIteratorB, typename _InputIteratorW>
piecewise_constant_distribution(_InputIteratorB __bfirst,
_InputIteratorB __bend,
_InputIteratorW __wbegin)
;
template<typename _Func>
piecewise_constant_distribution(initializer_list<_RealType> __bl,
_Func __fw)
;
template<typename _Func>
piecewise_constant_distribution(size_t __nw,
_RealType __xmin, _RealType __xmax,
_Func __fw)
;
explicit
piecewise_constant_distribution(const param_type& __p)
;
void
reset()
;
std::vector<_RealType>
intervals() const
;
std::vector<double>
densities() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
friend bool
operator==(const piecewise_constant_distribution& __d1,
const piecewise_constant_distribution& __d2)
{ return __d1._M_param == __d2._M_param; }
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::piecewise_constant_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::piecewise_constant_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
template<typename _RealType>
inline bool
operator!=(const std::piecewise_constant_distribution<_RealType>& __d1,
const std::piecewise_constant_distribution<_RealType>& __d2)
{ return !(__d1 == __d2); }
template<typename _RealType = double>
class piecewise_linear_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef piecewise_linear_distribution<_RealType> distribution_type;
friend class piecewise_linear_distribution<_RealType>;
param_type()
: _M_int(), _M_den(), _M_cp(), _M_m()
{ }
template<typename _InputIteratorB, typename _InputIteratorW>
param_type(_InputIteratorB __bfirst,
_InputIteratorB __bend,
_InputIteratorW __wbegin);
template<typename _Func>
param_type(initializer_list<_RealType> __bl, _Func __fw);
template<typename _Func>
param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
_Func __fw);
param_type(const param_type&) = default;
param_type& operator=(const param_type&) = default;
std::vector<_RealType>
intervals() const
{
if (_M_int.empty())
{
std::vector<_RealType> __tmp(2);
__tmp[1] = _RealType(1);
return __tmp;
}
else
return _M_int;
}
std::vector<double>
densities() const
{ return _M_den.empty() ? std::vector<double>(2, 1.0) : _M_den; }
friend bool
operator==(const param_type& __p1, const param_type& __p2)
{ return (__p1._M_int == __p2._M_int
&& __p1._M_den == __p2._M_den); }
private:
void
_M_initialize();
std::vector<_RealType> _M_int;
std::vector<double> _M_den;
std::vector<double> _M_cp;
std::vector<double> _M_m;
};
explicit
piecewise_linear_distribution()
;
template<typename _InputIteratorB, typename _InputIteratorW>
piecewise_linear_distribution(_InputIteratorB __bfirst,
_InputIteratorB __bend,
_InputIteratorW __wbegin)
;
template<typename _Func>
piecewise_linear_distribution(initializer_list<_RealType> __bl,
_Func __fw)
;
template<typename _Func>
piecewise_linear_distribution(size_t __nw,
_RealType __xmin, _RealType __xmax,
_Func __fw)
;
explicit
piecewise_linear_distribution(const param_type& __p)
;
void
reset()
;
std::vector<_RealType>
intervals() const
;
std::vector<double>
densities() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const piecewise_linear_distribution& __d1,
const piecewise_linear_distribution& __d2)
{ return __d1._M_param == __d2._M_param; }
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::piecewise_linear_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::piecewise_linear_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
template<typename _RealType>
inline bool
operator!=(const std::piecewise_linear_distribution<_RealType>& __d1,
const std::piecewise_linear_distribution<_RealType>& __d2)
{ return !(__d1 == __d2); }
class seed_seq
{
public:
typedef uint_least32_t result_type;
seed_seq()
: _M_v()
{ }
template<typename _IntType>
seed_seq(std::initializer_list<_IntType> il);
template<typename _InputIterator>
seed_seq(_InputIterator __begin, _InputIterator __end);
template<typename _RandomAccessIterator>
void
generate(_RandomAccessIterator __begin, _RandomAccessIterator __end);
size_t size() const
{ return _M_v.size(); }
template<typename OutputIterator>
void
param(OutputIterator __dest) const
;
private:
std::vector<result_type> _M_v;
};
}
#define _BITS_OPT_RANDOM_H 1
#define _X86INTRIN_H_INCLUDED
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bsfd (int __X)
;
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bsrd (int __X)
;
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bswapd (int __X)
;
#pragma GCC push_options
#pragma GCC target("sse4.2")
#define __DISABLE_SSE4_2__
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__crc32b (unsigned int __C, unsigned char __V)
;
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__crc32w (unsigned int __C, unsigned short __V)
;
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__crc32d (unsigned int __C, unsigned int __V)
;
#undef __DISABLE_SSE4_2__
#pragma GCC pop_options
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__popcntd (unsigned int __X)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rdpmc (int __S)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rdtsc (void)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rdtscp (unsigned int *__A)
;
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rolb (unsigned char __X, int __C)
;
extern unsigned short
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rolw (unsigned short __X, int __C)
;
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rold (unsigned int __X, int __C)
;
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rorb (unsigned char __X, int __C)
;
extern unsigned short
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rorw (unsigned short __X, int __C)
;
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rord (unsigned int __X, int __C)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__pause (void)
;
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bsfq (long long __X)
;
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bsrq (long long __X)
;
extern long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bswapq (long long __X)
;
#pragma GCC push_options
#pragma GCC target("sse4.2")
#define __DISABLE_SSE4_2__
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__crc32q (unsigned long long __C, unsigned long long __V)
;
#undef __DISABLE_SSE4_2__
#pragma GCC pop_options
extern long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__popcntq (unsigned long long __X)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rolq (unsigned long long __X, int __C)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rorq (unsigned long long __X, int __C)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__readeflags (void)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__writeeflags (unsigned long long X)
;
#define _bswap64(a) __bswapq(a)
#define _popcnt64(a) __popcntq(a)
#define _lrotl(a,b) __rolq((a), (b))
#define _lrotr(a,b) __rorq((a), (b))
#define _bit_scan_forward(a) __bsfd(a)
#define _bit_scan_reverse(a) __bsrd(a)
#define _bswap(a) __bswapd(a)
#define _popcnt32(a) __popcntd(a)
#define _rdpmc(a) __rdpmc(a)
#define _rdtsc() __rdtsc()
#define _rdtscp(a) __rdtscp(a)
#define _rotwl(a,b) __rolw((a), (b))
#define _rotwr(a,b) __rorw((a), (b))
#define _rotl(a,b) __rold((a), (b))
#define _rotr(a,b) __rord((a), (b))
#define _MMINTRIN_H_INCLUDED
typedef int __m64 __attribute__ ((__vector_size__ (8), __may_alias__));
typedef int __v2si __attribute__ ((__vector_size__ (8)));
typedef short __v4hi __attribute__ ((__vector_size__ (8)));
typedef char __v8qi __attribute__ ((__vector_size__ (8)));
typedef long long __v1di __attribute__ ((__vector_size__ (8)));
typedef float __v2sf __attribute__ ((__vector_size__ (8)));
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_empty (void)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_empty (void)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi32_si64 (int __i)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_from_int (int __i)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_from_int64 (long long __i)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_m64 (long long __i)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64x_si64 (long long __i)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pi64x (long long __i)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_si32 (__m64 __i)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_to_int (__m64 __i)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_to_int64 (__m64 __i)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtm64_si64 (__m64 __i)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_si64x (__m64 __i)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packs_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_packsswb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packs_pi32 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_packssdw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packs_pu16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_packuswb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpckhbw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpckhwd (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_pi32 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpckhdq (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpcklbw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpcklwd (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_pi32 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpckldq (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_pi32 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddd (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_si64 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddsb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddsw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_pu8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddusb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_pu16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddusw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_pi32 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubd (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_si64 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubsb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubsw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_pu8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubusb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_pu16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubusw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_madd_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmaddwd (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mulhi_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmulhw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mullo_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmullw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_pi16 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psllw (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_pi16 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psllwi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_pi32 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pslld (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_pi32 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pslldi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_si64 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psllq (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_si64 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psllqi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sra_pi16 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psraw (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srai_pi16 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrawi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sra_pi32 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrad (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srai_pi32 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psradi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_pi16 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrlw (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_pi16 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrlwi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_pi32 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrld (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_pi32 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrldi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_si64 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrlq (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_si64 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrlqi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_and_si64 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pand (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_andnot_si64 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pandn (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_or_si64 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_por (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_xor_si64 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pxor (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpeqb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpgtb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpeqw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpgtw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_pi32 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpeqd (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_pi32 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpgtd (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setzero_si64 (void)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pi32 (int __i1, int __i0)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pi16 (short __w3, short __w2, short __w1, short __w0)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pi8 (char __b7, char __b6, char __b5, char __b4,
char __b3, char __b2, char __b1, char __b0)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_pi32 (int __i0, int __i1)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_pi16 (short __w0, short __w1, short __w2, short __w3)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_pi8 (char __b0, char __b1, char __b2, char __b3,
char __b4, char __b5, char __b6, char __b7)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_pi32 (int __i)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_pi16 (short __w)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_pi8 (char __b)
;
#define _XMMINTRIN_H_INCLUDED
#define _MM_MALLOC_H_INCLUDED
extern "C" int posix_memalign (void **, size_t, size_t) throw ();
static void *
_mm_malloc (size_t size, size_t alignment)
;
static void
_mm_free (void * ptr)
;
enum _mm_hint
{
_MM_HINT_ET0 = 7,
_MM_HINT_ET1 = 6,
_MM_HINT_T0 = 3,
_MM_HINT_T1 = 2,
_MM_HINT_T2 = 1,
_MM_HINT_NTA = 0
};
#define _mm_prefetch(P,I) __builtin_prefetch ((P), ((I & 0x4) >> 2), (I & 0x3))
typedef float __m128 __attribute__ ((__vector_size__ (16), __may_alias__));
typedef float __v4sf __attribute__ ((__vector_size__ (16)));
#define _MM_SHUFFLE(fp3,fp2,fp1,fp0) (((fp3) << 6) | ((fp2) << 4) | ((fp1) << 2) | (fp0))
#define _MM_EXCEPT_MASK 0x003f
#define _MM_EXCEPT_INVALID 0x0001
#define _MM_EXCEPT_DENORM 0x0002
#define _MM_EXCEPT_DIV_ZERO 0x0004
#define _MM_EXCEPT_OVERFLOW 0x0008
#define _MM_EXCEPT_UNDERFLOW 0x0010
#define _MM_EXCEPT_INEXACT 0x0020
#define _MM_MASK_MASK 0x1f80
#define _MM_MASK_INVALID 0x0080
#define _MM_MASK_DENORM 0x0100
#define _MM_MASK_DIV_ZERO 0x0200
#define _MM_MASK_OVERFLOW 0x0400
#define _MM_MASK_UNDERFLOW 0x0800
#define _MM_MASK_INEXACT 0x1000
#define _MM_ROUND_MASK 0x6000
#define _MM_ROUND_NEAREST 0x0000
#define _MM_ROUND_DOWN 0x2000
#define _MM_ROUND_UP 0x4000
#define _MM_ROUND_TOWARD_ZERO 0x6000
#define _MM_FLUSH_ZERO_MASK 0x8000
#define _MM_FLUSH_ZERO_ON 0x8000
#define _MM_FLUSH_ZERO_OFF 0x0000
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_undefined_ps (void)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setzero_ps (void)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_div_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sqrt_ss (__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rcp_ss (__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rsqrt_ss (__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_div_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sqrt_ps (__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rcp_ps (__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rsqrt_ps (__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_and_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_andnot_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_or_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_xor_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmple_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpge_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpneq_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnlt_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnle_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpngt_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnge_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpord_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpunord_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmple_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpge_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpneq_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnlt_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnle_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpngt_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnge_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpord_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpunord_ps (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comieq_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comilt_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comile_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comigt_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comige_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comineq_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomieq_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomilt_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomile_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomigt_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomige_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomineq_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_si32 (__m128 __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvt_ss2si (__m128 __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_si64 (__m128 __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_si64x (__m128 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtps_pi32 (__m128 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvt_ps2pi (__m128 __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_si32 (__m128 __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtt_ss2si (__m128 __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_si64 (__m128 __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_si64x (__m128 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttps_pi32 (__m128 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtt_ps2pi (__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi32_ss (__m128 __A, int __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvt_si2ss (__m128 __A, int __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_ss (__m128 __A, long long __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64x_ss (__m128 __A, long long __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpi32_ps (__m128 __A, __m64 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvt_pi2ps (__m128 __A, __m64 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpi16_ps (__m64 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpu16_ps (__m64 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpi8_ps (__m64 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpu8_ps(__m64 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpi32x2_ps(__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtps_pi16(__m128 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtps_pi8(__m128 __A)
;
#define _mm_shuffle_ps(A,B,MASK) ((__m128) __builtin_ia32_shufps ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(MASK)))
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadh_pi (__m128 __A, __m64 const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storeh_pi (__m64 *__P, __m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movehl_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movelh_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadl_pi (__m128 __A, __m64 const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storel_pi (__m64 *__P, __m128 __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movemask_ps (__m128 __A)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_getcsr (void)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_GET_EXCEPTION_STATE (void)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_GET_EXCEPTION_MASK (void)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_GET_ROUNDING_MODE (void)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_GET_FLUSH_ZERO_MODE (void)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setcsr (unsigned int __I)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_SET_EXCEPTION_STATE(unsigned int __mask)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_SET_EXCEPTION_MASK (unsigned int __mask)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_SET_ROUNDING_MODE (unsigned int __mode)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_SET_FLUSH_ZERO_MODE (unsigned int __mode)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_ss (float __F)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_ps (float __F)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_ps1 (float __F)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_ss (float const *__P)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load1_ps (float const *__P)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_ps1 (float const *__P)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_ps (float const *__P)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadu_ps (float const *__P)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadr_ps (float const *__P)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_ps (const float __Z, const float __Y, const float __X, const float __W)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_ps (float __Z, float __Y, float __X, float __W)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_ss (float *__P, __m128 __A)
;
extern float __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_f32 (__m128 __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_ps (float *__P, __m128 __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storeu_ps (float *__P, __m128 __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store1_ps (float *__P, __m128 __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_ps1 (float *__P, __m128 __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storer_ps (float *__P, __m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_move_ss (__m128 __A, __m128 __B)
;
#define _mm_extract_pi16(A,N) ((int) __builtin_ia32_vec_ext_v4hi ((__v4hi)(__m64)(A), (int)(N)))
#define _m_pextrw(A,N) _mm_extract_pi16(A, N)
#define _mm_insert_pi16(A,D,N) ((__m64) __builtin_ia32_vec_set_v4hi ((__v4hi)(__m64)(A), (int)(D), (int)(N)))
#define _m_pinsrw(A,D,N) _mm_insert_pi16(A, D, N)
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_pi16 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmaxsw (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_pu8 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmaxub (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_pi16 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pminsw (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_pu8 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pminub (__m64 __A, __m64 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movemask_pi8 (__m64 __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmovmskb (__m64 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mulhi_pu16 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmulhuw (__m64 __A, __m64 __B)
;
#define _mm_shuffle_pi16(A,N) ((__m64) __builtin_ia32_pshufw ((__v4hi)(__m64)(A), (int)(N)))
#define _m_pshufw(A,N) _mm_shuffle_pi16 (A, N)
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskmove_si64 (__m64 __A, __m64 __N, char *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_maskmovq (__m64 __A, __m64 __N, char *__P)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_avg_pu8 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pavgb (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_avg_pu16 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pavgw (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sad_pu8 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psadbw (__m64 __A, __m64 __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_pi (__m64 *__P, __m64 __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_ps (float *__P, __m128 __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sfence (void)
;
#define _MM_TRANSPOSE4_PS(row0,row1,row2,row3) do { __v4sf __r0 = (row0), __r1 = (row1), __r2 = (row2), __r3 = (row3); __v4sf __t0 = __builtin_ia32_unpcklps (__r0, __r1); __v4sf __t1 = __builtin_ia32_unpcklps (__r2, __r3); __v4sf __t2 = __builtin_ia32_unpckhps (__r0, __r1); __v4sf __t3 = __builtin_ia32_unpckhps (__r2, __r3); (row0) = __builtin_ia32_movlhps (__t0, __t1); (row1) = __builtin_ia32_movhlps (__t1, __t0); (row2) = __builtin_ia32_movlhps (__t2, __t3); (row3) = __builtin_ia32_movhlps (__t3, __t2); } while (0)
#define _EMMINTRIN_H_INCLUDED
typedef double __v2df __attribute__ ((__vector_size__ (16)));
typedef long long __v2di __attribute__ ((__vector_size__ (16)));
typedef int __v4si __attribute__ ((__vector_size__ (16)));
typedef short __v8hi __attribute__ ((__vector_size__ (16)));
typedef char __v16qi __attribute__ ((__vector_size__ (16)));
typedef long long __m128i __attribute__ ((__vector_size__ (16), __may_alias__));
typedef double __m128d __attribute__ ((__vector_size__ (16), __may_alias__));
#define _MM_SHUFFLE2(fp1,fp0) (((fp1) << 1) | (fp0))
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_sd (double __F)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_pd (double __F)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pd1 (double __F)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pd (double __W, double __X)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_pd (double __W, double __X)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_undefined_pd (void)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setzero_pd (void)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_move_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_pd (double const *__P)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadu_pd (double const *__P)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load1_pd (double const *__P)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_sd (double const *__P)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_pd1 (double const *__P)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadr_pd (double const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_pd (double *__P, __m128d __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storeu_pd (double *__P, __m128d __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_sd (double *__P, __m128d __A)
;
extern double __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_f64 (__m128d __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storel_pd (double *__P, __m128d __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storeh_pd (double *__P, __m128d __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store1_pd (double *__P, __m128d __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_pd1 (double *__P, __m128d __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storer_pd (double *__P, __m128d __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi128_si32 (__m128i __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi128_si64 (__m128i __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi128_si64x (__m128i __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_div_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_div_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sqrt_pd (__m128d __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sqrt_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_and_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_andnot_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_or_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_xor_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmple_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpge_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpneq_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnlt_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnle_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpngt_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnge_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpord_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpunord_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmple_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpge_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpneq_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnlt_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnle_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpngt_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnge_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpord_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpunord_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comieq_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comilt_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comile_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comigt_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comige_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comineq_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomieq_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomilt_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomile_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomigt_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomige_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomineq_sd (__m128d __A, __m128d __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_epi64x (long long __q1, long long __q0)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_epi64 (__m64 __q1, __m64 __q0)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_epi32 (int __q3, int __q2, int __q1, int __q0)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_epi16 (short __q7, short __q6, short __q5, short __q4,
short __q3, short __q2, short __q1, short __q0)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_epi8 (char __q15, char __q14, char __q13, char __q12,
char __q11, char __q10, char __q09, char __q08,
char __q07, char __q06, char __q05, char __q04,
char __q03, char __q02, char __q01, char __q00)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_epi64x (long long __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_epi64 (__m64 __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_epi32 (int __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_epi16 (short __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_epi8 (char __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_epi64 (__m64 __q0, __m64 __q1)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_epi32 (int __q0, int __q1, int __q2, int __q3)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_epi16 (short __q0, short __q1, short __q2, short __q3,
short __q4, short __q5, short __q6, short __q7)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_epi8 (char __q00, char __q01, char __q02, char __q03,
char __q04, char __q05, char __q06, char __q07,
char __q08, char __q09, char __q10, char __q11,
char __q12, char __q13, char __q14, char __q15)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_si128 (__m128i const *__P)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadu_si128 (__m128i const *__P)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadl_epi64 (__m128i const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_si128 (__m128i *__P, __m128i __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storeu_si128 (__m128i *__P, __m128i __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storel_epi64 (__m128i *__P, __m128i __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movepi64_pi64 (__m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movpi64_epi64 (__m64 __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_move_epi64 (__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_undefined_si128 (void)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setzero_si128 (void)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi32_pd (__m128i __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi32_ps (__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpd_epi32 (__m128d __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpd_pi32 (__m128d __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpd_ps (__m128d __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttpd_epi32 (__m128d __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttpd_pi32 (__m128d __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpi32_pd (__m64 __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtps_epi32 (__m128 __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttps_epi32 (__m128 __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtps_pd (__m128 __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_si32 (__m128d __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_si64 (__m128d __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_si64x (__m128d __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_si32 (__m128d __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_si64 (__m128d __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_si64x (__m128d __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_ss (__m128 __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi32_sd (__m128d __A, int __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_sd (__m128d __A, long long __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64x_sd (__m128d __A, long long __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_sd (__m128d __A, __m128 __B)
;
#define _mm_shuffle_pd(A,B,N) ((__m128d)__builtin_ia32_shufpd ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(N)))
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadh_pd (__m128d __A, double const *__B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadl_pd (__m128d __A, double const *__B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movemask_pd (__m128d __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packs_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packs_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packus_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_epi64 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_epi64 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_epi64 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_epu8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_epu16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_epi64 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_epu8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_epu16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_madd_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mulhi_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mullo_epi16 (__m128i __A, __m128i __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_su32 (__m64 __A, __m64 __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_epu32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_epi16 (__m128i __A, int __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_epi32 (__m128i __A, int __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_epi64 (__m128i __A, int __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srai_epi16 (__m128i __A, int __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srai_epi32 (__m128i __A, int __B)
;
#define _mm_srli_si128(A,N) ((__m128i)__builtin_ia32_psrldqi128 ((__m128i)(A), (int)(N) * 8))
#define _mm_slli_si128(A,N) ((__m128i)__builtin_ia32_pslldqi128 ((__m128i)(A), (int)(N) * 8))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_epi16 (__m128i __A, int __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_epi32 (__m128i __A, int __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_epi64 (__m128i __A, int __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_epi64 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sra_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sra_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_epi64 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_and_si128 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_andnot_si128 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_or_si128 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_xor_si128 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_epi32 (__m128i __A, __m128i __B)
;
#define _mm_extract_epi16(A,N) ((int) (unsigned short) __builtin_ia32_vec_ext_v8hi ((__v8hi)(__m128i)(A), (int)(N)))
#define _mm_insert_epi16(A,D,N) ((__m128i) __builtin_ia32_vec_set_v8hi ((__v8hi)(__m128i)(A), (int)(D), (int)(N)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_epu8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_epu8 (__m128i __A, __m128i __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movemask_epi8 (__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mulhi_epu16 (__m128i __A, __m128i __B)
;
#define _mm_shufflehi_epi16(A,N) ((__m128i)__builtin_ia32_pshufhw ((__v8hi)(__m128i)(A), (int)(N)))
#define _mm_shufflelo_epi16(A,N) ((__m128i)__builtin_ia32_pshuflw ((__v8hi)(__m128i)(A), (int)(N)))
#define _mm_shuffle_epi32(A,N) ((__m128i)__builtin_ia32_pshufd ((__v4si)(__m128i)(A), (int)(N)))
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskmoveu_si128 (__m128i __A, __m128i __B, char *__C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_avg_epu8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_avg_epu16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sad_epu8 (__m128i __A, __m128i __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_si32 (int *__A, int __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_si64 (long long int *__A, long long int __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_si128 (__m128i *__A, __m128i __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_pd (double *__A, __m128d __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_clflush (void const *__A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_lfence (void)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mfence (void)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi32_si128 (int __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_si128 (long long __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64x_si128 (long long __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castpd_ps(__m128d __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castpd_si128(__m128d __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castps_pd(__m128 __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castps_si128(__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castsi128_ps(__m128i __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castsi128_pd(__m128i __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_pause (void)
;
#define _PMMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("sse3")
#define __DISABLE_SSE3__
#define _MM_DENORMALS_ZERO_MASK 0x0040
#define _MM_DENORMALS_ZERO_ON 0x0040
#define _MM_DENORMALS_ZERO_OFF 0x0000
#define _MM_SET_DENORMALS_ZERO_MODE(mode) _mm_setcsr ((_mm_getcsr () & ~_MM_DENORMALS_ZERO_MASK) | (mode))
#define _MM_GET_DENORMALS_ZERO_MODE() (_mm_getcsr() & _MM_DENORMALS_ZERO_MASK)
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_addsub_ps (__m128 __X, __m128 __Y)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadd_ps (__m128 __X, __m128 __Y)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsub_ps (__m128 __X, __m128 __Y)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movehdup_ps (__m128 __X)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_moveldup_ps (__m128 __X)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_addsub_pd (__m128d __X, __m128d __Y)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadd_pd (__m128d __X, __m128d __Y)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsub_pd (__m128d __X, __m128d __Y)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loaddup_pd (double const *__P)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movedup_pd (__m128d __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_lddqu_si128 (__m128i const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_monitor (void const * __P, unsigned int __E, unsigned int __H)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mwait (unsigned int __E, unsigned int __H)
;
#undef __DISABLE_SSE3__
#pragma GCC pop_options
#define _TMMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("ssse3")
#define __DISABLE_SSSE3__
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadd_epi16 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadd_epi32 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadds_epi16 (__m128i __X, __m128i __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadd_pi16 (__m64 __X, __m64 __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadd_pi32 (__m64 __X, __m64 __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadds_pi16 (__m64 __X, __m64 __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsub_epi16 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsub_epi32 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsubs_epi16 (__m128i __X, __m128i __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsub_pi16 (__m64 __X, __m64 __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsub_pi32 (__m64 __X, __m64 __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsubs_pi16 (__m64 __X, __m64 __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maddubs_epi16 (__m128i __X, __m128i __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maddubs_pi16 (__m64 __X, __m64 __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mulhrs_epi16 (__m128i __X, __m128i __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mulhrs_pi16 (__m64 __X, __m64 __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shuffle_epi8 (__m128i __X, __m128i __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shuffle_pi8 (__m64 __X, __m64 __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sign_epi8 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sign_epi16 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sign_epi32 (__m128i __X, __m128i __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sign_pi8 (__m64 __X, __m64 __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sign_pi16 (__m64 __X, __m64 __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sign_pi32 (__m64 __X, __m64 __Y)
;
#define _mm_alignr_epi8(X,Y,N) ((__m128i) __builtin_ia32_palignr128 ((__v2di)(__m128i)(X), (__v2di)(__m128i)(Y), (int)(N) * 8))
#define _mm_alignr_pi8(X,Y,N) ((__m64) __builtin_ia32_palignr ((__v1di)(__m64)(X), (__v1di)(__m64)(Y), (int)(N) * 8))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_abs_epi8 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_abs_epi16 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_abs_epi32 (__m128i __X)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_abs_pi8 (__m64 __X)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_abs_pi16 (__m64 __X)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_abs_pi32 (__m64 __X)
;
#undef __DISABLE_SSSE3__
#pragma GCC pop_options
#define _AMMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("sse4a")
#define __DISABLE_SSE4A__
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_sd (double * __P, __m128d __Y)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_ss (float * __P, __m128 __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_extract_si64 (__m128i __X, __m128i __Y)
;
#define _mm_extracti_si64(X,I,L) ((__m128i) __builtin_ia32_extrqi ((__v2di)(__m128i)(X), (unsigned int)(I), (unsigned int)(L)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_insert_si64 (__m128i __X,__m128i __Y)
;
#define _mm_inserti_si64(X,Y,I,L) ((__m128i) __builtin_ia32_insertqi ((__v2di)(__m128i)(X), (__v2di)(__m128i)(Y), (unsigned int)(I), (unsigned int)(L)))
#undef __DISABLE_SSE4A__
#pragma GCC pop_options
#define _SMMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("sse4.1")
#define __DISABLE_SSE4_1__
#define _MM_FROUND_TO_NEAREST_INT 0x00
#define _MM_FROUND_TO_NEG_INF 0x01
#define _MM_FROUND_TO_POS_INF 0x02
#define _MM_FROUND_TO_ZERO 0x03
#define _MM_FROUND_CUR_DIRECTION 0x04
#define _MM_FROUND_RAISE_EXC 0x00
#define _MM_FROUND_NO_EXC 0x08
#define _MM_FROUND_NINT (_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_RAISE_EXC)
#define _MM_FROUND_FLOOR (_MM_FROUND_TO_NEG_INF | _MM_FROUND_RAISE_EXC)
#define _MM_FROUND_CEIL (_MM_FROUND_TO_POS_INF | _MM_FROUND_RAISE_EXC)
#define _MM_FROUND_TRUNC (_MM_FROUND_TO_ZERO | _MM_FROUND_RAISE_EXC)
#define _MM_FROUND_RINT (_MM_FROUND_CUR_DIRECTION | _MM_FROUND_RAISE_EXC)
#define _MM_FROUND_NEARBYINT (_MM_FROUND_CUR_DIRECTION | _MM_FROUND_NO_EXC)
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testz_si128 (__m128i __M, __m128i __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testc_si128 (__m128i __M, __m128i __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testnzc_si128 (__m128i __M, __m128i __V)
;
#define _mm_test_all_zeros(M,V) _mm_testz_si128 ((M), (V))
#define _mm_test_all_ones(V) _mm_testc_si128 ((V), _mm_cmpeq_epi32 ((V), (V)))
#define _mm_test_mix_ones_zeros(M,V) _mm_testnzc_si128 ((M), (V))
#define _mm_round_pd(V,M) ((__m128d) __builtin_ia32_roundpd ((__v2df)(__m128d)(V), (int)(M)))
#define _mm_round_sd(D,V,M) ((__m128d) __builtin_ia32_roundsd ((__v2df)(__m128d)(D), (__v2df)(__m128d)(V), (int)(M)))
#define _mm_round_ps(V,M) ((__m128) __builtin_ia32_roundps ((__v4sf)(__m128)(V), (int)(M)))
#define _mm_round_ss(D,V,M) ((__m128) __builtin_ia32_roundss ((__v4sf)(__m128)(D), (__v4sf)(__m128)(V), (int)(M)))
#define _mm_ceil_pd(V) _mm_round_pd ((V), _MM_FROUND_CEIL)
#define _mm_ceil_sd(D,V) _mm_round_sd ((D), (V), _MM_FROUND_CEIL)
#define _mm_floor_pd(V) _mm_round_pd((V), _MM_FROUND_FLOOR)
#define _mm_floor_sd(D,V) _mm_round_sd ((D), (V), _MM_FROUND_FLOOR)
#define _mm_ceil_ps(V) _mm_round_ps ((V), _MM_FROUND_CEIL)
#define _mm_ceil_ss(D,V) _mm_round_ss ((D), (V), _MM_FROUND_CEIL)
#define _mm_floor_ps(V) _mm_round_ps ((V), _MM_FROUND_FLOOR)
#define _mm_floor_ss(D,V) _mm_round_ss ((D), (V), _MM_FROUND_FLOOR)
#define _mm_blend_epi16(X,Y,M) ((__m128i) __builtin_ia32_pblendw128 ((__v8hi)(__m128i)(X), (__v8hi)(__m128i)(Y), (int)(M)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_blendv_epi8 (__m128i __X, __m128i __Y, __m128i __M)
;
#define _mm_blend_ps(X,Y,M) ((__m128) __builtin_ia32_blendps ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(M)))
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_blendv_ps (__m128 __X, __m128 __Y, __m128 __M)
;
#define _mm_blend_pd(X,Y,M) ((__m128d) __builtin_ia32_blendpd ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(M)))
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_blendv_pd (__m128d __X, __m128d __Y, __m128d __M)
;
#define _mm_dp_ps(X,Y,M) ((__m128) __builtin_ia32_dpps ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(M)))
#define _mm_dp_pd(X,Y,M) ((__m128d) __builtin_ia32_dppd ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(M)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_epi64 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_epi8 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_epi8 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_epu16 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_epu16 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_epi32 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_epi32 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_epu32 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_epu32 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mullo_epi32 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_epi32 (__m128i __X, __m128i __Y)
;
#define _mm_insert_ps(D,S,N) ((__m128) __builtin_ia32_insertps128 ((__v4sf)(__m128)(D), (__v4sf)(__m128)(S), (int)(N)))
#define _MM_MK_INSERTPS_NDX(S,D,M) (((S) << 6) | ((D) << 4) | (M))
#define _mm_extract_ps(X,N) (__extension__ ({ union { int i; float f; } __tmp; __tmp.f = __builtin_ia32_vec_ext_v4sf ((__v4sf)(__m128)(X), (int)(N)); __tmp.i; }))
#define _MM_EXTRACT_FLOAT(D,S,N) { (D) = __builtin_ia32_vec_ext_v4sf ((__v4sf)(S), (N)); }
#define _MM_PICK_OUT_PS(X,N) _mm_insert_ps (_mm_setzero_ps (), (X), _MM_MK_INSERTPS_NDX ((N), 0, 0x0e))
#define _mm_insert_epi8(D,S,N) ((__m128i) __builtin_ia32_vec_set_v16qi ((__v16qi)(__m128i)(D), (int)(S), (int)(N)))
#define _mm_insert_epi32(D,S,N) ((__m128i) __builtin_ia32_vec_set_v4si ((__v4si)(__m128i)(D), (int)(S), (int)(N)))
#define _mm_insert_epi64(D,S,N) ((__m128i) __builtin_ia32_vec_set_v2di ((__v2di)(__m128i)(D), (long long)(S), (int)(N)))
#define _mm_extract_epi8(X,N) ((int) (unsigned char) __builtin_ia32_vec_ext_v16qi ((__v16qi)(__m128i)(X), (int)(N)))
#define _mm_extract_epi32(X,N) ((int) __builtin_ia32_vec_ext_v4si ((__v4si)(__m128i)(X), (int)(N)))
#define _mm_extract_epi64(X,N) ((long long) __builtin_ia32_vec_ext_v2di ((__v2di)(__m128i)(X), (int)(N)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_minpos_epu16 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi8_epi32 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi16_epi32 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi8_epi64 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi32_epi64 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi16_epi64 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi8_epi16 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepu8_epi32 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepu16_epi32 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepu8_epi64 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepu32_epi64 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepu16_epi64 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepu8_epi16 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packus_epi32 (__m128i __X, __m128i __Y)
;
#define _mm_mpsadbw_epu8(X,Y,M) ((__m128i) __builtin_ia32_mpsadbw128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_load_si128 (__m128i *__X)
;
#pragma GCC push_options
#pragma GCC target("sse4.2")
#define __DISABLE_SSE4_2__
#define _SIDD_UBYTE_OPS 0x00
#define _SIDD_UWORD_OPS 0x01
#define _SIDD_SBYTE_OPS 0x02
#define _SIDD_SWORD_OPS 0x03
#define _SIDD_CMP_EQUAL_ANY 0x00
#define _SIDD_CMP_RANGES 0x04
#define _SIDD_CMP_EQUAL_EACH 0x08
#define _SIDD_CMP_EQUAL_ORDERED 0x0c
#define _SIDD_POSITIVE_POLARITY 0x00
#define _SIDD_NEGATIVE_POLARITY 0x10
#define _SIDD_MASKED_POSITIVE_POLARITY 0x20
#define _SIDD_MASKED_NEGATIVE_POLARITY 0x30
#define _SIDD_LEAST_SIGNIFICANT 0x00
#define _SIDD_MOST_SIGNIFICANT 0x40
#define _SIDD_BIT_MASK 0x00
#define _SIDD_UNIT_MASK 0x40
#define _mm_cmpistrm(X,Y,M) ((__m128i) __builtin_ia32_pcmpistrm128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
#define _mm_cmpistri(X,Y,M) ((int) __builtin_ia32_pcmpistri128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
#define _mm_cmpestrm(X,LX,Y,LY,M) ((__m128i) __builtin_ia32_pcmpestrm128 ((__v16qi)(__m128i)(X), (int)(LX), (__v16qi)(__m128i)(Y), (int)(LY), (int)(M)))
#define _mm_cmpestri(X,LX,Y,LY,M) ((int) __builtin_ia32_pcmpestri128 ((__v16qi)(__m128i)(X), (int)(LX), (__v16qi)(__m128i)(Y), (int)(LY), (int)(M)))
#define _mm_cmpistra(X,Y,M) ((int) __builtin_ia32_pcmpistria128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
#define _mm_cmpistrc(X,Y,M) ((int) __builtin_ia32_pcmpistric128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
#define _mm_cmpistro(X,Y,M) ((int) __builtin_ia32_pcmpistrio128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
#define _mm_cmpistrs(X,Y,M) ((int) __builtin_ia32_pcmpistris128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
#define _mm_cmpistrz(X,Y,M) ((int) __builtin_ia32_pcmpistriz128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
#define _mm_cmpestra(X,LX,Y,LY,M) ((int) __builtin_ia32_pcmpestria128 ((__v16qi)(__m128i)(X), (int)(LX), (__v16qi)(__m128i)(Y), (int)(LY), (int)(M)))
#define _mm_cmpestrc(X,LX,Y,LY,M) ((int) __builtin_ia32_pcmpestric128 ((__v16qi)(__m128i)(X), (int)(LX), (__v16qi)(__m128i)(Y), (int)(LY), (int)(M)))
#define _mm_cmpestro(X,LX,Y,LY,M) ((int) __builtin_ia32_pcmpestrio128 ((__v16qi)(__m128i)(X), (int)(LX), (__v16qi)(__m128i)(Y), (int)(LY), (int)(M)))
#define _mm_cmpestrs(X,LX,Y,LY,M) ((int) __builtin_ia32_pcmpestris128 ((__v16qi)(__m128i)(X), (int)(LX), (__v16qi)(__m128i)(Y), (int)(LY), (int)(M)))
#define _mm_cmpestrz(X,LX,Y,LY,M) ((int) __builtin_ia32_pcmpestriz128 ((__v16qi)(__m128i)(X), (int)(LX), (__v16qi)(__m128i)(Y), (int)(LY), (int)(M)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_epi64 (__m128i __X, __m128i __Y)
;
#undef __DISABLE_SSE4_2__
#pragma GCC pop_options
#undef __DISABLE_SSE4_1__
#pragma GCC pop_options
#define _POPCNTINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("popcnt")
#define __DISABLE_POPCNT__
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_popcnt_u32 (unsigned int __X)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_popcnt_u64 (unsigned long long __X)
;
#undef __DISABLE_POPCNT__
#pragma GCC pop_options
#pragma GCC push_options
#pragma GCC target("sse4.1")
#define __DISABLE_SSE4_1__
#pragma GCC push_options
#pragma GCC target("sse4.2")
#define __DISABLE_SSE4_2__
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_crc32_u8 (unsigned int __C, unsigned char __V)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_crc32_u16 (unsigned int __C, unsigned short __V)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_crc32_u32 (unsigned int __C, unsigned int __V)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_crc32_u64 (unsigned long long __C, unsigned long long __V)
;
#undef __DISABLE_SSE4_2__
#pragma GCC pop_options
#undef __DISABLE_SSE4_1__
#pragma GCC pop_options
#define _WMMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("aes")
#define __DISABLE_AES__
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_aesdec_si128 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_aesdeclast_si128 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_aesenc_si128 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_aesenclast_si128 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_aesimc_si128 (__m128i __X)
;
#define _mm_aeskeygenassist_si128(X,C) ((__m128i) __builtin_ia32_aeskeygenassist128 ((__v2di)(__m128i)(X), (int)(C)))
#undef __DISABLE_AES__
#pragma GCC pop_options
#pragma GCC push_options
#pragma GCC target("pclmul")
#define __DISABLE_PCLMUL__
#define _mm_clmulepi64_si128(X,Y,I) ((__m128i) __builtin_ia32_pclmulqdq128 ((__v2di)(__m128i)(X), (__v2di)(__m128i)(Y), (int)(I)))
#undef __DISABLE_PCLMUL__
#pragma GCC pop_options
#define _IMMINTRIN_H_INCLUDED
#define _AVXINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("avx")
#define __DISABLE_AVX__
typedef double __v4df __attribute__ ((__vector_size__ (32)));
typedef float __v8sf __attribute__ ((__vector_size__ (32)));
typedef long long __v4di __attribute__ ((__vector_size__ (32)));
typedef int __v8si __attribute__ ((__vector_size__ (32)));
typedef short __v16hi __attribute__ ((__vector_size__ (32)));
typedef char __v32qi __attribute__ ((__vector_size__ (32)));
typedef float __m256 __attribute__ ((__vector_size__ (32),
__may_alias__));
typedef long long __m256i __attribute__ ((__vector_size__ (32),
__may_alias__));
typedef double __m256d __attribute__ ((__vector_size__ (32),
__may_alias__));
#define _CMP_EQ_OQ 0x00
#define _CMP_LT_OS 0x01
#define _CMP_LE_OS 0x02
#define _CMP_UNORD_Q 0x03
#define _CMP_NEQ_UQ 0x04
#define _CMP_NLT_US 0x05
#define _CMP_NLE_US 0x06
#define _CMP_ORD_Q 0x07
#define _CMP_EQ_UQ 0x08
#define _CMP_NGE_US 0x09
#define _CMP_NGT_US 0x0a
#define _CMP_FALSE_OQ 0x0b
#define _CMP_NEQ_OQ 0x0c
#define _CMP_GE_OS 0x0d
#define _CMP_GT_OS 0x0e
#define _CMP_TRUE_UQ 0x0f
#define _CMP_EQ_OS 0x10
#define _CMP_LT_OQ 0x11
#define _CMP_LE_OQ 0x12
#define _CMP_UNORD_S 0x13
#define _CMP_NEQ_US 0x14
#define _CMP_NLT_UQ 0x15
#define _CMP_NLE_UQ 0x16
#define _CMP_ORD_S 0x17
#define _CMP_EQ_US 0x18
#define _CMP_NGE_UQ 0x19
#define _CMP_NGT_UQ 0x1a
#define _CMP_FALSE_OS 0x1b
#define _CMP_NEQ_OS 0x1c
#define _CMP_GE_OQ 0x1d
#define _CMP_GT_OQ 0x1e
#define _CMP_TRUE_US 0x1f
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_add_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_add_ps (__m256 __A, __m256 __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_addsub_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_addsub_ps (__m256 __A, __m256 __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_and_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_and_ps (__m256 __A, __m256 __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_andnot_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_andnot_ps (__m256 __A, __m256 __B)
;
#define _mm256_blend_pd(X,Y,M) ((__m256d) __builtin_ia32_blendpd256 ((__v4df)(__m256d)(X), (__v4df)(__m256d)(Y), (int)(M)))
#define _mm256_blend_ps(X,Y,M) ((__m256) __builtin_ia32_blendps256 ((__v8sf)(__m256)(X), (__v8sf)(__m256)(Y), (int)(M)))
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_blendv_pd (__m256d __X, __m256d __Y, __m256d __M)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_blendv_ps (__m256 __X, __m256 __Y, __m256 __M)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_div_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_div_ps (__m256 __A, __m256 __B)
;
#define _mm256_dp_ps(X,Y,M) ((__m256) __builtin_ia32_dpps256 ((__v8sf)(__m256)(X), (__v8sf)(__m256)(Y), (int)(M)))
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hadd_pd (__m256d __X, __m256d __Y)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hadd_ps (__m256 __X, __m256 __Y)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hsub_pd (__m256d __X, __m256d __Y)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hsub_ps (__m256 __X, __m256 __Y)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_ps (__m256 __A, __m256 __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_ps (__m256 __A, __m256 __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mul_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mul_ps (__m256 __A, __m256 __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_or_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_or_ps (__m256 __A, __m256 __B)
;
#define _mm256_shuffle_pd(A,B,N) ((__m256d)__builtin_ia32_shufpd256 ((__v4df)(__m256d)(A), (__v4df)(__m256d)(B), (int)(N)))
#define _mm256_shuffle_ps(A,B,N) ((__m256) __builtin_ia32_shufps256 ((__v8sf)(__m256)(A), (__v8sf)(__m256)(B), (int)(N)))
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sub_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sub_ps (__m256 __A, __m256 __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_xor_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_xor_ps (__m256 __A, __m256 __B)
;
#define _mm_cmp_pd(X,Y,P) ((__m128d) __builtin_ia32_cmppd ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P)))
#define _mm_cmp_ps(X,Y,P) ((__m128) __builtin_ia32_cmpps ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P)))
#define _mm256_cmp_pd(X,Y,P) ((__m256d) __builtin_ia32_cmppd256 ((__v4df)(__m256d)(X), (__v4df)(__m256d)(Y), (int)(P)))
#define _mm256_cmp_ps(X,Y,P) ((__m256) __builtin_ia32_cmpps256 ((__v8sf)(__m256)(X), (__v8sf)(__m256)(Y), (int)(P)))
#define _mm_cmp_sd(X,Y,P) ((__m128d) __builtin_ia32_cmpsd ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P)))
#define _mm_cmp_ss(X,Y,P) ((__m128) __builtin_ia32_cmpss ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P)))
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi32_pd (__m128i __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi32_ps (__m256i __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtpd_ps (__m256d __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtps_epi32 (__m256 __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtps_pd (__m128 __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvttpd_epi32 (__m256d __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtpd_epi32 (__m256d __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvttps_epi32 (__m256 __A)
;
#define _mm256_extractf128_pd(X,N) ((__m128d) __builtin_ia32_vextractf128_pd256 ((__v4df)(__m256d)(X), (int)(N)))
#define _mm256_extractf128_ps(X,N) ((__m128) __builtin_ia32_vextractf128_ps256 ((__v8sf)(__m256)(X), (int)(N)))
#define _mm256_extractf128_si256(X,N) ((__m128i) __builtin_ia32_vextractf128_si256 ((__v8si)(__m256i)(X), (int)(N)))
#define _mm256_extract_epi32(X,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 2); _mm_extract_epi32 (__Y, (N) % 4); }))
#define _mm256_extract_epi16(X,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 3); _mm_extract_epi16 (__Y, (N) % 8); }))
#define _mm256_extract_epi8(X,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 4); _mm_extract_epi8 (__Y, (N) % 16); }))
#define _mm256_extract_epi64(X,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 1); _mm_extract_epi64 (__Y, (N) % 2); }))
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_zeroall (void)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_zeroupper (void)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_permutevar_pd (__m128d __A, __m128i __C)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_permutevar_pd (__m256d __A, __m256i __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_permutevar_ps (__m128 __A, __m128i __C)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_permutevar_ps (__m256 __A, __m256i __C)
;
#define _mm_permute_pd(X,C) ((__m128d) __builtin_ia32_vpermilpd ((__v2df)(__m128d)(X), (int)(C)))
#define _mm256_permute_pd(X,C) ((__m256d) __builtin_ia32_vpermilpd256 ((__v4df)(__m256d)(X), (int)(C)))
#define _mm_permute_ps(X,C) ((__m128) __builtin_ia32_vpermilps ((__v4sf)(__m128)(X), (int)(C)))
#define _mm256_permute_ps(X,C) ((__m256) __builtin_ia32_vpermilps256 ((__v8sf)(__m256)(X), (int)(C)))
#define _mm256_permute2f128_pd(X,Y,C) ((__m256d) __builtin_ia32_vperm2f128_pd256 ((__v4df)(__m256d)(X), (__v4df)(__m256d)(Y), (int)(C)))
#define _mm256_permute2f128_ps(X,Y,C) ((__m256) __builtin_ia32_vperm2f128_ps256 ((__v8sf)(__m256)(X), (__v8sf)(__m256)(Y), (int)(C)))
#define _mm256_permute2f128_si256(X,Y,C) ((__m256i) __builtin_ia32_vperm2f128_si256 ((__v8si)(__m256i)(X), (__v8si)(__m256i)(Y), (int)(C)))
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_broadcast_ss (float const *__X)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcast_sd (double const *__X)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcast_ss (float const *__X)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcast_pd (__m128d const *__X)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcast_ps (__m128 const *__X)
;
#define _mm256_insertf128_pd(X,Y,O) ((__m256d) __builtin_ia32_vinsertf128_pd256 ((__v4df)(__m256d)(X), (__v2df)(__m128d)(Y), (int)(O)))
#define _mm256_insertf128_ps(X,Y,O) ((__m256) __builtin_ia32_vinsertf128_ps256 ((__v8sf)(__m256)(X), (__v4sf)(__m128)(Y), (int)(O)))
#define _mm256_insertf128_si256(X,Y,O) ((__m256i) __builtin_ia32_vinsertf128_si256 ((__v8si)(__m256i)(X), (__v4si)(__m128i)(Y), (int)(O)))
#define _mm256_insert_epi32(X,D,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 2); __Y = _mm_insert_epi32 (__Y, (D), (N) % 4); _mm256_insertf128_si256 ((X), __Y, (N) >> 2); }))
#define _mm256_insert_epi16(X,D,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 3); __Y = _mm_insert_epi16 (__Y, (D), (N) % 8); _mm256_insertf128_si256 ((X), __Y, (N) >> 3); }))
#define _mm256_insert_epi8(X,D,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 4); __Y = _mm_insert_epi8 (__Y, (D), (N) % 16); _mm256_insertf128_si256 ((X), __Y, (N) >> 4); }))
#define _mm256_insert_epi64(X,D,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 1); __Y = _mm_insert_epi64 (__Y, (D), (N) % 2); _mm256_insertf128_si256 ((X), __Y, (N) >> 1); }))
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_load_pd (double const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_store_pd (double *__P, __m256d __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_load_ps (float const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_store_ps (float *__P, __m256 __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_loadu_pd (double const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_storeu_pd (double *__P, __m256d __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_loadu_ps (float const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_storeu_ps (float *__P, __m256 __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_load_si256 (__m256i const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_store_si256 (__m256i *__P, __m256i __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_loadu_si256 (__m256i const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_storeu_si256 (__m256i *__P, __m256i __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskload_pd (double const *__P, __m128i __M)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskstore_pd (double *__P, __m128i __M, __m128d __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskload_pd (double const *__P, __m256i __M)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskstore_pd (double *__P, __m256i __M, __m256d __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskload_ps (float const *__P, __m128i __M)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskstore_ps (float *__P, __m128i __M, __m128 __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskload_ps (float const *__P, __m256i __M)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskstore_ps (float *__P, __m256i __M, __m256 __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_movehdup_ps (__m256 __X)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_moveldup_ps (__m256 __X)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_movedup_pd (__m256d __X)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_lddqu_si256 (__m256i const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_stream_si256 (__m256i *__A, __m256i __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_stream_pd (double *__A, __m256d __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_stream_ps (float *__P, __m256 __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_rcp_ps (__m256 __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_rsqrt_ps (__m256 __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sqrt_pd (__m256d __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sqrt_ps (__m256 __A)
;
#define _mm256_round_pd(V,M) ((__m256d) __builtin_ia32_roundpd256 ((__v4df)(__m256d)(V), (int)(M)))
#define _mm256_round_ps(V,M) ((__m256) __builtin_ia32_roundps256 ((__v8sf)(__m256)(V), (int)(M)))
#define _mm256_ceil_pd(V) _mm256_round_pd ((V), _MM_FROUND_CEIL)
#define _mm256_floor_pd(V) _mm256_round_pd ((V), _MM_FROUND_FLOOR)
#define _mm256_ceil_ps(V) _mm256_round_ps ((V), _MM_FROUND_CEIL)
#define _mm256_floor_ps(V) _mm256_round_ps ((V), _MM_FROUND_FLOOR)
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpackhi_pd (__m256d __A, __m256d __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpacklo_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpackhi_ps (__m256 __A, __m256 __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpacklo_ps (__m256 __A, __m256 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testz_pd (__m128d __M, __m128d __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testc_pd (__m128d __M, __m128d __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testnzc_pd (__m128d __M, __m128d __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testz_ps (__m128 __M, __m128 __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testc_ps (__m128 __M, __m128 __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testnzc_ps (__m128 __M, __m128 __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testz_pd (__m256d __M, __m256d __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testc_pd (__m256d __M, __m256d __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testnzc_pd (__m256d __M, __m256d __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testz_ps (__m256 __M, __m256 __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testc_ps (__m256 __M, __m256 __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testnzc_ps (__m256 __M, __m256 __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testz_si256 (__m256i __M, __m256i __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testc_si256 (__m256i __M, __m256i __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testnzc_si256 (__m256i __M, __m256i __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_movemask_pd (__m256d __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_movemask_ps (__m256 __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_undefined_pd (void)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_undefined_ps (void)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_undefined_si256 (void)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setzero_pd (void)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setzero_ps (void)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setzero_si256 (void)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set_pd (double __A, double __B, double __C, double __D)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set_ps (float __A, float __B, float __C, float __D,
float __E, float __F, float __G, float __H)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set_epi32 (int __A, int __B, int __C, int __D,
int __E, int __F, int __G, int __H)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set_epi16 (short __q15, short __q14, short __q13, short __q12,
short __q11, short __q10, short __q09, short __q08,
short __q07, short __q06, short __q05, short __q04,
short __q03, short __q02, short __q01, short __q00)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set_epi8 (char __q31, char __q30, char __q29, char __q28,
char __q27, char __q26, char __q25, char __q24,
char __q23, char __q22, char __q21, char __q20,
char __q19, char __q18, char __q17, char __q16,
char __q15, char __q14, char __q13, char __q12,
char __q11, char __q10, char __q09, char __q08,
char __q07, char __q06, char __q05, char __q04,
char __q03, char __q02, char __q01, char __q00)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set_epi64x (long long __A, long long __B, long long __C,
long long __D)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set1_pd (double __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set1_ps (float __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set1_epi32 (int __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set1_epi16 (short __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set1_epi8 (char __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set1_epi64x (long long __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setr_pd (double __A, double __B, double __C, double __D)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setr_ps (float __A, float __B, float __C, float __D,
float __E, float __F, float __G, float __H)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setr_epi32 (int __A, int __B, int __C, int __D,
int __E, int __F, int __G, int __H)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setr_epi16 (short __q15, short __q14, short __q13, short __q12,
short __q11, short __q10, short __q09, short __q08,
short __q07, short __q06, short __q05, short __q04,
short __q03, short __q02, short __q01, short __q00)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setr_epi8 (char __q31, char __q30, char __q29, char __q28,
char __q27, char __q26, char __q25, char __q24,
char __q23, char __q22, char __q21, char __q20,
char __q19, char __q18, char __q17, char __q16,
char __q15, char __q14, char __q13, char __q12,
char __q11, char __q10, char __q09, char __q08,
char __q07, char __q06, char __q05, char __q04,
char __q03, char __q02, char __q01, char __q00)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setr_epi64x (long long __A, long long __B, long long __C,
long long __D)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castpd_ps (__m256d __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castpd_si256 (__m256d __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castps_pd (__m256 __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castps_si256(__m256 __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castsi256_ps (__m256i __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castsi256_pd (__m256i __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castpd256_pd128 (__m256d __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castps256_ps128 (__m256 __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castsi256_si128 (__m256i __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castpd128_pd256 (__m128d __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castps128_ps256 (__m128 __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castsi128_si256 (__m128i __A)
;
#undef __DISABLE_AVX__
#pragma GCC pop_options
#define _AVX2INTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("avx2")
#define __DISABLE_AVX2__
#define _mm256_mpsadbw_epu8(X,Y,M) ((__m256i) __builtin_ia32_mpsadbw256 ((__v32qi)(__m256i)(X), (__v32qi)(__m256i)(Y), (int)(M)))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_abs_epi8 (__m256i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_abs_epi16 (__m256i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_abs_epi32 (__m256i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_packs_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_packs_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_packus_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_packus_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_add_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_add_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_add_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_add_epi64 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_adds_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_adds_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_adds_epu8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_adds_epu16 (__m256i __A, __m256i __B)
;
#define _mm256_alignr_epi8(A,B,N) ((__m256i) __builtin_ia32_palignr256 ((__v4di)(__m256i)(A), (__v4di)(__m256i)(B), (int)(N) * 8))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_and_si256 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_andnot_si256 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_avg_epu8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_avg_epu16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_blendv_epi8 (__m256i __X, __m256i __Y, __m256i __M)
;
#define _mm256_blend_epi16(X,Y,M) ((__m256i) __builtin_ia32_pblendw256 ((__v16hi)(__m256i)(X), (__v16hi)(__m256i)(Y), (int)(M)))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpeq_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpeq_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpeq_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpeq_epi64 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpgt_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpgt_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpgt_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpgt_epi64 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hadd_epi16 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hadd_epi32 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hadds_epi16 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hsub_epi16 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hsub_epi32 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hsubs_epi16 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maddubs_epi16 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_madd_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_epu8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_epu16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_epu32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_epu8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_epu16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_epu32 (__m256i __A, __m256i __B)
;
extern int
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_movemask_epi8 (__m256i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi8_epi16 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi8_epi32 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi8_epi64 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi16_epi32 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi16_epi64 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi32_epi64 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepu8_epi16 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepu8_epi32 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepu8_epi64 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepu16_epi32 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepu16_epi64 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepu32_epi64 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mul_epi32 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mulhrs_epi16 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mulhi_epu16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mulhi_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mullo_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mullo_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mul_epu32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_or_si256 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sad_epu8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_shuffle_epi8 (__m256i __X, __m256i __Y)
;
#define _mm256_shuffle_epi32(A,N) ((__m256i)__builtin_ia32_pshufd256 ((__v8si)(__m256i)(A), (int)(N)))
#define _mm256_shufflehi_epi16(A,N) ((__m256i)__builtin_ia32_pshufhw256 ((__v16hi)(__m256i)(A), (int)(N)))
#define _mm256_shufflelo_epi16(A,N) ((__m256i)__builtin_ia32_pshuflw256 ((__v16hi)(__m256i)(A), (int)(N)))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sign_epi8 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sign_epi16 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sign_epi32 (__m256i __X, __m256i __Y)
;
#define _mm256_slli_si256(A,N) ((__m256i)__builtin_ia32_pslldqi256 ((__m256i)(A), (int)(N) * 8))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_slli_epi16 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sll_epi16 (__m256i __A, __m128i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_slli_epi32 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sll_epi32 (__m256i __A, __m128i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_slli_epi64 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sll_epi64 (__m256i __A, __m128i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srai_epi16 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sra_epi16 (__m256i __A, __m128i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srai_epi32 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sra_epi32 (__m256i __A, __m128i __B)
;
#define _mm256_srli_si256(A,N) ((__m256i)__builtin_ia32_psrldqi256 ((__m256i)(A), (int)(N) * 8))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srli_epi16 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srl_epi16 (__m256i __A, __m128i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srli_epi32 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srl_epi32 (__m256i __A, __m128i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srli_epi64 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srl_epi64 (__m256i __A, __m128i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sub_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sub_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sub_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sub_epi64 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_subs_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_subs_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_subs_epu8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_subs_epu16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpackhi_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpackhi_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpackhi_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpackhi_epi64 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpacklo_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpacklo_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpacklo_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpacklo_epi64 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_xor_si256 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_stream_load_si256 (__m256i const *__X)
;
extern __m128
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_broadcastss_ps (__m128 __X)
;
extern __m256
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcastss_ps (__m128 __X)
;
extern __m256d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcastsd_pd (__m128d __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcastsi128_si256 (__m128i __X)
;
#define _mm_blend_epi32(X,Y,M) ((__m128i) __builtin_ia32_pblendd128 ((__v4si)(__m128i)(X), (__v4si)(__m128i)(Y), (int)(M)))
#define _mm256_blend_epi32(X,Y,M) ((__m256i) __builtin_ia32_pblendd256 ((__v8si)(__m256i)(X), (__v8si)(__m256i)(Y), (int)(M)))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcastb_epi8 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcastw_epi16 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcastd_epi32 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcastq_epi64 (__m128i __X)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_broadcastb_epi8 (__m128i __X)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_broadcastw_epi16 (__m128i __X)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_broadcastd_epi32 (__m128i __X)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_broadcastq_epi64 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_permutevar8x32_epi32 (__m256i __X, __m256i __Y)
;
#define _mm256_permute4x64_pd(X,M) ((__m256d) __builtin_ia32_permdf256 ((__v4df)(__m256d)(X), (int)(M)))
extern __m256
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_permutevar8x32_ps (__m256 __X, __m256i __Y)
;
#define _mm256_permute4x64_epi64(X,M) ((__m256i) __builtin_ia32_permdi256 ((__v4di)(__m256i)(X), (int)(M)))
#define _mm256_permute2x128_si256(X,Y,M) ((__m256i) __builtin_ia32_permti256 ((__v4di)(__m256i)(X), (__v4di)(__m256i)(Y), (int)(M)))
#define _mm256_extracti128_si256(X,M) ((__m128i) __builtin_ia32_extract128i256 ((__v4di)(__m256i)(X), (int)(M)))
#define _mm256_inserti128_si256(X,Y,M) ((__m256i) __builtin_ia32_insert128i256 ((__v4di)(__m256i)(X), (__v2di)(__m128i)(Y), (int)(M)))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskload_epi32 (int const *__X, __m256i __M )
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskload_epi64 (long long const *__X, __m256i __M )
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskload_epi32 (int const *__X, __m128i __M )
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskload_epi64 (long long const *__X, __m128i __M )
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskstore_epi32 (int *__X, __m256i __M, __m256i __Y )
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskstore_epi64 (long long *__X, __m256i __M, __m256i __Y )
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskstore_epi32 (int *__X, __m128i __M, __m128i __Y )
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskstore_epi64 (long long *__X, __m128i __M, __m128i __Y )
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sllv_epi32 (__m256i __X, __m256i __Y)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sllv_epi32 (__m128i __X, __m128i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sllv_epi64 (__m256i __X, __m256i __Y)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sllv_epi64 (__m128i __X, __m128i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srav_epi32 (__m256i __X, __m256i __Y)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_srav_epi32 (__m128i __X, __m128i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srlv_epi32 (__m256i __X, __m256i __Y)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_srlv_epi32 (__m128i __X, __m128i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srlv_epi64 (__m256i __X, __m256i __Y)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_srlv_epi64 (__m128i __X, __m128i __Y)
;
#define _mm_i32gather_pd(BASE,INDEX,SCALE) (__m128d) __builtin_ia32_gathersiv2df ((__v2df) _mm_setzero_pd (), (double const *)BASE, (__v4si)(__m128i)INDEX, (__v2df)_mm_set1_pd( (double)(long long int) -1), (int)SCALE)
#define _mm_mask_i32gather_pd(SRC,BASE,INDEX,MASK,SCALE) (__m128d) __builtin_ia32_gathersiv2df ((__v2df)(__m128d)SRC, (double const *)BASE, (__v4si)(__m128i)INDEX, (__v2df)(__m128d)MASK, (int)SCALE)
#define _mm256_i32gather_pd(BASE,INDEX,SCALE) (__m256d) __builtin_ia32_gathersiv4df ((__v4df) _mm256_setzero_pd (), (double const *)BASE, (__v4si)(__m128i)INDEX, (__v4df)_mm256_set1_pd( (double)(long long int) -1), (int)SCALE)
#define _mm256_mask_i32gather_pd(SRC,BASE,INDEX,MASK,SCALE) (__m256d) __builtin_ia32_gathersiv4df ((__v4df)(__m256d)SRC, (double const *)BASE, (__v4si)(__m128i)INDEX, (__v4df)(__m256d)MASK, (int)SCALE)
#define _mm_i64gather_pd(BASE,INDEX,SCALE) (__m128d) __builtin_ia32_gatherdiv2df ((__v2df) _mm_setzero_pd (), (double const *)BASE, (__v2di)(__m128i)INDEX, (__v2df)_mm_set1_pd( (double)(long long int) -1), (int)SCALE)
#define _mm_mask_i64gather_pd(SRC,BASE,INDEX,MASK,SCALE) (__m128d) __builtin_ia32_gatherdiv2df ((__v2df)(__m128d)SRC, (double const *)BASE, (__v2di)(__m128i)INDEX, (__v2df)(__m128d)MASK, (int)SCALE)
#define _mm256_i64gather_pd(BASE,INDEX,SCALE) (__m256d) __builtin_ia32_gatherdiv4df ((__v4df) _mm256_setzero_pd (), (double const *)BASE, (__v4di)(__m256i)INDEX, (__v4df)_mm256_set1_pd( (double)(long long int) -1), (int)SCALE)
#define _mm256_mask_i64gather_pd(SRC,BASE,INDEX,MASK,SCALE) (__m256d) __builtin_ia32_gatherdiv4df ((__v4df)(__m256d)SRC, (double const *)BASE, (__v4di)(__m256i)INDEX, (__v4df)(__m256d)MASK, (int)SCALE)
#define _mm_i32gather_ps(BASE,INDEX,SCALE) (__m128) __builtin_ia32_gathersiv4sf ((__v4sf) _mm_setzero_ps (), (float const *)BASE, (__v4si)(__m128i)INDEX, _mm_set1_ps ((float)(int) -1), (int)SCALE)
#define _mm_mask_i32gather_ps(SRC,BASE,INDEX,MASK,SCALE) (__m128) __builtin_ia32_gathersiv4sf ((__v4sf)(__m128d)SRC, (float const *)BASE, (__v4si)(__m128i)INDEX, (__v4sf)(__m128d)MASK, (int)SCALE)
#define _mm256_i32gather_ps(BASE,INDEX,SCALE) (__m256) __builtin_ia32_gathersiv8sf ((__v8sf) _mm256_setzero_ps (), (float const *)BASE, (__v8si)(__m256i)INDEX, (__v8sf)_mm256_set1_ps ( (float)(int) -1), (int)SCALE)
#define _mm256_mask_i32gather_ps(SRC,BASE,INDEX,MASK,SCALE) (__m256) __builtin_ia32_gathersiv8sf ((__v8sf)(__m256)SRC, (float const *)BASE, (__v8si)(__m256i)INDEX, (__v8sf)(__m256d)MASK, (int)SCALE)
#define _mm_i64gather_ps(BASE,INDEX,SCALE) (__m128) __builtin_ia32_gatherdiv4sf ((__v4sf) _mm_setzero_pd (), (float const *)BASE, (__v2di)(__m128i)INDEX, (__v4sf)_mm_set1_ps ( (float)(int) -1), (int)SCALE)
#define _mm_mask_i64gather_ps(SRC,BASE,INDEX,MASK,SCALE) (__m128) __builtin_ia32_gatherdiv4sf ((__v4sf)(__m128)SRC, (float const *)BASE, (__v2di)(__m128i)INDEX, (__v4sf)(__m128d)MASK, (int)SCALE)
#define _mm256_i64gather_ps(BASE,INDEX,SCALE) (__m128) __builtin_ia32_gatherdiv4sf256 ((__v4sf) _mm_setzero_ps (), (float const *)BASE, (__v4di)(__m256i)INDEX, (__v4sf)_mm_set1_ps( (float)(int) -1), (int)SCALE)
#define _mm256_mask_i64gather_ps(SRC,BASE,INDEX,MASK,SCALE) (__m128) __builtin_ia32_gatherdiv4sf256 ((__v4sf)(__m128)SRC, (float const *)BASE, (__v4di)(__m256i)INDEX, (__v4sf)(__m128)MASK, (int)SCALE)
#define _mm_i32gather_epi64(BASE,INDEX,SCALE) (__m128i) __builtin_ia32_gathersiv2di ((__v2di) _mm_setzero_si128 (), (long long const *)BASE, (__v4si)(__m128i)INDEX, (__v2di)_mm_set1_epi64x (-1), (int)SCALE)
#define _mm_mask_i32gather_epi64(SRC,BASE,INDEX,MASK,SCALE) (__m128i) __builtin_ia32_gathersiv2di ((__v2di)(__m128i)SRC, (long long const *)BASE, (__v4si)(__m128i)INDEX, (__v2di)(__m128i)MASK, (int)SCALE)
#define _mm256_i32gather_epi64(BASE,INDEX,SCALE) (__m256i) __builtin_ia32_gathersiv4di ((__v4di) _mm256_setzero_si256 (), (long long const *)BASE, (__v4si)(__m128i)INDEX, (__v4di)_mm256_set1_epi64x (-1), (int)SCALE)
#define _mm256_mask_i32gather_epi64(SRC,BASE,INDEX,MASK,SCALE) (__m256i) __builtin_ia32_gathersiv4di ((__v4di)(__m256i)SRC, (long long const *)BASE, (__v4si)(__m128i)INDEX, (__v4di)(__m256i)MASK, (int)SCALE)
#define _mm_i64gather_epi64(BASE,INDEX,SCALE) (__m128i) __builtin_ia32_gatherdiv2di ((__v2di) _mm_setzero_si128 (), (long long const *)BASE, (__v2di)(__m128i)INDEX, (__v2di)_mm_set1_epi64x (-1), (int)SCALE)
#define _mm_mask_i64gather_epi64(SRC,BASE,INDEX,MASK,SCALE) (__m128i) __builtin_ia32_gatherdiv2di ((__v2di)(__m128i)SRC, (long long const *)BASE, (__v2di)(__m128i)INDEX, (__v2di)(__m128i)MASK, (int)SCALE)
#define _mm256_i64gather_epi64(BASE,INDEX,SCALE) (__m256i) __builtin_ia32_gatherdiv4di ((__v4di) _mm256_setzero_si256 (), (long long const *)BASE, (__v4di)(__m256i)INDEX, (__v4di)_mm256_set1_epi64x (-1), (int)SCALE)
#define _mm256_mask_i64gather_epi64(SRC,BASE,INDEX,MASK,SCALE) (__m256i) __builtin_ia32_gatherdiv4di ((__v4di)(__m256i)SRC, (long long const *)BASE, (__v4di)(__m256i)INDEX, (__v4di)(__m256i)MASK, (int)SCALE)
#define _mm_i32gather_epi32(BASE,INDEX,SCALE) (__m128i) __builtin_ia32_gathersiv4si ((__v4si) _mm_setzero_si128 (), (int const *)BASE, (__v4si)(__m128i)INDEX, (__v4si)_mm_set1_epi32 (-1), (int)SCALE)
#define _mm_mask_i32gather_epi32(SRC,BASE,INDEX,MASK,SCALE) (__m128i) __builtin_ia32_gathersiv4si ((__v4si)(__m128i)SRC, (int const *)BASE, (__v4si)(__m128i)INDEX, (__v4si)(__m128i)MASK, (int)SCALE)
#define _mm256_i32gather_epi32(BASE,INDEX,SCALE) (__m256i) __builtin_ia32_gathersiv8si ((__v8si) _mm256_setzero_si256 (), (int const *)BASE, (__v8si)(__m256i)INDEX, (__v8si)_mm256_set1_epi32 (-1), (int)SCALE)
#define _mm256_mask_i32gather_epi32(SRC,BASE,INDEX,MASK,SCALE) (__m256i) __builtin_ia32_gathersiv8si ((__v8si)(__m256i)SRC, (int const *)BASE, (__v8si)(__m256i)INDEX, (__v8si)(__m256i)MASK, (int)SCALE)
#define _mm_i64gather_epi32(BASE,INDEX,SCALE) (__m128i) __builtin_ia32_gatherdiv4si ((__v4si) _mm_setzero_si128 (), (int const *)BASE, (__v2di)(__m128i)INDEX, (__v4si)_mm_set1_epi32 (-1), (int)SCALE)
#define _mm_mask_i64gather_epi32(SRC,BASE,INDEX,MASK,SCALE) (__m128i) __builtin_ia32_gatherdiv4si ((__v4si)(__m128i)SRC, (int const *)BASE, (__v2di)(__m128i)INDEX, (__v4si)(__m128i)MASK, (int)SCALE)
#define _mm256_i64gather_epi32(BASE,INDEX,SCALE) (__m128i) __builtin_ia32_gatherdiv4si256 ((__v4si) _mm_setzero_si128 (), (int const *)BASE, (__v4di)(__m256i)INDEX, (__v4si)_mm_set1_epi32(-1), (int)SCALE)
#define _mm256_mask_i64gather_epi32(SRC,BASE,INDEX,MASK,SCALE) (__m128i) __builtin_ia32_gatherdiv4si256 ((__v4si)(__m128i)SRC, (int const *)BASE, (__v4di)(__m256i)INDEX, (__v4si)(__m128i)MASK, (int)SCALE)
#undef __DISABLE_AVX2__
#pragma GCC pop_options
#define _AVX512FINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("avx512f")
#define __DISABLE_AVX512F__
typedef double __v8df __attribute__ ((__vector_size__ (64)));
typedef float __v16sf __attribute__ ((__vector_size__ (64)));
typedef long long __v8di __attribute__ ((__vector_size__ (64)));
typedef int __v16si __attribute__ ((__vector_size__ (64)));
typedef short __v32hi __attribute__ ((__vector_size__ (64)));
typedef char __v64qi __attribute__ ((__vector_size__ (64)));
typedef float __m512 __attribute__ ((__vector_size__ (64), __may_alias__));
typedef long long __m512i __attribute__ ((__vector_size__ (64), __may_alias__));
typedef double __m512d __attribute__ ((__vector_size__ (64), __may_alias__));
typedef unsigned char __mmask8;
typedef unsigned short __mmask16;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set_epi64 (long long __A, long long __B, long long __C,
long long __D, long long __E, long long __F,
long long __G, long long __H)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set_epi32 (int __A, int __B, int __C, int __D,
int __E, int __F, int __G, int __H,
int __I, int __J, int __K, int __L,
int __M, int __N, int __O, int __P)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set_pd (double __A, double __B, double __C, double __D,
double __E, double __F, double __G, double __H)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set_ps (float __A, float __B, float __C, float __D,
float __E, float __F, float __G, float __H,
float __I, float __J, float __K, float __L,
float __M, float __N, float __O, float __P)
;
#define _mm512_setr_epi64(e0,e1,e2,e3,e4,e5,e6,e7) _mm512_set_epi64(e7,e6,e5,e4,e3,e2,e1,e0)
#define _mm512_setr_epi32(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15) _mm512_set_epi32(e15,e14,e13,e12,e11,e10,e9,e8,e7,e6,e5,e4,e3,e2,e1,e0)
#define _mm512_setr_pd(e0,e1,e2,e3,e4,e5,e6,e7) _mm512_set_pd(e7,e6,e5,e4,e3,e2,e1,e0)
#define _mm512_setr_ps(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15) _mm512_set_ps(e15,e14,e13,e12,e11,e10,e9,e8,e7,e6,e5,e4,e3,e2,e1,e0)
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_undefined_ps (void)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_undefined_pd (void)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_undefined_si512 (void)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set1_epi8 (char __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set1_epi16 (short __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set1_pd (double __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set1_ps (float __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set4_epi32 (int __A, int __B, int __C, int __D)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set4_epi64 (long long __A, long long __B, long long __C,
long long __D)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set4_pd (double __A, double __B, double __C, double __D)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set4_ps (float __A, float __B, float __C, float __D)
;
#define _mm512_setr4_epi64(e0,e1,e2,e3) _mm512_set4_epi64(e3,e2,e1,e0)
#define _mm512_setr4_epi32(e0,e1,e2,e3) _mm512_set4_epi32(e3,e2,e1,e0)
#define _mm512_setr4_pd(e0,e1,e2,e3) _mm512_set4_pd(e3,e2,e1,e0)
#define _mm512_setr4_ps(e0,e1,e2,e3) _mm512_set4_ps(e3,e2,e1,e0)
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_setzero_ps (void)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_setzero_pd (void)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_setzero_epi32 (void)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_setzero_si512 (void)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mov_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mov_pd (__mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mov_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mov_ps (__mmask16 __U, __m512 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_load_pd (void const *__P)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_load_pd (__m512d __W, __mmask8 __U, void const *__P)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_load_pd (__mmask8 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_store_pd (void *__P, __m512d __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_store_pd (void *__P, __mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_load_ps (void const *__P)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_load_ps (__m512 __W, __mmask16 __U, void const *__P)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_load_ps (__mmask16 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_store_ps (void *__P, __m512 __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_store_ps (void *__P, __mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mov_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mov_epi64 (__mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_load_epi64 (void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_load_epi64 (__m512i __W, __mmask8 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_load_epi64 (__mmask8 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_store_epi64 (void *__P, __m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_store_epi64 (void *__P, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mov_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mov_epi32 (__mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_load_si512 (void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_load_epi32 (void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_load_epi32 (__m512i __W, __mmask16 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_load_epi32 (__mmask16 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_store_si512 (void *__P, __m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_store_epi32 (void *__P, __m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_store_epi32 (void *__P, __mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mullo_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mullo_epi32 (__mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mullo_epi32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sllv_epi32 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sllv_epi32 (__m512i __W, __mmask16 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sllv_epi32 (__mmask16 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_srav_epi32 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_srav_epi32 (__m512i __W, __mmask16 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_srav_epi32 (__mmask16 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_srlv_epi32 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_srlv_epi32 (__m512i __W, __mmask16 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_srlv_epi32 (__mmask16 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_add_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_add_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_add_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sub_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sub_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sub_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sllv_epi64 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sllv_epi64 (__m512i __W, __mmask8 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sllv_epi64 (__mmask8 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_srav_epi64 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_srav_epi64 (__m512i __W, __mmask8 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_srav_epi64 (__mmask8 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_srlv_epi64 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_srlv_epi64 (__m512i __W, __mmask8 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_srlv_epi64 (__mmask8 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_add_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_add_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_add_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mul_epi32 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mul_epi32 (__m512i __W, __mmask8 __M, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mul_epi32 (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sub_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sub_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sub_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mul_epu32 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mul_epu32 (__m512i __W, __mmask8 __M, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mul_epu32 (__mmask8 __M, __m512i __X, __m512i __Y)
;
#define _mm512_slli_epi64(X,C) ((__m512i) __builtin_ia32_psllqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_undefined_si512 (), (__mmask8)-1))
#define _mm512_mask_slli_epi64(W,U,X,C) ((__m512i) __builtin_ia32_psllqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_slli_epi64(U,X,C) ((__m512i) __builtin_ia32_psllqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_setzero_si512 (), (__mmask8)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sll_epi64 (__m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sll_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sll_epi64 (__mmask8 __U, __m512i __A, __m128i __B)
;
#define _mm512_srli_epi64(X,C) ((__m512i) __builtin_ia32_psrlqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_undefined_si512 (), (__mmask8)-1))
#define _mm512_mask_srli_epi64(W,U,X,C) ((__m512i) __builtin_ia32_psrlqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_srli_epi64(U,X,C) ((__m512i) __builtin_ia32_psrlqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_setzero_si512 (), (__mmask8)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_srl_epi64 (__m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_srl_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_srl_epi64 (__mmask8 __U, __m512i __A, __m128i __B)
;
#define _mm512_srai_epi64(X,C) ((__m512i) __builtin_ia32_psraqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_undefined_si512 (), (__mmask8)-1))
#define _mm512_mask_srai_epi64(W,U,X,C) ((__m512i) __builtin_ia32_psraqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_srai_epi64(U,X,C) ((__m512i) __builtin_ia32_psraqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_setzero_si512 (), (__mmask8)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sra_epi64 (__m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sra_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sra_epi64 (__mmask8 __U, __m512i __A, __m128i __B)
;
#define _mm512_slli_epi32(X,C) ((__m512i) __builtin_ia32_pslldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_undefined_si512 (), (__mmask16)-1))
#define _mm512_mask_slli_epi32(W,U,X,C) ((__m512i) __builtin_ia32_pslldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_slli_epi32(U,X,C) ((__m512i) __builtin_ia32_pslldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sll_epi32 (__m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sll_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sll_epi32 (__mmask16 __U, __m512i __A, __m128i __B)
;
#define _mm512_srli_epi32(X,C) ((__m512i) __builtin_ia32_psrldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_undefined_si512 (), (__mmask16)-1))
#define _mm512_mask_srli_epi32(W,U,X,C) ((__m512i) __builtin_ia32_psrldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_srli_epi32(U,X,C) ((__m512i) __builtin_ia32_psrldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_srl_epi32 (__m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_srl_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_srl_epi32 (__mmask16 __U, __m512i __A, __m128i __B)
;
#define _mm512_srai_epi32(X,C) ((__m512i) __builtin_ia32_psradi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_undefined_si512 (), (__mmask16)-1))
#define _mm512_mask_srai_epi32(W,U,X,C) ((__m512i) __builtin_ia32_psradi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_srai_epi32(U,X,C) ((__m512i) __builtin_ia32_psradi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sra_epi32 (__m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sra_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sra_epi32 (__mmask16 __U, __m512i __A, __m128i __B)
;
#define _mm_add_round_sd(A,B,C) (__m128d)__builtin_ia32_addsd_round(A, B, C)
#define _mm_add_round_ss(A,B,C) (__m128)__builtin_ia32_addss_round(A, B, C)
#define _mm_sub_round_sd(A,B,C) (__m128d)__builtin_ia32_subsd_round(A, B, C)
#define _mm_sub_round_ss(A,B,C) (__m128)__builtin_ia32_subss_round(A, B, C)
#define _mm512_ternarylogic_epi64(A,B,C,I) ((__m512i) __builtin_ia32_pternlogq512_mask ((__v8di)(__m512i)(A), (__v8di)(__m512i)(B), (__v8di)(__m512i)(C), (int)(I), (__mmask8)-1))
#define _mm512_mask_ternarylogic_epi64(A,U,B,C,I) ((__m512i) __builtin_ia32_pternlogq512_mask ((__v8di)(__m512i)(A), (__v8di)(__m512i)(B), (__v8di)(__m512i)(C), (int)(I), (__mmask8)(U)))
#define _mm512_maskz_ternarylogic_epi64(U,A,B,C,I) ((__m512i) __builtin_ia32_pternlogq512_maskz ((__v8di)(__m512i)(A), (__v8di)(__m512i)(B), (__v8di)(__m512i)(C), (int)(I), (__mmask8)(U)))
#define _mm512_ternarylogic_epi32(A,B,C,I) ((__m512i) __builtin_ia32_pternlogd512_mask ((__v16si)(__m512i)(A), (__v16si)(__m512i)(B), (__v16si)(__m512i)(C), (int)(I), (__mmask16)-1))
#define _mm512_mask_ternarylogic_epi32(A,U,B,C,I) ((__m512i) __builtin_ia32_pternlogd512_mask ((__v16si)(__m512i)(A), (__v16si)(__m512i)(B), (__v16si)(__m512i)(C), (int)(I), (__mmask16)(U)))
#define _mm512_maskz_ternarylogic_epi32(U,A,B,C,I) ((__m512i) __builtin_ia32_pternlogd512_maskz ((__v16si)(__m512i)(A), (__v16si)(__m512i)(B), (__v16si)(__m512i)(C), (int)(I), (__mmask16)(U)))
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rcp14_pd (__m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rcp14_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rcp14_pd (__mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rcp14_ps (__m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rcp14_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rcp14_ps (__mmask16 __U, __m512 __A)
;
extern __m128d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_rcp14_sd (__m128d __A, __m128d __B)
;
extern __m128
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_rcp14_ss (__m128 __A, __m128 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rsqrt14_pd (__m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rsqrt14_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rsqrt14_pd (__mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rsqrt14_ps (__m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rsqrt14_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rsqrt14_ps (__mmask16 __U, __m512 __A)
;
extern __m128d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_rsqrt14_sd (__m128d __A, __m128d __B)
;
extern __m128
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_rsqrt14_ss (__m128 __A, __m128 __B)
;
#define _mm512_sqrt_round_pd(A,C) (__m512d)__builtin_ia32_sqrtpd512_mask(A, (__v8df)_mm512_undefined_pd(), -1, C)
#define _mm512_mask_sqrt_round_pd(W,U,A,C) (__m512d)__builtin_ia32_sqrtpd512_mask(A, W, U, C)
#define _mm512_maskz_sqrt_round_pd(U,A,C) (__m512d)__builtin_ia32_sqrtpd512_mask(A, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_sqrt_round_ps(A,C) (__m512)__builtin_ia32_sqrtps512_mask(A, (__v16sf)_mm512_undefined_ps(), -1, C)
#define _mm512_mask_sqrt_round_ps(W,U,A,C) (__m512)__builtin_ia32_sqrtps512_mask(A, W, U, C)
#define _mm512_maskz_sqrt_round_ps(U,A,C) (__m512)__builtin_ia32_sqrtps512_mask(A, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm_sqrt_round_sd(A,B,C) (__m128d)__builtin_ia32_sqrtsd_round(A, B, C)
#define _mm_sqrt_round_ss(A,B,C) (__m128)__builtin_ia32_sqrtss_round(A, B, C)
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi8_epi32 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi8_epi32 (__m512i __W, __mmask16 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi8_epi32 (__mmask16 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi8_epi64 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi8_epi64 (__m512i __W, __mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi8_epi64 (__mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi16_epi32 (__m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi16_epi32 (__m512i __W, __mmask16 __U, __m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi16_epi32 (__mmask16 __U, __m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi16_epi64 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi16_epi64 (__m512i __W, __mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi16_epi64 (__mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi32_epi64 (__m256i __X)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi32_epi64 (__m512i __W, __mmask8 __U, __m256i __X)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi32_epi64 (__mmask8 __U, __m256i __X)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepu8_epi32 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepu8_epi32 (__m512i __W, __mmask16 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepu8_epi32 (__mmask16 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepu8_epi64 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepu8_epi64 (__m512i __W, __mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepu8_epi64 (__mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepu16_epi32 (__m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepu16_epi32 (__m512i __W, __mmask16 __U, __m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepu16_epi32 (__mmask16 __U, __m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepu16_epi64 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepu16_epi64 (__m512i __W, __mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepu16_epi64 (__mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepu32_epi64 (__m256i __X)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepu32_epi64 (__m512i __W, __mmask8 __U, __m256i __X)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepu32_epi64 (__mmask8 __U, __m256i __X)
;
#define _mm512_add_round_pd(A,B,C) (__m512d)__builtin_ia32_addpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, C)
#define _mm512_mask_add_round_pd(W,U,A,B,C) (__m512d)__builtin_ia32_addpd512_mask(A, B, W, U, C)
#define _mm512_maskz_add_round_pd(U,A,B,C) (__m512d)__builtin_ia32_addpd512_mask(A, B, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_add_round_ps(A,B,C) (__m512)__builtin_ia32_addps512_mask(A, B, (__v16sf)_mm512_undefined_ps(), -1, C)
#define _mm512_mask_add_round_ps(W,U,A,B,C) (__m512)__builtin_ia32_addps512_mask(A, B, W, U, C)
#define _mm512_maskz_add_round_ps(U,A,B,C) (__m512)__builtin_ia32_addps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm512_sub_round_pd(A,B,C) (__m512d)__builtin_ia32_subpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, C)
#define _mm512_mask_sub_round_pd(W,U,A,B,C) (__m512d)__builtin_ia32_subpd512_mask(A, B, W, U, C)
#define _mm512_maskz_sub_round_pd(U,A,B,C) (__m512d)__builtin_ia32_subpd512_mask(A, B, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_sub_round_ps(A,B,C) (__m512)__builtin_ia32_subps512_mask(A, B, (__v16sf)_mm512_undefined_ps(), -1, C)
#define _mm512_mask_sub_round_ps(W,U,A,B,C) (__m512)__builtin_ia32_subps512_mask(A, B, W, U, C)
#define _mm512_maskz_sub_round_ps(U,A,B,C) (__m512)__builtin_ia32_subps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm512_mul_round_pd(A,B,C) (__m512d)__builtin_ia32_mulpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, C)
#define _mm512_mask_mul_round_pd(W,U,A,B,C) (__m512d)__builtin_ia32_mulpd512_mask(A, B, W, U, C)
#define _mm512_maskz_mul_round_pd(U,A,B,C) (__m512d)__builtin_ia32_mulpd512_mask(A, B, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_mul_round_ps(A,B,C) (__m512)__builtin_ia32_mulps512_mask(A, B, (__v16sf)_mm512_undefined_ps(), -1, C)
#define _mm512_mask_mul_round_ps(W,U,A,B,C) (__m512)__builtin_ia32_mulps512_mask(A, B, W, U, C)
#define _mm512_maskz_mul_round_ps(U,A,B,C) (__m512)__builtin_ia32_mulps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm512_div_round_pd(A,B,C) (__m512d)__builtin_ia32_divpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, C)
#define _mm512_mask_div_round_pd(W,U,A,B,C) (__m512d)__builtin_ia32_divpd512_mask(A, B, W, U, C)
#define _mm512_maskz_div_round_pd(U,A,B,C) (__m512d)__builtin_ia32_divpd512_mask(A, B, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_div_round_ps(A,B,C) (__m512)__builtin_ia32_divps512_mask(A, B, (__v16sf)_mm512_undefined_ps(), -1, C)
#define _mm512_mask_div_round_ps(W,U,A,B,C) (__m512)__builtin_ia32_divps512_mask(A, B, W, U, C)
#define _mm512_maskz_div_round_ps(U,A,B,C) (__m512)__builtin_ia32_divps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm_mul_round_sd(A,B,C) (__m128d)__builtin_ia32_mulsd_round(A, B, C)
#define _mm_mul_round_ss(A,B,C) (__m128)__builtin_ia32_mulss_round(A, B, C)
#define _mm_div_round_sd(A,B,C) (__m128d)__builtin_ia32_divsd_round(A, B, C)
#define _mm_div_round_ss(A,B,C) (__m128)__builtin_ia32_divss_round(A, B, C)
#define _mm512_max_round_pd(A,B,R) (__m512d)__builtin_ia32_maxpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, R)
#define _mm512_mask_max_round_pd(W,U,A,B,R) (__m512d)__builtin_ia32_maxpd512_mask(A, B, W, U, R)
#define _mm512_maskz_max_round_pd(U,A,B,R) (__m512d)__builtin_ia32_maxpd512_mask(A, B, (__v8df)_mm512_setzero_pd(), U, R)
#define _mm512_max_round_ps(A,B,R) (__m512)__builtin_ia32_maxps512_mask(A, B, (__v16sf)_mm512_undefined_pd(), -1, R)
#define _mm512_mask_max_round_ps(W,U,A,B,R) (__m512)__builtin_ia32_maxps512_mask(A, B, W, U, R)
#define _mm512_maskz_max_round_ps(U,A,B,R) (__m512)__builtin_ia32_maxps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, R)
#define _mm512_min_round_pd(A,B,R) (__m512d)__builtin_ia32_minpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, R)
#define _mm512_mask_min_round_pd(W,U,A,B,R) (__m512d)__builtin_ia32_minpd512_mask(A, B, W, U, R)
#define _mm512_maskz_min_round_pd(U,A,B,R) (__m512d)__builtin_ia32_minpd512_mask(A, B, (__v8df)_mm512_setzero_pd(), U, R)
#define _mm512_min_round_ps(A,B,R) (__m512)__builtin_ia32_minps512_mask(A, B, (__v16sf)_mm512_undefined_ps(), -1, R)
#define _mm512_mask_min_round_ps(W,U,A,B,R) (__m512)__builtin_ia32_minps512_mask(A, B, W, U, R)
#define _mm512_maskz_min_round_ps(U,A,B,R) (__m512)__builtin_ia32_minps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, R)
#define _mm512_scalef_round_pd(A,B,C) (__m512d)__builtin_ia32_scalefpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, C)
#define _mm512_mask_scalef_round_pd(W,U,A,B,C) (__m512d)__builtin_ia32_scalefpd512_mask(A, B, W, U, C)
#define _mm512_maskz_scalef_round_pd(U,A,B,C) (__m512d)__builtin_ia32_scalefpd512_mask(A, B, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_scalef_round_ps(A,B,C) (__m512)__builtin_ia32_scalefps512_mask(A, B, (__v16sf)_mm512_undefined_ps(), -1, C)
#define _mm512_mask_scalef_round_ps(W,U,A,B,C) (__m512)__builtin_ia32_scalefps512_mask(A, B, W, U, C)
#define _mm512_maskz_scalef_round_ps(U,A,B,C) (__m512)__builtin_ia32_scalefps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm_scalef_round_sd(A,B,C) (__m128d)__builtin_ia32_scalefsd_round(A, B, C)
#define _mm_scalef_round_ss(A,B,C) (__m128)__builtin_ia32_scalefss_round(A, B, C)
#define _mm512_fmadd_round_pd(A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_mask(A, B, C, -1, R)
#define _mm512_mask_fmadd_round_pd(A,U,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_mask(A, B, C, U, R)
#define _mm512_mask3_fmadd_round_pd(A,B,C,U,R) (__m512d)__builtin_ia32_vfmaddpd512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmadd_round_pd(U,A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_maskz(A, B, C, U, R)
#define _mm512_fmadd_round_ps(A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_mask(A, B, C, -1, R)
#define _mm512_mask_fmadd_round_ps(A,U,B,C,R) (__m512)__builtin_ia32_vfmaddps512_mask(A, B, C, U, R)
#define _mm512_mask3_fmadd_round_ps(A,B,C,U,R) (__m512)__builtin_ia32_vfmaddps512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmadd_round_ps(U,A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_maskz(A, B, C, U, R)
#define _mm512_fmsub_round_pd(A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_mask(A, B, -(C), -1, R)
#define _mm512_mask_fmsub_round_pd(A,U,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_mask(A, B, -(C), U, R)
#define _mm512_mask3_fmsub_round_pd(A,B,C,U,R) (__m512d)__builtin_ia32_vfmsubpd512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmsub_round_pd(U,A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_maskz(A, B, -(C), U, R)
#define _mm512_fmsub_round_ps(A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_mask(A, B, -(C), -1, R)
#define _mm512_mask_fmsub_round_ps(A,U,B,C,R) (__m512)__builtin_ia32_vfmaddps512_mask(A, B, -(C), U, R)
#define _mm512_mask3_fmsub_round_ps(A,B,C,U,R) (__m512)__builtin_ia32_vfmsubps512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmsub_round_ps(U,A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_maskz(A, B, -(C), U, R)
#define _mm512_fmaddsub_round_pd(A,B,C,R) (__m512d)__builtin_ia32_vfmaddsubpd512_mask(A, B, C, -1, R)
#define _mm512_mask_fmaddsub_round_pd(A,U,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_mask(A, B, C, U, R)
#define _mm512_mask3_fmaddsub_round_pd(A,B,C,U,R) (__m512d)__builtin_ia32_vfmaddsubpd512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmaddsub_round_pd(U,A,B,C,R) (__m512d)__builtin_ia32_vfmaddsubpd512_maskz(A, B, C, U, R)
#define _mm512_fmaddsub_round_ps(A,B,C,R) (__m512)__builtin_ia32_vfmaddsubps512_mask(A, B, C, -1, R)
#define _mm512_mask_fmaddsub_round_ps(A,U,B,C,R) (__m512)__builtin_ia32_vfmaddsubps512_mask(A, B, C, U, R)
#define _mm512_mask3_fmaddsub_round_ps(A,B,C,U,R) (__m512)__builtin_ia32_vfmaddsubps512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmaddsub_round_ps(U,A,B,C,R) (__m512)__builtin_ia32_vfmaddsubps512_maskz(A, B, C, U, R)
#define _mm512_fmsubadd_round_pd(A,B,C,R) (__m512d)__builtin_ia32_vfmaddsubpd512_mask(A, B, -(C), -1, R)
#define _mm512_mask_fmsubadd_round_pd(A,U,B,C,R) (__m512d)__builtin_ia32_vfmaddsubpd512_mask(A, B, -(C), U, R)
#define _mm512_mask3_fmsubadd_round_pd(A,B,C,U,R) (__m512d)__builtin_ia32_vfmsubaddpd512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmsubadd_round_pd(U,A,B,C,R) (__m512d)__builtin_ia32_vfmaddsubpd512_maskz(A, B, -(C), U, R)
#define _mm512_fmsubadd_round_ps(A,B,C,R) (__m512)__builtin_ia32_vfmaddsubps512_mask(A, B, -(C), -1, R)
#define _mm512_mask_fmsubadd_round_ps(A,U,B,C,R) (__m512)__builtin_ia32_vfmaddsubps512_mask(A, B, -(C), U, R)
#define _mm512_mask3_fmsubadd_round_ps(A,B,C,U,R) (__m512)__builtin_ia32_vfmsubaddps512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmsubadd_round_ps(U,A,B,C,R) (__m512)__builtin_ia32_vfmaddsubps512_maskz(A, B, -(C), U, R)
#define _mm512_fnmadd_round_pd(A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_mask(-(A), B, C, -1, R)
#define _mm512_mask_fnmadd_round_pd(A,U,B,C,R) (__m512d)__builtin_ia32_vfnmaddpd512_mask(-(A), B, C, U, R)
#define _mm512_mask3_fnmadd_round_pd(A,B,C,U,R) (__m512d)__builtin_ia32_vfmaddpd512_mask3(-(A), B, C, U, R)
#define _mm512_maskz_fnmadd_round_pd(U,A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_maskz(-(A), B, C, U, R)
#define _mm512_fnmadd_round_ps(A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_mask(-(A), B, C, -1, R)
#define _mm512_mask_fnmadd_round_ps(A,U,B,C,R) (__m512)__builtin_ia32_vfnmaddps512_mask(-(A), B, C, U, R)
#define _mm512_mask3_fnmadd_round_ps(A,B,C,U,R) (__m512)__builtin_ia32_vfmaddps512_mask3(-(A), B, C, U, R)
#define _mm512_maskz_fnmadd_round_ps(U,A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_maskz(-(A), B, C, U, R)
#define _mm512_fnmsub_round_pd(A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_mask(-(A), B, -(C), -1, R)
#define _mm512_mask_fnmsub_round_pd(A,U,B,C,R) (__m512d)__builtin_ia32_vfnmsubpd512_mask(A, B, C, U, R)
#define _mm512_mask3_fnmsub_round_pd(A,B,C,U,R) (__m512d)__builtin_ia32_vfnmsubpd512_mask3(A, B, C, U, R)
#define _mm512_maskz_fnmsub_round_pd(U,A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_maskz(-(A), B, -(C), U, R)
#define _mm512_fnmsub_round_ps(A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_mask(-(A), B, -(C), -1, R)
#define _mm512_mask_fnmsub_round_ps(A,U,B,C,R) (__m512)__builtin_ia32_vfnmsubps512_mask(A, B, C, U, R)
#define _mm512_mask3_fnmsub_round_ps(A,B,C,U,R) (__m512)__builtin_ia32_vfnmsubps512_mask3(A, B, C, U, R)
#define _mm512_maskz_fnmsub_round_ps(U,A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_maskz(-(A), B, -(C), U, R)
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_abs_epi64 (__m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_abs_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_abs_epi64 (__mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_abs_epi32 (__m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_abs_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_abs_epi32 (__mmask16 __U, __m512i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcastss_ps (__m128 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcastss_ps (__m512 __O, __mmask16 __M, __m128 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcastss_ps (__mmask16 __M, __m128 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcastsd_pd (__m128d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcastsd_pd (__m512d __O, __mmask8 __M, __m128d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcastsd_pd (__mmask8 __M, __m128d __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcastd_epi32 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcastd_epi32 (__m512i __O, __mmask16 __M, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcastd_epi32 (__mmask16 __M, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set1_epi32 (int __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_set1_epi32 (__m512i __O, __mmask16 __M, int __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_set1_epi32 (__mmask16 __M, int __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcastq_epi64 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcastq_epi64 (__m512i __O, __mmask8 __M, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcastq_epi64 (__mmask8 __M, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set1_epi64 (long long __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_set1_epi64 (__m512i __O, __mmask8 __M, long long __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_set1_epi64 (__mmask8 __M, long long __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcast_f32x4 (__m128 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcast_f32x4 (__m512 __O, __mmask16 __M, __m128 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcast_f32x4 (__mmask16 __M, __m128 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcast_i32x4 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcast_i32x4 (__m512i __O, __mmask16 __M, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcast_i32x4 (__mmask16 __M, __m128i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcast_f64x4 (__m256d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcast_f64x4 (__m512d __O, __mmask8 __M, __m256d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcast_f64x4 (__mmask8 __M, __m256d __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcast_i64x4 (__m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcast_i64x4 (__m512i __O, __mmask8 __M, __m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcast_i64x4 (__mmask8 __M, __m256i __A)
;
typedef enum
{
_MM_PERM_AAAA = 0x00, _MM_PERM_AAAB = 0x01, _MM_PERM_AAAC = 0x02,
_MM_PERM_AAAD = 0x03, _MM_PERM_AABA = 0x04, _MM_PERM_AABB = 0x05,
_MM_PERM_AABC = 0x06, _MM_PERM_AABD = 0x07, _MM_PERM_AACA = 0x08,
_MM_PERM_AACB = 0x09, _MM_PERM_AACC = 0x0A, _MM_PERM_AACD = 0x0B,
_MM_PERM_AADA = 0x0C, _MM_PERM_AADB = 0x0D, _MM_PERM_AADC = 0x0E,
_MM_PERM_AADD = 0x0F, _MM_PERM_ABAA = 0x10, _MM_PERM_ABAB = 0x11,
_MM_PERM_ABAC = 0x12, _MM_PERM_ABAD = 0x13, _MM_PERM_ABBA = 0x14,
_MM_PERM_ABBB = 0x15, _MM_PERM_ABBC = 0x16, _MM_PERM_ABBD = 0x17,
_MM_PERM_ABCA = 0x18, _MM_PERM_ABCB = 0x19, _MM_PERM_ABCC = 0x1A,
_MM_PERM_ABCD = 0x1B, _MM_PERM_ABDA = 0x1C, _MM_PERM_ABDB = 0x1D,
_MM_PERM_ABDC = 0x1E, _MM_PERM_ABDD = 0x1F, _MM_PERM_ACAA = 0x20,
_MM_PERM_ACAB = 0x21, _MM_PERM_ACAC = 0x22, _MM_PERM_ACAD = 0x23,
_MM_PERM_ACBA = 0x24, _MM_PERM_ACBB = 0x25, _MM_PERM_ACBC = 0x26,
_MM_PERM_ACBD = 0x27, _MM_PERM_ACCA = 0x28, _MM_PERM_ACCB = 0x29,
_MM_PERM_ACCC = 0x2A, _MM_PERM_ACCD = 0x2B, _MM_PERM_ACDA = 0x2C,
_MM_PERM_ACDB = 0x2D, _MM_PERM_ACDC = 0x2E, _MM_PERM_ACDD = 0x2F,
_MM_PERM_ADAA = 0x30, _MM_PERM_ADAB = 0x31, _MM_PERM_ADAC = 0x32,
_MM_PERM_ADAD = 0x33, _MM_PERM_ADBA = 0x34, _MM_PERM_ADBB = 0x35,
_MM_PERM_ADBC = 0x36, _MM_PERM_ADBD = 0x37, _MM_PERM_ADCA = 0x38,
_MM_PERM_ADCB = 0x39, _MM_PERM_ADCC = 0x3A, _MM_PERM_ADCD = 0x3B,
_MM_PERM_ADDA = 0x3C, _MM_PERM_ADDB = 0x3D, _MM_PERM_ADDC = 0x3E,
_MM_PERM_ADDD = 0x3F, _MM_PERM_BAAA = 0x40, _MM_PERM_BAAB = 0x41,
_MM_PERM_BAAC = 0x42, _MM_PERM_BAAD = 0x43, _MM_PERM_BABA = 0x44,
_MM_PERM_BABB = 0x45, _MM_PERM_BABC = 0x46, _MM_PERM_BABD = 0x47,
_MM_PERM_BACA = 0x48, _MM_PERM_BACB = 0x49, _MM_PERM_BACC = 0x4A,
_MM_PERM_BACD = 0x4B, _MM_PERM_BADA = 0x4C, _MM_PERM_BADB = 0x4D,
_MM_PERM_BADC = 0x4E, _MM_PERM_BADD = 0x4F, _MM_PERM_BBAA = 0x50,
_MM_PERM_BBAB = 0x51, _MM_PERM_BBAC = 0x52, _MM_PERM_BBAD = 0x53,
_MM_PERM_BBBA = 0x54, _MM_PERM_BBBB = 0x55, _MM_PERM_BBBC = 0x56,
_MM_PERM_BBBD = 0x57, _MM_PERM_BBCA = 0x58, _MM_PERM_BBCB = 0x59,
_MM_PERM_BBCC = 0x5A, _MM_PERM_BBCD = 0x5B, _MM_PERM_BBDA = 0x5C,
_MM_PERM_BBDB = 0x5D, _MM_PERM_BBDC = 0x5E, _MM_PERM_BBDD = 0x5F,
_MM_PERM_BCAA = 0x60, _MM_PERM_BCAB = 0x61, _MM_PERM_BCAC = 0x62,
_MM_PERM_BCAD = 0x63, _MM_PERM_BCBA = 0x64, _MM_PERM_BCBB = 0x65,
_MM_PERM_BCBC = 0x66, _MM_PERM_BCBD = 0x67, _MM_PERM_BCCA = 0x68,
_MM_PERM_BCCB = 0x69, _MM_PERM_BCCC = 0x6A, _MM_PERM_BCCD = 0x6B,
_MM_PERM_BCDA = 0x6C, _MM_PERM_BCDB = 0x6D, _MM_PERM_BCDC = 0x6E,
_MM_PERM_BCDD = 0x6F, _MM_PERM_BDAA = 0x70, _MM_PERM_BDAB = 0x71,
_MM_PERM_BDAC = 0x72, _MM_PERM_BDAD = 0x73, _MM_PERM_BDBA = 0x74,
_MM_PERM_BDBB = 0x75, _MM_PERM_BDBC = 0x76, _MM_PERM_BDBD = 0x77,
_MM_PERM_BDCA = 0x78, _MM_PERM_BDCB = 0x79, _MM_PERM_BDCC = 0x7A,
_MM_PERM_BDCD = 0x7B, _MM_PERM_BDDA = 0x7C, _MM_PERM_BDDB = 0x7D,
_MM_PERM_BDDC = 0x7E, _MM_PERM_BDDD = 0x7F, _MM_PERM_CAAA = 0x80,
_MM_PERM_CAAB = 0x81, _MM_PERM_CAAC = 0x82, _MM_PERM_CAAD = 0x83,
_MM_PERM_CABA = 0x84, _MM_PERM_CABB = 0x85, _MM_PERM_CABC = 0x86,
_MM_PERM_CABD = 0x87, _MM_PERM_CACA = 0x88, _MM_PERM_CACB = 0x89,
_MM_PERM_CACC = 0x8A, _MM_PERM_CACD = 0x8B, _MM_PERM_CADA = 0x8C,
_MM_PERM_CADB = 0x8D, _MM_PERM_CADC = 0x8E, _MM_PERM_CADD = 0x8F,
_MM_PERM_CBAA = 0x90, _MM_PERM_CBAB = 0x91, _MM_PERM_CBAC = 0x92,
_MM_PERM_CBAD = 0x93, _MM_PERM_CBBA = 0x94, _MM_PERM_CBBB = 0x95,
_MM_PERM_CBBC = 0x96, _MM_PERM_CBBD = 0x97, _MM_PERM_CBCA = 0x98,
_MM_PERM_CBCB = 0x99, _MM_PERM_CBCC = 0x9A, _MM_PERM_CBCD = 0x9B,
_MM_PERM_CBDA = 0x9C, _MM_PERM_CBDB = 0x9D, _MM_PERM_CBDC = 0x9E,
_MM_PERM_CBDD = 0x9F, _MM_PERM_CCAA = 0xA0, _MM_PERM_CCAB = 0xA1,
_MM_PERM_CCAC = 0xA2, _MM_PERM_CCAD = 0xA3, _MM_PERM_CCBA = 0xA4,
_MM_PERM_CCBB = 0xA5, _MM_PERM_CCBC = 0xA6, _MM_PERM_CCBD = 0xA7,
_MM_PERM_CCCA = 0xA8, _MM_PERM_CCCB = 0xA9, _MM_PERM_CCCC = 0xAA,
_MM_PERM_CCCD = 0xAB, _MM_PERM_CCDA = 0xAC, _MM_PERM_CCDB = 0xAD,
_MM_PERM_CCDC = 0xAE, _MM_PERM_CCDD = 0xAF, _MM_PERM_CDAA = 0xB0,
_MM_PERM_CDAB = 0xB1, _MM_PERM_CDAC = 0xB2, _MM_PERM_CDAD = 0xB3,
_MM_PERM_CDBA = 0xB4, _MM_PERM_CDBB = 0xB5, _MM_PERM_CDBC = 0xB6,
_MM_PERM_CDBD = 0xB7, _MM_PERM_CDCA = 0xB8, _MM_PERM_CDCB = 0xB9,
_MM_PERM_CDCC = 0xBA, _MM_PERM_CDCD = 0xBB, _MM_PERM_CDDA = 0xBC,
_MM_PERM_CDDB = 0xBD, _MM_PERM_CDDC = 0xBE, _MM_PERM_CDDD = 0xBF,
_MM_PERM_DAAA = 0xC0, _MM_PERM_DAAB = 0xC1, _MM_PERM_DAAC = 0xC2,
_MM_PERM_DAAD = 0xC3, _MM_PERM_DABA = 0xC4, _MM_PERM_DABB = 0xC5,
_MM_PERM_DABC = 0xC6, _MM_PERM_DABD = 0xC7, _MM_PERM_DACA = 0xC8,
_MM_PERM_DACB = 0xC9, _MM_PERM_DACC = 0xCA, _MM_PERM_DACD = 0xCB,
_MM_PERM_DADA = 0xCC, _MM_PERM_DADB = 0xCD, _MM_PERM_DADC = 0xCE,
_MM_PERM_DADD = 0xCF, _MM_PERM_DBAA = 0xD0, _MM_PERM_DBAB = 0xD1,
_MM_PERM_DBAC = 0xD2, _MM_PERM_DBAD = 0xD3, _MM_PERM_DBBA = 0xD4,
_MM_PERM_DBBB = 0xD5, _MM_PERM_DBBC = 0xD6, _MM_PERM_DBBD = 0xD7,
_MM_PERM_DBCA = 0xD8, _MM_PERM_DBCB = 0xD9, _MM_PERM_DBCC = 0xDA,
_MM_PERM_DBCD = 0xDB, _MM_PERM_DBDA = 0xDC, _MM_PERM_DBDB = 0xDD,
_MM_PERM_DBDC = 0xDE, _MM_PERM_DBDD = 0xDF, _MM_PERM_DCAA = 0xE0,
_MM_PERM_DCAB = 0xE1, _MM_PERM_DCAC = 0xE2, _MM_PERM_DCAD = 0xE3,
_MM_PERM_DCBA = 0xE4, _MM_PERM_DCBB = 0xE5, _MM_PERM_DCBC = 0xE6,
_MM_PERM_DCBD = 0xE7, _MM_PERM_DCCA = 0xE8, _MM_PERM_DCCB = 0xE9,
_MM_PERM_DCCC = 0xEA, _MM_PERM_DCCD = 0xEB, _MM_PERM_DCDA = 0xEC,
_MM_PERM_DCDB = 0xED, _MM_PERM_DCDC = 0xEE, _MM_PERM_DCDD = 0xEF,
_MM_PERM_DDAA = 0xF0, _MM_PERM_DDAB = 0xF1, _MM_PERM_DDAC = 0xF2,
_MM_PERM_DDAD = 0xF3, _MM_PERM_DDBA = 0xF4, _MM_PERM_DDBB = 0xF5,
_MM_PERM_DDBC = 0xF6, _MM_PERM_DDBD = 0xF7, _MM_PERM_DDCA = 0xF8,
_MM_PERM_DDCB = 0xF9, _MM_PERM_DDCC = 0xFA, _MM_PERM_DDCD = 0xFB,
_MM_PERM_DDDA = 0xFC, _MM_PERM_DDDB = 0xFD, _MM_PERM_DDDC = 0xFE,
_MM_PERM_DDDD = 0xFF
} _MM_PERM_ENUM;
#define _mm512_shuffle_epi32(X,C) ((__m512i) __builtin_ia32_pshufd512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_undefined_si512 (), (__mmask16)-1))
#define _mm512_mask_shuffle_epi32(W,U,X,C) ((__m512i) __builtin_ia32_pshufd512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_shuffle_epi32(U,X,C) ((__m512i) __builtin_ia32_pshufd512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)(U)))
#define _mm512_shuffle_i64x2(X,Y,C) ((__m512i) __builtin_ia32_shuf_i64x2_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(C), (__v8di)(__m512i)_mm512_undefined_si512 (), (__mmask8)-1))
#define _mm512_mask_shuffle_i64x2(W,U,X,Y,C) ((__m512i) __builtin_ia32_shuf_i64x2_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(C), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_shuffle_i64x2(U,X,Y,C) ((__m512i) __builtin_ia32_shuf_i64x2_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(C), (__v8di)(__m512i)_mm512_setzero_si512 (), (__mmask8)(U)))
#define _mm512_shuffle_i32x4(X,Y,C) ((__m512i) __builtin_ia32_shuf_i32x4_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(C), (__v16si)(__m512i)_mm512_undefined_si512 (), (__mmask16)-1))
#define _mm512_mask_shuffle_i32x4(W,U,X,Y,C) ((__m512i) __builtin_ia32_shuf_i32x4_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_shuffle_i32x4(U,X,Y,C) ((__m512i) __builtin_ia32_shuf_i32x4_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)(U)))
#define _mm512_shuffle_f64x2(X,Y,C) ((__m512d) __builtin_ia32_shuf_f64x2_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(C), (__v8df)(__m512d)_mm512_undefined_pd(), (__mmask8)-1))
#define _mm512_mask_shuffle_f64x2(W,U,X,Y,C) ((__m512d) __builtin_ia32_shuf_f64x2_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(C), (__v8df)(__m512d)(W), (__mmask8)(U)))
#define _mm512_maskz_shuffle_f64x2(U,X,Y,C) ((__m512d) __builtin_ia32_shuf_f64x2_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(C), (__v8df)(__m512d)_mm512_setzero_pd(), (__mmask8)(U)))
#define _mm512_shuffle_f32x4(X,Y,C) ((__m512) __builtin_ia32_shuf_f32x4_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(C), (__v16sf)(__m512)_mm512_undefined_ps(), (__mmask16)-1))
#define _mm512_mask_shuffle_f32x4(W,U,X,Y,C) ((__m512) __builtin_ia32_shuf_f32x4_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(C), (__v16sf)(__m512)(W), (__mmask16)(U)))
#define _mm512_maskz_shuffle_f32x4(U,X,Y,C) ((__m512) __builtin_ia32_shuf_f32x4_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(C), (__v16sf)(__m512)_mm512_setzero_ps(), (__mmask16)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rolv_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rolv_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rolv_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rorv_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rorv_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rorv_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rolv_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rolv_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rolv_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rorv_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rorv_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rorv_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
#define _mm512_cvtt_roundpd_epi32(A,B) ((__m256i)__builtin_ia32_cvttpd2dq512_mask(A, (__v8si)_mm256_undefined_si256(), -1, B))
#define _mm512_mask_cvtt_roundpd_epi32(W,U,A,B) ((__m256i)__builtin_ia32_cvttpd2dq512_mask(A, (__v8si)(W), U, B))
#define _mm512_maskz_cvtt_roundpd_epi32(U,A,B) ((__m256i)__builtin_ia32_cvttpd2dq512_mask(A, (__v8si)_mm256_setzero_si256(), U, B))
#define _mm512_cvtt_roundpd_epu32(A,B) ((__m256i)__builtin_ia32_cvttpd2udq512_mask(A, (__v8si)_mm256_undefined_si256(), -1, B))
#define _mm512_mask_cvtt_roundpd_epu32(W,U,A,B) ((__m256i)__builtin_ia32_cvttpd2udq512_mask(A, (__v8si)(W), U, B))
#define _mm512_maskz_cvtt_roundpd_epu32(U,A,B) ((__m256i)__builtin_ia32_cvttpd2udq512_mask(A, (__v8si)_mm256_setzero_si256(), U, B))
#define _mm512_cvt_roundpd_epi32(A,B) ((__m256i)__builtin_ia32_cvtpd2dq512_mask(A, (__v8si)_mm256_undefined_si256(), -1, B))
#define _mm512_mask_cvt_roundpd_epi32(W,U,A,B) ((__m256i)__builtin_ia32_cvtpd2dq512_mask(A, (__v8si)(W), U, B))
#define _mm512_maskz_cvt_roundpd_epi32(U,A,B) ((__m256i)__builtin_ia32_cvtpd2dq512_mask(A, (__v8si)_mm256_setzero_si256(), U, B))
#define _mm512_cvt_roundpd_epu32(A,B) ((__m256i)__builtin_ia32_cvtpd2udq512_mask(A, (__v8si)_mm256_undefined_si256(), -1, B))
#define _mm512_mask_cvt_roundpd_epu32(W,U,A,B) ((__m256i)__builtin_ia32_cvtpd2udq512_mask(A, (__v8si)(W), U, B))
#define _mm512_maskz_cvt_roundpd_epu32(U,A,B) ((__m256i)__builtin_ia32_cvtpd2udq512_mask(A, (__v8si)_mm256_setzero_si256(), U, B))
#define _mm512_cvtt_roundps_epi32(A,B) ((__m512i)__builtin_ia32_cvttps2dq512_mask(A, (__v16si)_mm512_undefined_si512 (), -1, B))
#define _mm512_mask_cvtt_roundps_epi32(W,U,A,B) ((__m512i)__builtin_ia32_cvttps2dq512_mask(A, (__v16si)(W), U, B))
#define _mm512_maskz_cvtt_roundps_epi32(U,A,B) ((__m512i)__builtin_ia32_cvttps2dq512_mask(A, (__v16si)_mm512_setzero_si512 (), U, B))
#define _mm512_cvtt_roundps_epu32(A,B) ((__m512i)__builtin_ia32_cvttps2udq512_mask(A, (__v16si)_mm512_undefined_si512 (), -1, B))
#define _mm512_mask_cvtt_roundps_epu32(W,U,A,B) ((__m512i)__builtin_ia32_cvttps2udq512_mask(A, (__v16si)(W), U, B))
#define _mm512_maskz_cvtt_roundps_epu32(U,A,B) ((__m512i)__builtin_ia32_cvttps2udq512_mask(A, (__v16si)_mm512_setzero_si512 (), U, B))
#define _mm512_cvt_roundps_epi32(A,B) ((__m512i)__builtin_ia32_cvtps2dq512_mask(A, (__v16si)_mm512_undefined_si512 (), -1, B))
#define _mm512_mask_cvt_roundps_epi32(W,U,A,B) ((__m512i)__builtin_ia32_cvtps2dq512_mask(A, (__v16si)(W), U, B))
#define _mm512_maskz_cvt_roundps_epi32(U,A,B) ((__m512i)__builtin_ia32_cvtps2dq512_mask(A, (__v16si)_mm512_setzero_si512 (), U, B))
#define _mm512_cvt_roundps_epu32(A,B) ((__m512i)__builtin_ia32_cvtps2udq512_mask(A, (__v16si)_mm512_undefined_si512 (), -1, B))
#define _mm512_mask_cvt_roundps_epu32(W,U,A,B) ((__m512i)__builtin_ia32_cvtps2udq512_mask(A, (__v16si)(W), U, B))
#define _mm512_maskz_cvt_roundps_epu32(U,A,B) ((__m512i)__builtin_ia32_cvtps2udq512_mask(A, (__v16si)_mm512_setzero_si512 (), U, B))
extern __m128d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtu32_sd (__m128d __A, unsigned __B)
;
#define _mm_cvt_roundu64_sd(A,B,C) (__m128d)__builtin_ia32_cvtusi2sd64(A, B, C)
#define _mm_cvt_roundi64_sd(A,B,C) (__m128d)__builtin_ia32_cvtsi2sd64(A, B, C)
#define _mm_cvt_roundsi64_sd(A,B,C) (__m128d)__builtin_ia32_cvtsi2sd64(A, B, C)
#define _mm_cvt_roundu32_ss(A,B,C) (__m128)__builtin_ia32_cvtusi2ss32(A, B, C)
#define _mm_cvt_roundi32_ss(A,B,C) (__m128)__builtin_ia32_cvtsi2ss32(A, B, C)
#define _mm_cvt_roundsi32_ss(A,B,C) (__m128)__builtin_ia32_cvtsi2ss32(A, B, C)
#define _mm_cvt_roundu64_ss(A,B,C) (__m128)__builtin_ia32_cvtusi2ss64(A, B, C)
#define _mm_cvt_roundi64_ss(A,B,C) (__m128)__builtin_ia32_cvtsi2ss64(A, B, C)
#define _mm_cvt_roundsi64_ss(A,B,C) (__m128)__builtin_ia32_cvtsi2ss64(A, B, C)
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi32_epi8 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi32_storeu_epi8 (void * __P, __mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi32_epi8 (__m128i __O, __mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi32_epi8 (__mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtsepi32_epi8 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi32_storeu_epi8 (void * __P, __mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi32_epi8 (__m128i __O, __mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtsepi32_epi8 (__mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtusepi32_epi8 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi32_storeu_epi8 (void * __P, __mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi32_epi8 (__m128i __O, __mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtusepi32_epi8 (__mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi32_epi16 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi32_storeu_epi16 (void * __P, __mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi32_epi16 (__m256i __O, __mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi32_epi16 (__mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtsepi32_epi16 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi32_storeu_epi16 (void *__P, __mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi32_epi16 (__m256i __O, __mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtsepi32_epi16 (__mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtusepi32_epi16 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi32_storeu_epi16 (void *__P, __mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi32_epi16 (__m256i __O, __mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtusepi32_epi16 (__mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi64_epi32 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi64_storeu_epi32 (void* __P, __mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi64_epi32 (__m256i __O, __mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi64_epi32 (__mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtsepi64_epi32 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi64_storeu_epi32 (void *__P, __mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi64_epi32 (__m256i __O, __mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtsepi64_epi32 (__mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtusepi64_epi32 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi64_storeu_epi32 (void* __P, __mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi64_epi32 (__m256i __O, __mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtusepi64_epi32 (__mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi64_epi16 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi64_storeu_epi16 (void *__P, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi64_epi16 (__m128i __O, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi64_epi16 (__mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtsepi64_epi16 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi64_storeu_epi16 (void * __P, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi64_epi16 (__m128i __O, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtsepi64_epi16 (__mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtusepi64_epi16 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi64_storeu_epi16 (void *__P, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi64_epi16 (__m128i __O, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtusepi64_epi16 (__mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi64_epi8 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi64_storeu_epi8 (void * __P, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi64_epi8 (__m128i __O, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi64_epi8 (__mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtsepi64_epi8 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi64_storeu_epi8 (void * __P, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi64_epi8 (__m128i __O, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtsepi64_epi8 (__mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtusepi64_epi8 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi64_storeu_epi8 (void * __P, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi64_epi8 (__m128i __O, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtusepi64_epi8 (__mmask8 __M, __m512i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi32_pd (__m256i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi32_pd (__m512d __W, __mmask8 __U, __m256i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi32_pd (__mmask8 __U, __m256i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepu32_pd (__m256i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepu32_pd (__m512d __W, __mmask8 __U, __m256i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepu32_pd (__mmask8 __U, __m256i __A)
;
#define _mm512_cvt_roundepi32_ps(A,B) (__m512)__builtin_ia32_cvtdq2ps512_mask((__v16si)(A), (__v16sf)_mm512_undefined_ps(), -1, B)
#define _mm512_mask_cvt_roundepi32_ps(W,U,A,B) (__m512)__builtin_ia32_cvtdq2ps512_mask((__v16si)(A), W, U, B)
#define _mm512_maskz_cvt_roundepi32_ps(U,A,B) (__m512)__builtin_ia32_cvtdq2ps512_mask((__v16si)(A), (__v16sf)_mm512_setzero_ps(), U, B)
#define _mm512_cvt_roundepu32_ps(A,B) (__m512)__builtin_ia32_cvtudq2ps512_mask((__v16si)(A), (__v16sf)_mm512_undefined_ps(), -1, B)
#define _mm512_mask_cvt_roundepu32_ps(W,U,A,B) (__m512)__builtin_ia32_cvtudq2ps512_mask((__v16si)(A), W, U, B)
#define _mm512_maskz_cvt_roundepu32_ps(U,A,B) (__m512)__builtin_ia32_cvtudq2ps512_mask((__v16si)(A), (__v16sf)_mm512_setzero_ps(), U, B)
#define _mm512_extractf64x4_pd(X,C) ((__m256d) __builtin_ia32_extractf64x4_mask ((__v8df)(__m512d) (X), (int) (C), (__v4df)(__m256d)_mm256_undefined_pd(), (__mmask8)-1))
#define _mm512_mask_extractf64x4_pd(W,U,X,C) ((__m256d) __builtin_ia32_extractf64x4_mask ((__v8df)(__m512d) (X), (int) (C), (__v4df)(__m256d)(W), (__mmask8)(U)))
#define _mm512_maskz_extractf64x4_pd(U,X,C) ((__m256d) __builtin_ia32_extractf64x4_mask ((__v8df)(__m512d) (X), (int) (C), (__v4df)(__m256d)_mm256_setzero_pd(), (__mmask8)(U)))
#define _mm512_extractf32x4_ps(X,C) ((__m128) __builtin_ia32_extractf32x4_mask ((__v16sf)(__m512) (X), (int) (C), (__v4sf)(__m128)_mm_undefined_ps(), (__mmask8)-1))
#define _mm512_mask_extractf32x4_ps(W,U,X,C) ((__m128) __builtin_ia32_extractf32x4_mask ((__v16sf)(__m512) (X), (int) (C), (__v4sf)(__m128)(W), (__mmask8)(U)))
#define _mm512_maskz_extractf32x4_ps(U,X,C) ((__m128) __builtin_ia32_extractf32x4_mask ((__v16sf)(__m512) (X), (int) (C), (__v4sf)(__m128)_mm_setzero_ps(), (__mmask8)(U)))
#define _mm512_extracti64x4_epi64(X,C) ((__m256i) __builtin_ia32_extracti64x4_mask ((__v8di)(__m512i) (X), (int) (C), (__v4di)(__m256i)_mm256_undefined_si256 (), (__mmask8)-1))
#define _mm512_mask_extracti64x4_epi64(W,U,X,C) ((__m256i) __builtin_ia32_extracti64x4_mask ((__v8di)(__m512i) (X), (int) (C), (__v4di)(__m256i)(W), (__mmask8)(U)))
#define _mm512_maskz_extracti64x4_epi64(U,X,C) ((__m256i) __builtin_ia32_extracti64x4_mask ((__v8di)(__m512i) (X), (int) (C), (__v4di)(__m256i)_mm256_setzero_si256 (), (__mmask8)(U)))
#define _mm512_extracti32x4_epi32(X,C) ((__m128i) __builtin_ia32_extracti32x4_mask ((__v16si)(__m512i) (X), (int) (C), (__v4si)(__m128i)_mm_undefined_si128 (), (__mmask8)-1))
#define _mm512_mask_extracti32x4_epi32(W,U,X,C) ((__m128i) __builtin_ia32_extracti32x4_mask ((__v16si)(__m512i) (X), (int) (C), (__v4si)(__m128i)(W), (__mmask8)(U)))
#define _mm512_maskz_extracti32x4_epi32(U,X,C) ((__m128i) __builtin_ia32_extracti32x4_mask ((__v16si)(__m512i) (X), (int) (C), (__v4si)(__m128i)_mm_setzero_si128 (), (__mmask8)(U)))
#define _mm512_insertf32x4(X,Y,C) ((__m512) __builtin_ia32_insertf32x4_mask ((__v16sf)(__m512) (X), (__v4sf)(__m128) (Y), (int) (C), (__v16sf)(__m512) (X), (__mmask16)(-1)))
#define _mm512_inserti32x4(X,Y,C) ((__m512i) __builtin_ia32_inserti32x4_mask ((__v16si)(__m512i) (X), (__v4si)(__m128i) (Y), (int) (C), (__v16si)(__m512i) (X), (__mmask16)(-1)))
#define _mm512_insertf64x4(X,Y,C) ((__m512d) __builtin_ia32_insertf64x4_mask ((__v8df)(__m512d) (X), (__v4df)(__m256d) (Y), (int) (C), (__v8df)(__m512d)_mm512_undefined_pd(), (__mmask8)-1))
#define _mm512_mask_insertf64x4(W,U,X,Y,C) ((__m512d) __builtin_ia32_insertf64x4_mask ((__v8df)(__m512d) (X), (__v4df)(__m256d) (Y), (int) (C), (__v8df)(__m512d)(W), (__mmask8)(U)))
#define _mm512_maskz_insertf64x4(U,X,Y,C) ((__m512d) __builtin_ia32_insertf64x4_mask ((__v8df)(__m512d) (X), (__v4df)(__m256d) (Y), (int) (C), (__v8df)(__m512d)_mm512_setzero_pd(), (__mmask8)(U)))
#define _mm512_inserti64x4(X,Y,C) ((__m512i) __builtin_ia32_inserti64x4_mask ((__v8di)(__m512i) (X), (__v4di)(__m256i) (Y), (int) (C), (__v8di)(__m512i)_mm512_undefined_si512 (), (__mmask8)-1))
#define _mm512_mask_inserti64x4(W,U,X,Y,C) ((__m512i) __builtin_ia32_inserti64x4_mask ((__v8di)(__m512i) (X), (__v4di)(__m256i) (Y), (int) (C), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_inserti64x4(U,X,Y,C) ((__m512i) __builtin_ia32_inserti64x4_mask ((__v8di)(__m512i) (X), (__v4di)(__m256i) (Y), (int) (C), (__v8di)(__m512i)_mm512_setzero_si512 (), (__mmask8)(U)))
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_loadu_pd (void const *__P)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_loadu_pd (__m512d __W, __mmask8 __U, void const *__P)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_loadu_pd (__mmask8 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_storeu_pd (void *__P, __m512d __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_storeu_pd (void *__P, __mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_loadu_ps (void const *__P)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_loadu_ps (__m512 __W, __mmask16 __U, void const *__P)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_loadu_ps (__mmask16 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_storeu_ps (void *__P, __m512 __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_storeu_ps (void *__P, __mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_loadu_epi64 (__m512i __W, __mmask8 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_loadu_epi64 (__mmask8 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_storeu_epi64 (void *__P, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_loadu_si512 (void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_loadu_epi32 (__m512i __W, __mmask16 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_loadu_epi32 (__mmask16 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_storeu_si512 (void *__P, __m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_storeu_epi32 (void *__P, __mmask16 __U, __m512i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutevar_pd (__m512d __A, __m512i __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutevar_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512i __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutevar_pd (__mmask8 __U, __m512d __A, __m512i __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutevar_ps (__m512 __A, __m512i __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutevar_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512i __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutevar_ps (__mmask16 __U, __m512 __A, __m512i __C)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutex2var_epi64 (__m512i __A, __m512i __I, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutex2var_epi64 (__m512i __A, __mmask8 __U, __m512i __I,
__m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask2_permutex2var_epi64 (__m512i __A, __m512i __I,
__mmask8 __U, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutex2var_epi64 (__mmask8 __U, __m512i __A,
__m512i __I, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutex2var_epi32 (__m512i __A, __m512i __I, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutex2var_epi32 (__m512i __A, __mmask16 __U,
__m512i __I, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask2_permutex2var_epi32 (__m512i __A, __m512i __I,
__mmask16 __U, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutex2var_epi32 (__mmask16 __U, __m512i __A,
__m512i __I, __m512i __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutex2var_pd (__m512d __A, __m512i __I, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutex2var_pd (__m512d __A, __mmask8 __U, __m512i __I,
__m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask2_permutex2var_pd (__m512d __A, __m512i __I, __mmask8 __U,
__m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutex2var_pd (__mmask8 __U, __m512d __A, __m512i __I,
__m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutex2var_ps (__m512 __A, __m512i __I, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutex2var_ps (__m512 __A, __mmask16 __U, __m512i __I, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask2_permutex2var_ps (__m512 __A, __m512i __I, __mmask16 __U,
__m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutex2var_ps (__mmask16 __U, __m512 __A, __m512i __I,
__m512 __B)
;
#define _mm512_permute_pd(X,C) ((__m512d) __builtin_ia32_vpermilpd512_mask ((__v8df)(__m512d)(X), (int)(C), (__v8df)(__m512d)_mm512_undefined_pd(), (__mmask8)(-1)))
#define _mm512_mask_permute_pd(W,U,X,C) ((__m512d) __builtin_ia32_vpermilpd512_mask ((__v8df)(__m512d)(X), (int)(C), (__v8df)(__m512d)(W), (__mmask8)(U)))
#define _mm512_maskz_permute_pd(U,X,C) ((__m512d) __builtin_ia32_vpermilpd512_mask ((__v8df)(__m512d)(X), (int)(C), (__v8df)(__m512d)_mm512_setzero_pd(), (__mmask8)(U)))
#define _mm512_permute_ps(X,C) ((__m512) __builtin_ia32_vpermilps512_mask ((__v16sf)(__m512)(X), (int)(C), (__v16sf)(__m512)_mm512_undefined_ps(), (__mmask16)(-1)))
#define _mm512_mask_permute_ps(W,U,X,C) ((__m512) __builtin_ia32_vpermilps512_mask ((__v16sf)(__m512)(X), (int)(C), (__v16sf)(__m512)(W), (__mmask16)(U)))
#define _mm512_maskz_permute_ps(U,X,C) ((__m512) __builtin_ia32_vpermilps512_mask ((__v16sf)(__m512)(X), (int)(C), (__v16sf)(__m512)_mm512_setzero_ps(), (__mmask16)(U)))
#define _mm512_permutex_pd(X,M) ((__m512d) __builtin_ia32_permdf512_mask ((__v8df)(__m512d)(X), (int)(M), (__v8df)(__m512d)_mm512_undefined_pd(), (__mmask8)-1))
#define _mm512_mask_permutex_pd(W,U,X,M) ((__m512d) __builtin_ia32_permdf512_mask ((__v8df)(__m512d)(X), (int)(M), (__v8df)(__m512d)(W), (__mmask8)(U)))
#define _mm512_maskz_permutex_pd(U,X,M) ((__m512d) __builtin_ia32_permdf512_mask ((__v8df)(__m512d)(X), (int)(M), (__v8df)(__m512d)_mm512_setzero_pd(), (__mmask8)(U)))
#define _mm512_permutex_epi64(X,I) ((__m512i) __builtin_ia32_permdi512_mask ((__v8di)(__m512i)(X), (int)(I), (__v8di)(__m512i) (_mm512_undefined_si512 ()), (__mmask8)(-1)))
#define _mm512_maskz_permutex_epi64(M,X,I) ((__m512i) __builtin_ia32_permdi512_mask ((__v8di)(__m512i)(X), (int)(I), (__v8di)(__m512i) (_mm512_setzero_si512 ()), (__mmask8)(M)))
#define _mm512_mask_permutex_epi64(W,M,X,I) ((__m512i) __builtin_ia32_permdi512_mask ((__v8di)(__m512i)(X), (int)(I), (__v8di)(__m512i)(W), (__mmask8)(M)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutexvar_epi64 (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutexvar_epi64 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutexvar_epi64 (__m512i __W, __mmask8 __M, __m512i __X,
__m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutexvar_epi32 (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutexvar_epi32 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutexvar_epi32 (__m512i __W, __mmask16 __M, __m512i __X,
__m512i __Y)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutexvar_pd (__m512i __X, __m512d __Y)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutexvar_pd (__m512d __W, __mmask8 __U, __m512i __X, __m512d __Y)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutexvar_pd (__mmask8 __U, __m512i __X, __m512d __Y)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutexvar_ps (__m512i __X, __m512 __Y)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutexvar_ps (__m512 __W, __mmask16 __U, __m512i __X, __m512 __Y)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutexvar_ps (__mmask16 __U, __m512i __X, __m512 __Y)
;
#define _mm512_shuffle_pd(X,Y,C) ((__m512d)__builtin_ia32_shufpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(C), (__v8df)(__m512d)_mm512_undefined_pd(), (__mmask8)-1))
#define _mm512_mask_shuffle_pd(W,U,X,Y,C) ((__m512d)__builtin_ia32_shufpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(C), (__v8df)(__m512d)(W), (__mmask8)(U)))
#define _mm512_maskz_shuffle_pd(U,X,Y,C) ((__m512d)__builtin_ia32_shufpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(C), (__v8df)(__m512d)_mm512_setzero_pd(), (__mmask8)(U)))
#define _mm512_shuffle_ps(X,Y,C) ((__m512)__builtin_ia32_shufps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(C), (__v16sf)(__m512)_mm512_undefined_ps(), (__mmask16)-1))
#define _mm512_mask_shuffle_ps(W,U,X,Y,C) ((__m512)__builtin_ia32_shufps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(C), (__v16sf)(__m512)(W), (__mmask16)(U)))
#define _mm512_maskz_shuffle_ps(U,X,Y,C) ((__m512)__builtin_ia32_shufps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(C), (__v16sf)(__m512)_mm512_setzero_ps(), (__mmask16)(U)))
#define _mm512_fixupimm_round_pd(X,Y,Z,C,R) ((__m512d)__builtin_ia32_fixupimmpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (__v8di)(__m512i)(Z), (int)(C), (__mmask8)(-1), (R)))
#define _mm512_mask_fixupimm_round_pd(X,U,Y,Z,C,R) ((__m512d)__builtin_ia32_fixupimmpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (__v8di)(__m512i)(Z), (int)(C), (__mmask8)(U), (R)))
#define _mm512_maskz_fixupimm_round_pd(U,X,Y,Z,C,R) ((__m512d)__builtin_ia32_fixupimmpd512_maskz ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (__v8di)(__m512i)(Z), (int)(C), (__mmask8)(U), (R)))
#define _mm512_fixupimm_round_ps(X,Y,Z,C,R) ((__m512)__builtin_ia32_fixupimmps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(-1), (R)))
#define _mm512_mask_fixupimm_round_ps(X,U,Y,Z,C,R) ((__m512)__builtin_ia32_fixupimmps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(U), (R)))
#define _mm512_maskz_fixupimm_round_ps(U,X,Y,Z,C,R) ((__m512)__builtin_ia32_fixupimmps512_maskz ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(U), (R)))
#define _mm_fixupimm_round_sd(X,Y,Z,C,R) ((__m128d)__builtin_ia32_fixupimmsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(-1), (R)))
#define _mm_mask_fixupimm_round_sd(X,U,Y,Z,C,R) ((__m128d)__builtin_ia32_fixupimmsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(U), (R)))
#define _mm_maskz_fixupimm_round_sd(U,X,Y,Z,C,R) ((__m128d)__builtin_ia32_fixupimmsd_maskz ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(U), (R)))
#define _mm_fixupimm_round_ss(X,Y,Z,C,R) ((__m128)__builtin_ia32_fixupimmss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(-1), (R)))
#define _mm_mask_fixupimm_round_ss(X,U,Y,Z,C,R) ((__m128)__builtin_ia32_fixupimmss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(U), (R)))
#define _mm_maskz_fixupimm_round_ss(U,X,Y,Z,C,R) ((__m128)__builtin_ia32_fixupimmss_maskz ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(U), (R)))
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_movehdup_ps (__m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_movehdup_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_movehdup_ps (__mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_moveldup_ps (__m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_moveldup_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_moveldup_ps (__mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_or_si512 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_or_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_or_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_or_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_or_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_or_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_or_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_xor_si512 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_xor_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_xor_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_xor_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_xor_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_xor_epi64 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_xor_epi64 (__mmask16 __U, __m512i __A, __m512i __B)
;
#define _mm512_rol_epi32(A,B) ((__m512i)__builtin_ia32_prold512_mask ((__v16si)(__m512i)(A), (int)(B), (__v16si)_mm512_undefined_si512 (), (__mmask16)(-1)))
#define _mm512_mask_rol_epi32(W,U,A,B) ((__m512i)__builtin_ia32_prold512_mask ((__v16si)(__m512i)(A), (int)(B), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_rol_epi32(U,A,B) ((__m512i)__builtin_ia32_prold512_mask ((__v16si)(__m512i)(A), (int)(B), (__v16si)_mm512_setzero_si512 (), (__mmask16)(U)))
#define _mm512_ror_epi32(A,B) ((__m512i)__builtin_ia32_prord512_mask ((__v16si)(__m512i)(A), (int)(B), (__v16si)_mm512_undefined_si512 (), (__mmask16)(-1)))
#define _mm512_mask_ror_epi32(W,U,A,B) ((__m512i)__builtin_ia32_prord512_mask ((__v16si)(__m512i)(A), (int)(B), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_ror_epi32(U,A,B) ((__m512i)__builtin_ia32_prord512_mask ((__v16si)(__m512i)(A), (int)(B), (__v16si)_mm512_setzero_si512 (), (__mmask16)(U)))
#define _mm512_rol_epi64(A,B) ((__m512i)__builtin_ia32_prolq512_mask ((__v8di)(__m512i)(A), (int)(B), (__v8di)_mm512_undefined_si512 (), (__mmask8)(-1)))
#define _mm512_mask_rol_epi64(W,U,A,B) ((__m512i)__builtin_ia32_prolq512_mask ((__v8di)(__m512i)(A), (int)(B), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_rol_epi64(U,A,B) ((__m512i)__builtin_ia32_prolq512_mask ((__v8di)(__m512i)(A), (int)(B), (__v8di)_mm512_setzero_si512 (), (__mmask8)(U)))
#define _mm512_ror_epi64(A,B) ((__m512i)__builtin_ia32_prorq512_mask ((__v8di)(__m512i)(A), (int)(B), (__v8di)_mm512_undefined_si512 (), (__mmask8)(-1)))
#define _mm512_mask_ror_epi64(W,U,A,B) ((__m512i)__builtin_ia32_prorq512_mask ((__v8di)(__m512i)(A), (int)(B), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_ror_epi64(U,A,B) ((__m512i)__builtin_ia32_prorq512_mask ((__v8di)(__m512i)(A), (int)(B), (__v8di)_mm512_setzero_si512 (), (__mmask8)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_and_si512 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_and_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_and_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_and_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_and_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_and_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_and_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_andnot_si512 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_andnot_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_andnot_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_andnot_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_andnot_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_andnot_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_andnot_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_test_epi32_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_test_epi32_mask (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_test_epi64_mask (__m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_test_epi64_mask (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_testn_epi32_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_testn_epi32_mask (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_testn_epi64_mask (__m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_testn_epi64_mask (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpackhi_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpackhi_epi32 (__m512i __W, __mmask16 __U, __m512i __A,
__m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpackhi_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpackhi_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpackhi_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpackhi_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpacklo_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpacklo_epi32 (__m512i __W, __mmask16 __U, __m512i __A,
__m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpacklo_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpacklo_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpacklo_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpacklo_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
#define _mm_cvt_roundss_u64(A,B) ((unsigned long long)__builtin_ia32_vcvtss2usi64(A, B))
#define _mm_cvt_roundss_si64(A,B) ((long long)__builtin_ia32_vcvtss2si64(A, B))
#define _mm_cvt_roundss_i64(A,B) ((long long)__builtin_ia32_vcvtss2si64(A, B))
#define _mm_cvtt_roundss_u64(A,B) ((unsigned long long)__builtin_ia32_vcvttss2usi64(A, B))
#define _mm_cvtt_roundss_i64(A,B) ((long long)__builtin_ia32_vcvttss2si64(A, B))
#define _mm_cvtt_roundss_si64(A,B) ((long long)__builtin_ia32_vcvttss2si64(A, B))
#define _mm_cvt_roundss_u32(A,B) ((unsigned)__builtin_ia32_vcvtss2usi32(A, B))
#define _mm_cvt_roundss_si32(A,B) ((int)__builtin_ia32_vcvtss2si32(A, B))
#define _mm_cvt_roundss_i32(A,B) ((int)__builtin_ia32_vcvtss2si32(A, B))
#define _mm_cvtt_roundss_u32(A,B) ((unsigned)__builtin_ia32_vcvttss2usi32(A, B))
#define _mm_cvtt_roundss_si32(A,B) ((int)__builtin_ia32_vcvttss2si32(A, B))
#define _mm_cvtt_roundss_i32(A,B) ((int)__builtin_ia32_vcvttss2si32(A, B))
#define _mm_cvt_roundsd_u64(A,B) ((unsigned long long)__builtin_ia32_vcvtsd2usi64(A, B))
#define _mm_cvt_roundsd_si64(A,B) ((long long)__builtin_ia32_vcvtsd2si64(A, B))
#define _mm_cvt_roundsd_i64(A,B) ((long long)__builtin_ia32_vcvtsd2si64(A, B))
#define _mm_cvtt_roundsd_u64(A,B) ((unsigned long long)__builtin_ia32_vcvttsd2usi64(A, B))
#define _mm_cvtt_roundsd_si64(A,B) ((long long)__builtin_ia32_vcvttsd2si64(A, B))
#define _mm_cvtt_roundsd_i64(A,B) ((long long)__builtin_ia32_vcvttsd2si64(A, B))
#define _mm_cvt_roundsd_u32(A,B) ((unsigned)__builtin_ia32_vcvtsd2usi32(A, B))
#define _mm_cvt_roundsd_si32(A,B) ((int)__builtin_ia32_vcvtsd2si32(A, B))
#define _mm_cvt_roundsd_i32(A,B) ((int)__builtin_ia32_vcvtsd2si32(A, B))
#define _mm_cvtt_roundsd_u32(A,B) ((unsigned)__builtin_ia32_vcvttsd2usi32(A, B))
#define _mm_cvtt_roundsd_si32(A,B) ((int)__builtin_ia32_vcvttsd2si32(A, B))
#define _mm_cvtt_roundsd_i32(A,B) ((int)__builtin_ia32_vcvttsd2si32(A, B))
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_movedup_pd (__m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_movedup_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_movedup_pd (__mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpacklo_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpacklo_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpacklo_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpackhi_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpackhi_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpackhi_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpackhi_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpackhi_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpackhi_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
#define _mm512_cvt_roundps_pd(A,B) (__m512d)__builtin_ia32_cvtps2pd512_mask(A, (__v8df)_mm512_undefined_pd(), -1, B)
#define _mm512_mask_cvt_roundps_pd(W,U,A,B) (__m512d)__builtin_ia32_cvtps2pd512_mask(A, (__v8df)(W), U, B)
#define _mm512_maskz_cvt_roundps_pd(U,A,B) (__m512d)__builtin_ia32_cvtps2pd512_mask(A, (__v8df)_mm512_setzero_pd(), U, B)
#define _mm512_cvt_roundph_ps(A,B) (__m512)__builtin_ia32_vcvtph2ps512_mask((__v16hi)(A), (__v16sf)_mm512_undefined_ps(), -1, B)
#define _mm512_mask_cvt_roundph_ps(W,U,A,B) (__m512)__builtin_ia32_vcvtph2ps512_mask((__v16hi)(A), (__v16sf)(W), U, B)
#define _mm512_maskz_cvt_roundph_ps(U,A,B) (__m512)__builtin_ia32_vcvtph2ps512_mask((__v16hi)(A), (__v16sf)_mm512_setzero_ps(), U, B)
#define _mm512_cvt_roundps_ph(A,I) ((__m256i) __builtin_ia32_vcvtps2ph512_mask ((__v16sf)(__m512) A, (int) (I), (__v16hi)_mm256_undefined_si256 (), -1))
#define _mm512_cvtps_ph(A,I) ((__m256i) __builtin_ia32_vcvtps2ph512_mask ((__v16sf)(__m512) A, (int) (I), (__v16hi)_mm256_undefined_si256 (), -1))
#define _mm512_mask_cvt_roundps_ph(U,W,A,I) ((__m256i) __builtin_ia32_vcvtps2ph512_mask ((__v16sf)(__m512) A, (int) (I), (__v16hi)(__m256i)(U), (__mmask16) (W)))
#define _mm512_mask_cvtps_ph(U,W,A,I) ((__m256i) __builtin_ia32_vcvtps2ph512_mask ((__v16sf)(__m512) A, (int) (I), (__v16hi)(__m256i)(U), (__mmask16) (W)))
#define _mm512_maskz_cvt_roundps_ph(W,A,I) ((__m256i) __builtin_ia32_vcvtps2ph512_mask ((__v16sf)(__m512) A, (int) (I), (__v16hi)_mm256_setzero_si256 (), (__mmask16) (W)))
#define _mm512_maskz_cvtps_ph(W,A,I) ((__m256i) __builtin_ia32_vcvtps2ph512_mask ((__v16sf)(__m512) A, (int) (I), (__v16hi)_mm256_setzero_si256 (), (__mmask16) (W)))
#define _mm512_cvt_roundpd_ps(A,B) (__m256)__builtin_ia32_cvtpd2ps512_mask(A, (__v8sf)_mm256_undefined_ps(), -1, B)
#define _mm512_mask_cvt_roundpd_ps(W,U,A,B) (__m256)__builtin_ia32_cvtpd2ps512_mask(A, (__v8sf)(W), U, B)
#define _mm512_maskz_cvt_roundpd_ps(U,A,B) (__m256)__builtin_ia32_cvtpd2ps512_mask(A, (__v8sf)_mm256_setzero_ps(), U, B)
#define _mm_cvt_roundsd_ss(A,B,C) (__m128)__builtin_ia32_cvtsd2ss_round(A, B, C)
#define _mm_cvt_roundss_sd(A,B,C) (__m128d)__builtin_ia32_cvtss2sd_round(A, B, C)
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_stream_si512 (__m512i * __P, __m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_stream_ps (float *__P, __m512 __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_stream_pd (double *__P, __m512d __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_stream_load_si512 (void *__P)
;
typedef enum
{
_MM_MANT_NORM_1_2,
_MM_MANT_NORM_p5_2,
_MM_MANT_NORM_p5_1,
_MM_MANT_NORM_p75_1p5
} _MM_MANTISSA_NORM_ENUM;
typedef enum
{
_MM_MANT_SIGN_src,
_MM_MANT_SIGN_zero,
_MM_MANT_SIGN_nan
} _MM_MANTISSA_SIGN_ENUM;
#define _mm512_getmant_round_pd(X,B,C,R) ((__m512d)__builtin_ia32_getmantpd512_mask ((__v8df)(__m512d)(X), (int)(((C)<<2) | (B)), (__v8df)(__m512d)_mm512_undefined_pd(), (__mmask8)-1, (R)))
#define _mm512_mask_getmant_round_pd(W,U,X,B,C,R) ((__m512d)__builtin_ia32_getmantpd512_mask ((__v8df)(__m512d)(X), (int)(((C)<<2) | (B)), (__v8df)(__m512d)(W), (__mmask8)(U), (R)))
#define _mm512_maskz_getmant_round_pd(U,X,B,C,R) ((__m512d)__builtin_ia32_getmantpd512_mask ((__v8df)(__m512d)(X), (int)(((C)<<2) | (B)), (__v8df)(__m512d)_mm512_setzero_pd(), (__mmask8)(U), (R)))
#define _mm512_getmant_round_ps(X,B,C,R) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)(__m512)_mm512_undefined_ps(), (__mmask16)-1, (R)))
#define _mm512_mask_getmant_round_ps(W,U,X,B,C,R) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)(__m512)(W), (__mmask16)(U), (R)))
#define _mm512_maskz_getmant_round_ps(U,X,B,C,R) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)(__m512)_mm512_setzero_ps(), (__mmask16)(U), (R)))
#define _mm_getmant_round_sd(X,Y,C,D,R) ((__m128d)__builtin_ia32_getmantsd_round ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(((D)<<2) | (C)), (R)))
#define _mm_getmant_round_ss(X,Y,C,D,R) ((__m128)__builtin_ia32_getmantss_round ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(((D)<<2) | (C)), (R)))
#define _mm_getexp_round_ss(A,B,R) ((__m128)__builtin_ia32_getexpss128_round((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), R))
#define _mm_getexp_round_sd(A,B,R) ((__m128d)__builtin_ia32_getexpsd128_round((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), R))
#define _mm512_getexp_round_ps(A,R) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)_mm512_undefined_ps(), (__mmask16)-1, R))
#define _mm512_mask_getexp_round_ps(W,U,A,R) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)(__m512)(W), (__mmask16)(U), R))
#define _mm512_maskz_getexp_round_ps(U,A,R) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)_mm512_setzero_ps(), (__mmask16)(U), R))
#define _mm512_getexp_round_pd(A,R) ((__m512d)__builtin_ia32_getexppd512_mask((__v8df)(__m512d)(A), (__v8df)_mm512_undefined_pd(), (__mmask8)-1, R))
#define _mm512_mask_getexp_round_pd(W,U,A,R) ((__m512d)__builtin_ia32_getexppd512_mask((__v8df)(__m512d)(A), (__v8df)(__m512d)(W), (__mmask8)(U), R))
#define _mm512_maskz_getexp_round_pd(U,A,R) ((__m512d)__builtin_ia32_getexppd512_mask((__v8df)(__m512d)(A), (__v8df)_mm512_setzero_pd(), (__mmask8)(U), R))
#define _mm512_roundscale_round_ps(A,B,R) ((__m512) __builtin_ia32_rndscaleps_mask ((__v16sf)(__m512)(A), (int)(B), (__v16sf)_mm512_undefined_ps(), (__mmask16)(-1), R))
#define _mm512_mask_roundscale_round_ps(A,B,C,D,R) ((__m512) __builtin_ia32_rndscaleps_mask ((__v16sf)(__m512)(C), (int)(D), (__v16sf)(__m512)(A), (__mmask16)(B), R))
#define _mm512_maskz_roundscale_round_ps(A,B,C,R) ((__m512) __builtin_ia32_rndscaleps_mask ((__v16sf)(__m512)(B), (int)(C), (__v16sf)_mm512_setzero_ps(), (__mmask16)(A), R))
#define _mm512_roundscale_round_pd(A,B,R) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(A), (int)(B), (__v8df)_mm512_undefined_pd(), (__mmask8)(-1), R))
#define _mm512_mask_roundscale_round_pd(A,B,C,D,R) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(C), (int)(D), (__v8df)(__m512d)(A), (__mmask8)(B), R))
#define _mm512_maskz_roundscale_round_pd(A,B,C,R) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(B), (int)(C), (__v8df)_mm512_setzero_pd(), (__mmask8)(A), R))
#define _mm_roundscale_round_ss(A,B,C,R) ((__m128) __builtin_ia32_rndscaless_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), R))
#define _mm_roundscale_round_sd(A,B,C,R) ((__m128d) __builtin_ia32_rndscalesd_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), R))
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_floor_ps (__m512 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_floor_pd (__m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_ceil_ps (__m512 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_ceil_pd (__m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_floor_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_floor_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_ceil_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_ceil_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
#define _mm512_alignr_epi32(X,Y,C) ((__m512i)__builtin_ia32_alignd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(C), (__v16si)_mm512_undefined_si512 (), (__mmask16)-1))
#define _mm512_mask_alignr_epi32(W,U,X,Y,C) ((__m512i)__builtin_ia32_alignd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_alignr_epi32(U,X,Y,C) ((__m512i)__builtin_ia32_alignd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(C), (__v16si)_mm512_setzero_si512 (), (__mmask16)(U)))
#define _mm512_alignr_epi64(X,Y,C) ((__m512i)__builtin_ia32_alignq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(C), (__v8di)_mm512_undefined_si512 (), (__mmask8)-1))
#define _mm512_mask_alignr_epi64(W,U,X,Y,C) ((__m512i)__builtin_ia32_alignq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(C), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_alignr_epi64(U,X,Y,C) ((__m512i)__builtin_ia32_alignq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(C), (__v8di)_mm512_setzero_si512 (), (__mmask8)(U)))
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpeq_epi32_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpeq_epi32_mask (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpeq_epi64_mask (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpeq_epi64_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpgt_epi32_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpgt_epi32_mask (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpgt_epi64_mask (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpgt_epi64_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpge_epi32_mask (__m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpge_epi32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpge_epu32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpge_epu32_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpge_epi64_mask (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpge_epi64_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpge_epu64_mask (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpge_epu64_mask (__m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmple_epi32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmple_epi32_mask (__m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmple_epu32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmple_epu32_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmple_epi64_mask (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmple_epi64_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmple_epu64_mask (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmple_epu64_mask (__m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmplt_epi32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmplt_epi32_mask (__m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmplt_epu32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmplt_epu32_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmplt_epi64_mask (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmplt_epi64_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmplt_epu64_mask (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmplt_epu64_mask (__m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpneq_epi32_mask (__m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpneq_epi32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpneq_epu32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpneq_epu32_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpneq_epi64_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpneq_epi64_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpneq_epu64_mask (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpneq_epu64_mask (__m512i __X, __m512i __Y)
;
#define _MM_CMPINT_EQ 0x0
#define _MM_CMPINT_LT 0x1
#define _MM_CMPINT_LE 0x2
#define _MM_CMPINT_UNUSED 0x3
#define _MM_CMPINT_NE 0x4
#define _MM_CMPINT_NLT 0x5
#define _MM_CMPINT_GE 0x5
#define _MM_CMPINT_NLE 0x6
#define _MM_CMPINT_GT 0x6
#define _mm512_cmp_epi64_mask(X,Y,P) ((__mmask8) __builtin_ia32_cmpq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(P), (__mmask8)-1))
#define _mm512_cmp_epi32_mask(X,Y,P) ((__mmask8) __builtin_ia32_cmpd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(P), (__mmask16)-1))
#define _mm512_cmp_epu64_mask(X,Y,P) ((__mmask8) __builtin_ia32_ucmpq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(P), (__mmask8)-1))
#define _mm512_cmp_epu32_mask(X,Y,P) ((__mmask8) __builtin_ia32_ucmpd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(P), (__mmask16)-1))
#define _mm512_cmp_round_pd_mask(X,Y,P,R) ((__mmask8) __builtin_ia32_cmppd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(P), (__mmask8)-1, R))
#define _mm512_cmp_round_ps_mask(X,Y,P,R) ((__mmask16) __builtin_ia32_cmpps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(P), (__mmask16)-1, R))
#define _mm512_mask_cmp_epi64_mask(M,X,Y,P) ((__mmask8) __builtin_ia32_cmpq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(P), (__mmask8)M))
#define _mm512_mask_cmp_epi32_mask(M,X,Y,P) ((__mmask8) __builtin_ia32_cmpd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(P), (__mmask16)M))
#define _mm512_mask_cmp_epu64_mask(M,X,Y,P) ((__mmask8) __builtin_ia32_ucmpq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(P), (__mmask8)M))
#define _mm512_mask_cmp_epu32_mask(M,X,Y,P) ((__mmask8) __builtin_ia32_ucmpd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(P), (__mmask16)M))
#define _mm512_mask_cmp_round_pd_mask(M,X,Y,P,R) ((__mmask8) __builtin_ia32_cmppd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(P), (__mmask8)M, R))
#define _mm512_mask_cmp_round_ps_mask(M,X,Y,P,R) ((__mmask16) __builtin_ia32_cmpps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(P), (__mmask16)M, R))
#define _mm_cmp_round_sd_mask(X,Y,P,R) ((__mmask8) __builtin_ia32_cmpsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P), (__mmask8)-1, R))
#define _mm_mask_cmp_round_sd_mask(M,X,Y,P,R) ((__mmask8) __builtin_ia32_cmpsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P), (M), R))
#define _mm_cmp_round_ss_mask(X,Y,P,R) ((__mmask8) __builtin_ia32_cmpss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P), (__mmask8)-1, R))
#define _mm_mask_cmp_round_ss_mask(M,X,Y,P,R) ((__mmask8) __builtin_ia32_cmpss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P), (M), R))
#define _mm512_i32gather_ps(INDEX,ADDR,SCALE) (__m512) __builtin_ia32_gathersiv16sf ((__v16sf)_mm512_undefined_ps(), (float const *)ADDR, (__v16si)(__m512i)INDEX, (__mmask16)0xFFFF, (int)SCALE)
#define _mm512_mask_i32gather_ps(V1OLD,MASK,INDEX,ADDR,SCALE) (__m512) __builtin_ia32_gathersiv16sf ((__v16sf)(__m512)V1OLD, (float const *)ADDR, (__v16si)(__m512i)INDEX, (__mmask16)MASK, (int)SCALE)
#define _mm512_i32gather_pd(INDEX,ADDR,SCALE) (__m512d) __builtin_ia32_gathersiv8df ((__v8df)_mm512_undefined_pd(), (double const *)ADDR, (__v8si)(__m256i)INDEX, (__mmask8)0xFF, (int)SCALE)
#define _mm512_mask_i32gather_pd(V1OLD,MASK,INDEX,ADDR,SCALE) (__m512d) __builtin_ia32_gathersiv8df ((__v8df)(__m512d)V1OLD, (double const *)ADDR, (__v8si)(__m256i)INDEX, (__mmask8)MASK, (int)SCALE)
#define _mm512_i64gather_ps(INDEX,ADDR,SCALE) (__m256) __builtin_ia32_gatherdiv16sf ((__v8sf)_mm256_undefined_ps(), (float const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)0xFF, (int)SCALE)
#define _mm512_mask_i64gather_ps(V1OLD,MASK,INDEX,ADDR,SCALE) (__m256) __builtin_ia32_gatherdiv16sf ((__v8sf)(__m256)V1OLD, (float const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)MASK, (int)SCALE)
#define _mm512_i64gather_pd(INDEX,ADDR,SCALE) (__m512d) __builtin_ia32_gatherdiv8df ((__v8df)_mm512_undefined_pd(), (double const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)0xFF, (int)SCALE)
#define _mm512_mask_i64gather_pd(V1OLD,MASK,INDEX,ADDR,SCALE) (__m512d) __builtin_ia32_gatherdiv8df ((__v8df)(__m512d)V1OLD, (double const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)MASK, (int)SCALE)
#define _mm512_i32gather_epi32(INDEX,ADDR,SCALE) (__m512i) __builtin_ia32_gathersiv16si ((__v16si)_mm512_undefined_si512 (), (int const *)ADDR, (__v16si)(__m512i)INDEX, (__mmask16)0xFFFF, (int)SCALE)
#define _mm512_mask_i32gather_epi32(V1OLD,MASK,INDEX,ADDR,SCALE) (__m512i) __builtin_ia32_gathersiv16si ((__v16si)(__m512i)V1OLD, (int const *)ADDR, (__v16si)(__m512i)INDEX, (__mmask16)MASK, (int)SCALE)
#define _mm512_i32gather_epi64(INDEX,ADDR,SCALE) (__m512i) __builtin_ia32_gathersiv8di ((__v8di)_mm512_undefined_si512 (), (long long const *)ADDR, (__v8si)(__m256i)INDEX, (__mmask8)0xFF, (int)SCALE)
#define _mm512_mask_i32gather_epi64(V1OLD,MASK,INDEX,ADDR,SCALE) (__m512i) __builtin_ia32_gathersiv8di ((__v8di)(__m512i)V1OLD, (long long const *)ADDR, (__v8si)(__m256i)INDEX, (__mmask8)MASK, (int)SCALE)
#define _mm512_i64gather_epi32(INDEX,ADDR,SCALE) (__m256i) __builtin_ia32_gatherdiv16si ((__v8si)_mm256_undefined_si256(), (int const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)0xFF, (int)SCALE)
#define _mm512_mask_i64gather_epi32(V1OLD,MASK,INDEX,ADDR,SCALE) (__m256i) __builtin_ia32_gatherdiv16si ((__v8si)(__m256i)V1OLD, (int const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)MASK, (int)SCALE)
#define _mm512_i64gather_epi64(INDEX,ADDR,SCALE) (__m512i) __builtin_ia32_gatherdiv8di ((__v8di)_mm512_undefined_si512 (), (long long const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)0xFF, (int)SCALE)
#define _mm512_mask_i64gather_epi64(V1OLD,MASK,INDEX,ADDR,SCALE) (__m512i) __builtin_ia32_gatherdiv8di ((__v8di)(__m512i)V1OLD, (long long const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)MASK, (int)SCALE)
#define _mm512_i32scatter_ps(ADDR,INDEX,V1,SCALE) __builtin_ia32_scattersiv16sf ((float *)ADDR, (__mmask16)0xFFFF, (__v16si)(__m512i)INDEX, (__v16sf)(__m512)V1, (int)SCALE)
#define _mm512_mask_i32scatter_ps(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scattersiv16sf ((float *)ADDR, (__mmask16)MASK, (__v16si)(__m512i)INDEX, (__v16sf)(__m512)V1, (int)SCALE)
#define _mm512_i32scatter_pd(ADDR,INDEX,V1,SCALE) __builtin_ia32_scattersiv8df ((double *)ADDR, (__mmask8)0xFF, (__v8si)(__m256i)INDEX, (__v8df)(__m512d)V1, (int)SCALE)
#define _mm512_mask_i32scatter_pd(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scattersiv8df ((double *)ADDR, (__mmask8)MASK, (__v8si)(__m256i)INDEX, (__v8df)(__m512d)V1, (int)SCALE)
#define _mm512_i64scatter_ps(ADDR,INDEX,V1,SCALE) __builtin_ia32_scatterdiv16sf ((float *)ADDR, (__mmask8)0xFF, (__v8di)(__m512i)INDEX, (__v8sf)(__m256)V1, (int)SCALE)
#define _mm512_mask_i64scatter_ps(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scatterdiv16sf ((float *)ADDR, (__mmask16)MASK, (__v8di)(__m512i)INDEX, (__v8sf)(__m256)V1, (int)SCALE)
#define _mm512_i64scatter_pd(ADDR,INDEX,V1,SCALE) __builtin_ia32_scatterdiv8df ((double *)ADDR, (__mmask8)0xFF, (__v8di)(__m512i)INDEX, (__v8df)(__m512d)V1, (int)SCALE)
#define _mm512_mask_i64scatter_pd(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scatterdiv8df ((double *)ADDR, (__mmask8)MASK, (__v8di)(__m512i)INDEX, (__v8df)(__m512d)V1, (int)SCALE)
#define _mm512_i32scatter_epi32(ADDR,INDEX,V1,SCALE) __builtin_ia32_scattersiv16si ((int *)ADDR, (__mmask16)0xFFFF, (__v16si)(__m512i)INDEX, (__v16si)(__m512i)V1, (int)SCALE)
#define _mm512_mask_i32scatter_epi32(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scattersiv16si ((int *)ADDR, (__mmask16)MASK, (__v16si)(__m512i)INDEX, (__v16si)(__m512i)V1, (int)SCALE)
#define _mm512_i32scatter_epi64(ADDR,INDEX,V1,SCALE) __builtin_ia32_scattersiv8di ((long long *)ADDR, (__mmask8)0xFF, (__v8si)(__m256i)INDEX, (__v8di)(__m512i)V1, (int)SCALE)
#define _mm512_mask_i32scatter_epi64(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scattersiv8di ((long long *)ADDR, (__mmask8)MASK, (__v8si)(__m256i)INDEX, (__v8di)(__m512i)V1, (int)SCALE)
#define _mm512_i64scatter_epi32(ADDR,INDEX,V1,SCALE) __builtin_ia32_scatterdiv16si ((int *)ADDR, (__mmask8)0xFF, (__v8di)(__m512i)INDEX, (__v8si)(__m256i)V1, (int)SCALE)
#define _mm512_mask_i64scatter_epi32(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scatterdiv16si ((int *)ADDR, (__mmask8)MASK, (__v8di)(__m512i)INDEX, (__v8si)(__m256i)V1, (int)SCALE)
#define _mm512_i64scatter_epi64(ADDR,INDEX,V1,SCALE) __builtin_ia32_scatterdiv8di ((long long *)ADDR, (__mmask8)0xFF, (__v8di)(__m512i)INDEX, (__v8di)(__m512i)V1, (int)SCALE)
#define _mm512_mask_i64scatter_epi64(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scatterdiv8di ((long long *)ADDR, (__mmask8)MASK, (__v8di)(__m512i)INDEX, (__v8di)(__m512i)V1, (int)SCALE)
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compress_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_compress_pd (__mmask8 __U, __m512d __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compressstoreu_pd (void *__P, __mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compress_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_compress_ps (__mmask16 __U, __m512 __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compressstoreu_ps (void *__P, __mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compress_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_compress_epi64 (__mmask8 __U, __m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compressstoreu_epi64 (void *__P, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compress_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_compress_epi32 (__mmask16 __U, __m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compressstoreu_epi32 (void *__P, __mmask16 __U, __m512i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expand_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expand_pd (__mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expandloadu_pd (__m512d __W, __mmask8 __U, void const *__P)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expandloadu_pd (__mmask8 __U, void const *__P)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expand_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expand_ps (__mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expandloadu_ps (__m512 __W, __mmask16 __U, void const *__P)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expandloadu_ps (__mmask16 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expand_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expand_epi64 (__mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expandloadu_epi64 (__m512i __W, __mmask8 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expandloadu_epi64 (__mmask8 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expand_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expand_epi32 (__mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expandloadu_epi32 (__m512i __W, __mmask16 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expandloadu_epi32 (__mmask16 __U, void const *__P)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kand (__mmask16 __A, __mmask16 __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kandn (__mmask16 __A, __mmask16 __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kor (__mmask16 __A, __mmask16 __B)
;
extern int
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kortestz (__mmask16 __A, __mmask16 __B)
;
extern int
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kortestc (__mmask16 __A, __mmask16 __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kxnor (__mmask16 __A, __mmask16 __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kxor (__mmask16 __A, __mmask16 __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_knot (__mmask16 __A)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kunpackb (__mmask16 __A, __mmask16 __B)
;
#define _mm512_maskz_insertf32x4(A,X,Y,C) ((__m512) __builtin_ia32_insertf32x4_mask ((__v16sf)(__m512) (X), (__v4sf)(__m128) (Y), (int) (C), (__v16sf)_mm512_setzero_ps(), (__mmask8)(A)))
#define _mm512_maskz_inserti32x4(A,X,Y,C) ((__m512i) __builtin_ia32_inserti32x4_mask ((__v16si)(__m512i) (X), (__v4si)(__m128i) (Y), (int) (C), (__v16si)_mm512_setzero_si512 (), (__mmask8)(A)))
#define _mm512_mask_insertf32x4(A,B,X,Y,C) ((__m512) __builtin_ia32_insertf32x4_mask ((__v16sf)(__m512) (X), (__v4sf)(__m128) (Y), (int) (C), (__v16sf)(__m512) (A), (__mmask8)(B)))
#define _mm512_mask_inserti32x4(A,B,X,Y,C) ((__m512i) __builtin_ia32_inserti32x4_mask ((__v16si)(__m512i) (X), (__v4si)(__m128i) (Y), (int) (C), (__v16si)(__m512i) (A), (__mmask8)(B)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_max_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_max_epi64 (__mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_max_epi64 (__m512i __W, __mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_min_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_min_epi64 (__m512i __W, __mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_min_epi64 (__mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_max_epu64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_max_epu64 (__mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_max_epu64 (__m512i __W, __mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_min_epu64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_min_epu64 (__m512i __W, __mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_min_epu64 (__mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_max_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_max_epi32 (__mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_max_epi32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_min_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_min_epi32 (__mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_min_epi32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_max_epu32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_max_epu32 (__mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_max_epu32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_min_epu32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_min_epu32 (__mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_min_epu32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpacklo_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpacklo_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpacklo_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
#define _mm_max_round_sd(A,B,C) (__m128d)__builtin_ia32_addsd_round(A, B, C)
#define _mm_max_round_ss(A,B,C) (__m128)__builtin_ia32_addss_round(A, B, C)
#define _mm_min_round_sd(A,B,C) (__m128d)__builtin_ia32_subsd_round(A, B, C)
#define _mm_min_round_ss(A,B,C) (__m128)__builtin_ia32_subss_round(A, B, C)
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_blend_pd (__mmask8 __U, __m512d __A, __m512d __W)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_blend_ps (__mmask16 __U, __m512 __A, __m512 __W)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_blend_epi64 (__mmask8 __U, __m512i __A, __m512i __W)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_blend_epi32 (__mmask16 __U, __m512i __A, __m512i __W)
;
#define _mm_fmadd_round_sd(A,B,C,R) (__m128d)__builtin_ia32_vfmaddsd3_round(A, B, C, R)
#define _mm_fmadd_round_ss(A,B,C,R) (__m128)__builtin_ia32_vfmaddss3_round(A, B, C, R)
#define _mm_fmsub_round_sd(A,B,C,R) (__m128d)__builtin_ia32_vfmaddsd3_round(A, B, -(C), R)
#define _mm_fmsub_round_ss(A,B,C,R) (__m128)__builtin_ia32_vfmaddss3_round(A, B, -(C), R)
#define _mm_fnmadd_round_sd(A,B,C,R) (__m128d)__builtin_ia32_vfmaddsd3_round(A, -(B), C, R)
#define _mm_fnmadd_round_ss(A,B,C,R) (__m128)__builtin_ia32_vfmaddss3_round(A, -(B), C, R)
#define _mm_fnmsub_round_sd(A,B,C,R) (__m128d)__builtin_ia32_vfmaddsd3_round(A, -(B), -(C), R)
#define _mm_fnmsub_round_ss(A,B,C,R) (__m128)__builtin_ia32_vfmaddss3_round(A, -(B), -(C), R)
#define _mm_comi_round_ss(A,B,C,D) __builtin_ia32_vcomiss(A, B, C, D)
#define _mm_comi_round_sd(A,B,C,D) __builtin_ia32_vcomisd(A, B, C, D)
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sqrt_pd (__m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sqrt_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sqrt_pd (__mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sqrt_ps (__m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sqrt_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sqrt_ps (__mmask16 __U, __m512 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_add_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_add_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_add_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_add_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_add_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_add_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sub_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sub_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sub_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sub_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sub_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sub_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mul_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mul_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mul_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mul_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mul_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mul_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_div_pd (__m512d __M, __m512d __V)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_div_pd (__m512d __W, __mmask8 __U, __m512d __M, __m512d __V)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_div_pd (__mmask8 __U, __m512d __M, __m512d __V)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_div_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_div_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_div_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_max_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_max_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_max_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_max_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_max_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_max_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_min_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_min_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_min_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_min_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_min_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_min_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_scalef_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_scalef_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_scalef_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_scalef_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_scalef_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_scalef_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
extern __m128d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_scalef_sd (__m128d __A, __m128d __B)
;
extern __m128
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_scalef_ss (__m128 __A, __m128 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmadd_pd (__m512d __A, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmadd_pd (__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmadd_pd (__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmadd_pd (__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmadd_ps (__m512 __A, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmadd_ps (__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmadd_ps (__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmadd_ps (__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmsub_pd (__m512d __A, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmsub_pd (__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmsub_pd (__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmsub_pd (__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmsub_ps (__m512 __A, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmsub_ps (__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmsub_ps (__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmsub_ps (__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmaddsub_pd (__m512d __A, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmaddsub_pd (__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmaddsub_pd (__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmaddsub_pd (__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmaddsub_ps (__m512 __A, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmaddsub_ps (__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmaddsub_ps (__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmaddsub_ps (__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmsubadd_pd (__m512d __A, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmsubadd_pd (__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmsubadd_pd (__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmsubadd_pd (__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmsubadd_ps (__m512 __A, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmsubadd_ps (__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmsubadd_ps (__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmsubadd_ps (__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fnmadd_pd (__m512d __A, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fnmadd_pd (__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fnmadd_pd (__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fnmadd_pd (__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fnmadd_ps (__m512 __A, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fnmadd_ps (__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fnmadd_ps (__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fnmadd_ps (__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fnmsub_pd (__m512d __A, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fnmsub_pd (__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fnmsub_pd (__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fnmsub_pd (__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fnmsub_ps (__m512 __A, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fnmsub_ps (__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fnmsub_ps (__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fnmsub_ps (__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvttpd_epi32 (__m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvttpd_epi32 (__m256i __W, __mmask8 __U, __m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvttpd_epi32 (__mmask8 __U, __m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvttpd_epu32 (__m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvttpd_epu32 (__m256i __W, __mmask8 __U, __m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvttpd_epu32 (__mmask8 __U, __m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtpd_epi32 (__m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtpd_epi32 (__m256i __W, __mmask8 __U, __m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtpd_epi32 (__mmask8 __U, __m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtpd_epu32 (__m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtpd_epu32 (__m256i __W, __mmask8 __U, __m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtpd_epu32 (__mmask8 __U, __m512d __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvttps_epi32 (__m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvttps_epi32 (__m512i __W, __mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvttps_epi32 (__mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvttps_epu32 (__m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvttps_epu32 (__m512i __W, __mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvttps_epu32 (__mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtps_epi32 (__m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtps_epi32 (__m512i __W, __mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtps_epi32 (__mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtps_epu32 (__m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtps_epu32 (__m512i __W, __mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtps_epu32 (__mmask16 __U, __m512 __A)
;
extern __m128
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtu64_ss (__m128 __A, unsigned long long __B)
;
extern __m128d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtu64_sd (__m128d __A, unsigned long long __B)
;
extern __m128
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtu32_ss (__m128 __A, unsigned __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi32_ps (__m512i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi32_ps (__m512 __W, __mmask16 __U, __m512i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi32_ps (__mmask16 __U, __m512i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepu32_ps (__m512i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepu32_ps (__m512 __W, __mmask16 __U, __m512i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepu32_ps (__mmask16 __U, __m512i __A)
;
#define _mm512_fixupimm_pd(X,Y,Z,C) ((__m512d)__builtin_ia32_fixupimmpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (__v8di)(__m512i)(Z), (int)(C), (__mmask8)(-1), _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_fixupimm_pd(X,U,Y,Z,C) ((__m512d)__builtin_ia32_fixupimmpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (__v8di)(__m512i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_fixupimm_pd(U,X,Y,Z,C) ((__m512d)__builtin_ia32_fixupimmpd512_maskz ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (__v8di)(__m512i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_fixupimm_ps(X,Y,Z,C) ((__m512)__builtin_ia32_fixupimmps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(-1), _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_fixupimm_ps(X,U,Y,Z,C) ((__m512)__builtin_ia32_fixupimmps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_fixupimm_ps(U,X,Y,Z,C) ((__m512)__builtin_ia32_fixupimmps512_maskz ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm_fixupimm_sd(X,Y,Z,C) ((__m128d)__builtin_ia32_fixupimmsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(-1), _MM_FROUND_CUR_DIRECTION))
#define _mm_mask_fixupimm_sd(X,U,Y,Z,C) ((__m128d)__builtin_ia32_fixupimmsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm_maskz_fixupimm_sd(U,X,Y,Z,C) ((__m128d)__builtin_ia32_fixupimmsd_maskz ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm_fixupimm_ss(X,Y,Z,C) ((__m128)__builtin_ia32_fixupimmss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(-1), _MM_FROUND_CUR_DIRECTION))
#define _mm_mask_fixupimm_ss(X,U,Y,Z,C) ((__m128)__builtin_ia32_fixupimmss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm_maskz_fixupimm_ss(U,X,Y,Z,C) ((__m128)__builtin_ia32_fixupimmss_maskz ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
extern unsigned long long
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_u64 (__m128 __A)
;
extern unsigned long long
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_u64 (__m128 __A)
;
extern long long
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_i64 (__m128 __A)
;
extern unsigned
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_u32 (__m128 __A)
;
extern unsigned
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_u32 (__m128 __A)
;
extern int
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_i32 (__m128 __A)
;
extern unsigned long long
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_u64 (__m128d __A)
;
extern unsigned long long
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_u64 (__m128d __A)
;
extern long long
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_i64 (__m128d __A)
;
extern unsigned
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_u32 (__m128d __A)
;
extern unsigned
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_u32 (__m128d __A)
;
extern int
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_i32 (__m128d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtps_pd (__m256 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtps_pd (__m512d __W, __mmask8 __U, __m256 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtps_pd (__mmask8 __U, __m256 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtph_ps (__m256i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtph_ps (__m512 __W, __mmask16 __U, __m256i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtph_ps (__mmask16 __U, __m256i __A)
;
extern __m256
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtpd_ps (__m512d __A)
;
extern __m256
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtpd_ps (__m256 __W, __mmask8 __U, __m512d __A)
;
extern __m256
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtpd_ps (__mmask8 __U, __m512d __A)
;
#define _mm512_getmant_pd(X,B,C) ((__m512d)__builtin_ia32_getmantpd512_mask ((__v8df)(__m512d)(X), (int)(((C)<<2) | (B)), (__v8df)_mm512_undefined_pd(), (__mmask8)-1, _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_getmant_pd(W,U,X,B,C) ((__m512d)__builtin_ia32_getmantpd512_mask ((__v8df)(__m512d)(X), (int)(((C)<<2) | (B)), (__v8df)(__m512d)(W), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_getmant_pd(U,X,B,C) ((__m512d)__builtin_ia32_getmantpd512_mask ((__v8df)(__m512d)(X), (int)(((C)<<2) | (B)), (__v8df)_mm512_setzero_pd(), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_getmant_ps(X,B,C) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)_mm512_undefined_ps(), (__mmask16)-1, _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_getmant_ps(W,U,X,B,C) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)(__m512)(W), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_getmant_ps(U,X,B,C) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)_mm512_setzero_ps(), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm_getmant_sd(X,Y,C,D) ((__m128d)__builtin_ia32_getmantsd_round ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(((D)<<2) | (C)), _MM_FROUND_CUR_DIRECTION))
#define _mm_getmant_ss(X,Y,C,D) ((__m128)__builtin_ia32_getmantss_round ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(((D)<<2) | (C)), _MM_FROUND_CUR_DIRECTION))
#define _mm_getexp_ss(A,B) ((__m128)__builtin_ia32_getexpss128_mask((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), _MM_FROUND_CUR_DIRECTION))
#define _mm_getexp_sd(A,B) ((__m128d)__builtin_ia32_getexpsd128_mask((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), _MM_FROUND_CUR_DIRECTION))
#define _mm512_getexp_ps(A) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)_mm512_undefined_ps(), (__mmask16)-1, _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_getexp_ps(W,U,A) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)(__m512)(W), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_getexp_ps(U,A) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)_mm512_setzero_ps(), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_getexp_pd(A) ((__m512d)__builtin_ia32_getexppd512_mask((__v8df)(__m512d)(A), (__v8df)_mm512_undefined_pd(), (__mmask8)-1, _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_getexp_pd(W,U,A) ((__m512d)__builtin_ia32_getexppd512_mask((__v8df)(__m512d)(A), (__v8df)(__m512d)(W), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_getexp_pd(U,A) ((__m512d)__builtin_ia32_getexppd512_mask((__v8df)(__m512d)(A), (__v8df)_mm512_setzero_pd(), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_roundscale_ps(A,B) ((__m512) __builtin_ia32_rndscaleps_mask ((__v16sf)(__m512)(A), (int)(B), (__v16sf)_mm512_undefined_ps(), (__mmask16)(-1), _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_roundscale_ps(A,B,C,D) ((__m512) __builtin_ia32_rndscaleps_mask ((__v16sf)(__m512)(C), (int)(D), (__v16sf)(__m512)(A), (__mmask16)(B), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_roundscale_ps(A,B,C) ((__m512) __builtin_ia32_rndscaleps_mask ((__v16sf)(__m512)(B), (int)(C), (__v16sf)_mm512_setzero_ps(), (__mmask16)(A), _MM_FROUND_CUR_DIRECTION))
#define _mm512_roundscale_pd(A,B) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(A), (int)(B), (__v8df)_mm512_undefined_pd(), (__mmask8)(-1), _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_roundscale_pd(A,B,C,D) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(C), (int)(D), (__v8df)(__m512d)(A), (__mmask8)(B), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_roundscale_pd(A,B,C) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(B), (int)(C), (__v8df)_mm512_setzero_pd(), (__mmask8)(A), _MM_FROUND_CUR_DIRECTION))
#define _mm_roundscale_ss(A,B,C) ((__m128) __builtin_ia32_rndscaless_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), _MM_FROUND_CUR_DIRECTION))
#define _mm_roundscale_sd(A,B,C) ((__m128d) __builtin_ia32_rndscalesd_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), _MM_FROUND_CUR_DIRECTION))
#define _mm512_cmp_pd_mask(X,Y,P) ((__mmask8) __builtin_ia32_cmppd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(P), (__mmask8)-1,_MM_FROUND_CUR_DIRECTION))
#define _mm512_cmp_ps_mask(X,Y,P) ((__mmask16) __builtin_ia32_cmpps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(P), (__mmask16)-1,_MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_cmp_pd_mask(M,X,Y,P) ((__mmask8) __builtin_ia32_cmppd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(P), (__mmask8)M, _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_cmp_ps_mask(M,X,Y,P) ((__mmask16) __builtin_ia32_cmpps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(P), (__mmask16)M,_MM_FROUND_CUR_DIRECTION))
#define _mm_cmp_sd_mask(X,Y,P) ((__mmask8) __builtin_ia32_cmpsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P), (__mmask8)-1,_MM_FROUND_CUR_DIRECTION))
#define _mm_mask_cmp_sd_mask(M,X,Y,P) ((__mmask8) __builtin_ia32_cmpsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P), M,_MM_FROUND_CUR_DIRECTION))
#define _mm_cmp_ss_mask(X,Y,P) ((__mmask8) __builtin_ia32_cmpss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P), (__mmask8)-1,_MM_FROUND_CUR_DIRECTION))
#define _mm_mask_cmp_ss_mask(M,X,Y,P) ((__mmask8) __builtin_ia32_cmpss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P), M,_MM_FROUND_CUR_DIRECTION))
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kmov (__mmask16 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castpd_ps (__m512d __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castpd_si512 (__m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castps_pd (__m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castps_si512 (__m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castsi512_ps (__m512i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castsi512_pd (__m512i __A)
;
extern __m128d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castpd512_pd128 (__m512d __A)
;
extern __m128
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castps512_ps128 (__m512 __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castsi512_si128 (__m512i __A)
;
extern __m256d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castpd512_pd256 (__m512d __A)
;
extern __m256
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castps512_ps256 (__m512 __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castsi512_si256 (__m512i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castpd128_pd512 (__m128d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castps128_ps512 (__m128 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castsi128_si512 (__m128i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castpd256_pd512 (__m256d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castps256_ps512 (__m256 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castsi256_si512 (__m256i __A)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpeq_epu32_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpeq_epu32_mask (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpeq_epu64_mask (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpeq_epu64_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpgt_epu32_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpgt_epu32_mask (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpgt_epu64_mask (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpgt_epu64_mask (__m512i __A, __m512i __B)
;
#undef __DISABLE_AVX512F__
#pragma GCC pop_options
#define _AVX512ERINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("avx512er")
#define __DISABLE_AVX512ER__
typedef double __v8df __attribute__ ((__vector_size__ (64)));
typedef float __v16sf __attribute__ ((__vector_size__ (64)));
typedef float __m512 __attribute__ ((__vector_size__ (64), __may_alias__));
typedef double __m512d __attribute__ ((__vector_size__ (64), __may_alias__));
typedef unsigned char __mmask8;
typedef unsigned short __mmask16;
#define _mm512_exp2a23_round_pd(A,C) __builtin_ia32_exp2pd_mask(A, (__v8df)_mm512_setzero_pd(), -1, C)
#define _mm512_mask_exp2a23_round_pd(W,U,A,C) __builtin_ia32_exp2pd_mask(A, W, U, C)
#define _mm512_maskz_exp2a23_round_pd(U,A,C) __builtin_ia32_exp2pd_mask(A, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_exp2a23_round_ps(A,C) __builtin_ia32_exp2ps_mask(A, (__v16sf)_mm512_setzero_ps(), -1, C)
#define _mm512_mask_exp2a23_round_ps(W,U,A,C) __builtin_ia32_exp2ps_mask(A, W, U, C)
#define _mm512_maskz_exp2a23_round_ps(U,A,C) __builtin_ia32_exp2ps_mask(A, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm512_rcp28_round_pd(A,C) __builtin_ia32_rcp28pd_mask(A, (__v8df)_mm512_setzero_pd(), -1, C)
#define _mm512_mask_rcp28_round_pd(W,U,A,C) __builtin_ia32_rcp28pd_mask(A, W, U, C)
#define _mm512_maskz_rcp28_round_pd(U,A,C) __builtin_ia32_rcp28pd_mask(A, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_rcp28_round_ps(A,C) __builtin_ia32_rcp28ps_mask(A, (__v16sf)_mm512_setzero_ps(), -1, C)
#define _mm512_mask_rcp28_round_ps(W,U,A,C) __builtin_ia32_rcp28ps_mask(A, W, U, C)
#define _mm512_maskz_rcp28_round_ps(U,A,C) __builtin_ia32_rcp28ps_mask(A, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm512_rsqrt28_round_pd(A,C) __builtin_ia32_rsqrt28pd_mask(A, (__v8df)_mm512_setzero_pd(), -1, C)
#define _mm512_mask_rsqrt28_round_pd(W,U,A,C) __builtin_ia32_rsqrt28pd_mask(A, W, U, C)
#define _mm512_maskz_rsqrt28_round_pd(U,A,C) __builtin_ia32_rsqrt28pd_mask(A, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_rsqrt28_round_ps(A,C) __builtin_ia32_rsqrt28ps_mask(A, (__v16sf)_mm512_setzero_ps(), -1, C)
#define _mm512_mask_rsqrt28_round_ps(W,U,A,C) __builtin_ia32_rsqrt28ps_mask(A, W, U, C)
#define _mm512_maskz_rsqrt28_round_ps(U,A,C) __builtin_ia32_rsqrt28ps_mask(A, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm_rcp28_round_sd(A,B,R) __builtin_ia32_rcp28sd_round(A, B, R)
#define _mm_rcp28_round_ss(A,B,R) __builtin_ia32_rcp28ss_round(A, B, R)
#define _mm_rsqrt28_round_sd(A,B,R) __builtin_ia32_rsqrt28sd_round(A, B, R)
#define _mm_rsqrt28_round_ss(A,B,R) __builtin_ia32_rsqrt28ss_round(A, B, R)
#define _mm512_exp2a23_pd(A) _mm512_exp2a23_round_pd(A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_mask_exp2a23_pd(W,U,A) _mm512_mask_exp2a23_round_pd(W, U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_maskz_exp2a23_pd(U,A) _mm512_maskz_exp2a23_round_pd(U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_exp2a23_ps(A) _mm512_exp2a23_round_ps(A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_mask_exp2a23_ps(W,U,A) _mm512_mask_exp2a23_round_ps(W, U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_maskz_exp2a23_ps(U,A) _mm512_maskz_exp2a23_round_ps(U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_rcp28_pd(A) _mm512_rcp28_round_pd(A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_mask_rcp28_pd(W,U,A) _mm512_mask_rcp28_round_pd(W, U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_maskz_rcp28_pd(U,A) _mm512_maskz_rcp28_round_pd(U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_rcp28_ps(A) _mm512_rcp28_round_ps(A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_mask_rcp28_ps(W,U,A) _mm512_mask_rcp28_round_ps(W, U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_maskz_rcp28_ps(U,A) _mm512_maskz_rcp28_round_ps(U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_rsqrt28_pd(A) _mm512_rsqrt28_round_pd(A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_mask_rsqrt28_pd(W,U,A) _mm512_mask_rsqrt28_round_pd(W, U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_maskz_rsqrt28_pd(U,A) _mm512_maskz_rsqrt28_round_pd(U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_rsqrt28_ps(A) _mm512_rsqrt28_round_ps(A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_mask_rsqrt28_ps(W,U,A) _mm512_mask_rsqrt28_round_ps(W, U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_maskz_rsqrt28_ps(U,A) _mm512_maskz_rsqrt28_round_ps(U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm_rcp28_sd(A,B) __builtin_ia32_rcp28sd_round(B, A, _MM_FROUND_CUR_DIRECTION)
#define _mm_rcp28_ss(A,B) __builtin_ia32_rcp28ss_round(B, A, _MM_FROUND_CUR_DIRECTION)
#define _mm_rsqrt28_sd(A,B) __builtin_ia32_rsqrt28sd_round(B, A, _MM_FROUND_CUR_DIRECTION)
#define _mm_rsqrt28_ss(A,B) __builtin_ia32_rsqrt28ss_round(B, A, _MM_FROUND_CUR_DIRECTION)
#undef __DISABLE_AVX512ER__
#pragma GCC pop_options
#define _AVX512PFINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("avx512pf")
#define __DISABLE_AVX512PF__
typedef long long __v8di __attribute__ ((__vector_size__ (64)));
typedef int __v16si __attribute__ ((__vector_size__ (64)));
typedef long long __m512i __attribute__ ((__vector_size__ (64), __may_alias__));
typedef unsigned char __mmask8;
typedef unsigned short __mmask16;
#define _mm512_mask_prefetch_i32gather_pd(INDEX,MASK,ADDR,SCALE,HINT) __builtin_ia32_gatherpfdpd ((__mmask8)MASK, (__v8si)(__m256i)INDEX, (long long const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_mask_prefetch_i32gather_ps(INDEX,MASK,ADDR,SCALE,HINT) __builtin_ia32_gatherpfdps ((__mmask16)MASK, (__v16si)(__m512i)INDEX, (int const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_mask_prefetch_i64gather_pd(INDEX,MASK,ADDR,SCALE,HINT) __builtin_ia32_gatherpfqpd ((__mmask8)MASK, (__v8di)(__m512i)INDEX, (long long const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_mask_prefetch_i64gather_ps(INDEX,MASK,ADDR,SCALE,HINT) __builtin_ia32_gatherpfqps ((__mmask8)MASK, (__v8di)(__m512i)INDEX, (int const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_prefetch_i32scatter_pd(ADDR,INDEX,SCALE,HINT) __builtin_ia32_scatterpfdpd ((__mmask8)0xFF, (__v8si)(__m256i)INDEX, (long long const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_prefetch_i32scatter_ps(ADDR,INDEX,SCALE,HINT) __builtin_ia32_scatterpfdps ((__mmask16)0xFFFF, (__v16si)(__m512i)INDEX, (int const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_mask_prefetch_i32scatter_pd(ADDR,MASK,INDEX,SCALE,HINT) __builtin_ia32_scatterpfdpd ((__mmask8)MASK, (__v8si)(__m256i)INDEX, (long long const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_mask_prefetch_i32scatter_ps(ADDR,MASK,INDEX,SCALE,HINT) __builtin_ia32_scatterpfdps ((__mmask16)MASK, (__v16si)(__m512i)INDEX, (int const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_prefetch_i64scatter_pd(ADDR,INDEX,SCALE,HINT) __builtin_ia32_scatterpfqpd ((__mmask8)0xFF, (__v8di)(__m512i)INDEX, (long long const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_prefetch_i64scatter_ps(ADDR,INDEX,SCALE,HINT) __builtin_ia32_scatterpfqps ((__mmask8)0xFF, (__v8di)(__m512i)INDEX, (int const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_mask_prefetch_i64scatter_pd(ADDR,MASK,INDEX,SCALE,HINT) __builtin_ia32_scatterpfqpd ((__mmask8)MASK, (__v8di)(__m512i)INDEX, (long long const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_mask_prefetch_i64scatter_ps(ADDR,MASK,INDEX,SCALE,HINT) __builtin_ia32_scatterpfqps ((__mmask8)MASK, (__v8di)(__m512i)INDEX, (int const *)ADDR, (int)SCALE, (int)HINT)
#undef __DISABLE_AVX512PF__
#pragma GCC pop_options
#define _AVX512CDINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("avx512cd")
#define __DISABLE_AVX512CD__
typedef long long __v8di __attribute__ ((__vector_size__ (64)));
typedef int __v16si __attribute__ ((__vector_size__ (64)));
typedef long long __m512i __attribute__ ((__vector_size__ (64), __may_alias__));
typedef double __m512d __attribute__ ((__vector_size__ (64), __may_alias__));
typedef unsigned char __mmask8;
typedef unsigned short __mmask16;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_conflict_epi32 (__m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_conflict_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_conflict_epi32 (__mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_conflict_epi64 (__m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_conflict_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_conflict_epi64 (__mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_lzcnt_epi64 (__m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_lzcnt_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_lzcnt_epi64 (__mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_lzcnt_epi32 (__m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_lzcnt_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_lzcnt_epi32 (__mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcastmb_epi64 (__mmask8 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcastmw_epi32 (__mmask16 __A)
;
#undef __DISABLE_AVX512CD__
#pragma GCC pop_options
#define _SHAINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("sha")
#define __DISABLE_SHA__
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha1msg1_epu32 (__m128i __A, __m128i __B)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha1msg2_epu32 (__m128i __A, __m128i __B)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha1nexte_epu32 (__m128i __A, __m128i __B)
;
#define _mm_sha1rnds4_epu32(A,B,I) ((__m128i) __builtin_ia32_sha1rnds4 ((__v4si)(__m128i)A, (__v4si)(__m128i)B, (int)I))
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha256msg1_epu32 (__m128i __A, __m128i __B)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha256msg2_epu32 (__m128i __A, __m128i __B)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha256rnds2_epu32 (__m128i __A, __m128i __B, __m128i __C)
;
#undef __DISABLE_SHA__
#pragma GCC pop_options
#define _LZCNTINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("lzcnt")
#define __DISABLE_LZCNT__
extern unsigned short __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__lzcnt16 (unsigned short __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__lzcnt32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_lzcnt_u32 (unsigned int __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__lzcnt64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_lzcnt_u64 (unsigned long long __X)
;
#undef __DISABLE_LZCNT__
#pragma GCC pop_options
#define _BMIINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("bmi")
#define __DISABLE_BMI__
extern unsigned short __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__tzcnt_u16 (unsigned short __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__andn_u32 (unsigned int __X, unsigned int __Y)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bextr_u32 (unsigned int __X, unsigned int __Y)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_bextr_u32 (unsigned int __X, unsigned int __Y, unsigned __Z)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsi_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_blsi_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsmsk_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_blsmsk_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsr_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_blsr_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__tzcnt_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_tzcnt_u32 (unsigned int __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__andn_u64 (unsigned long long __X, unsigned long long __Y)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bextr_u64 (unsigned long long __X, unsigned long long __Y)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_bextr_u64 (unsigned long long __X, unsigned int __Y, unsigned int __Z)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsi_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_blsi_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsmsk_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_blsmsk_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsr_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_blsr_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__tzcnt_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_tzcnt_u64 (unsigned long long __X)
;
#undef __DISABLE_BMI__
#pragma GCC pop_options
#define _BMI2INTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("bmi2")
#define __DISABLE_BMI2__
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_bzhi_u32 (unsigned int __X, unsigned int __Y)
;
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_pdep_u32 (unsigned int __X, unsigned int __Y)
;
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_pext_u32 (unsigned int __X, unsigned int __Y)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_bzhi_u64 (unsigned long long __X, unsigned long long __Y)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_pdep_u64 (unsigned long long __X, unsigned long long __Y)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_pext_u64 (unsigned long long __X, unsigned long long __Y)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mulx_u64 (unsigned long long __X, unsigned long long __Y,
unsigned long long *__P)
;
#undef __DISABLE_BMI2__
#pragma GCC pop_options
#define _FMAINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("fma")
#define __DISABLE_FMA__
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmadd_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m256d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmadd_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmadd_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m256
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmadd_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmadd_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmadd_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmsub_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m256d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmsub_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmsub_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m256
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmsub_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmsub_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmsub_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmadd_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m256d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fnmadd_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmadd_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m256
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fnmadd_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmadd_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmadd_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmsub_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m256d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fnmsub_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmsub_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m256
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fnmsub_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmsub_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmsub_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmaddsub_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m256d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmaddsub_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmaddsub_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m256
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmaddsub_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmsubadd_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m256d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmsubadd_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmsubadd_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m256
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmsubadd_ps (__m256 __A, __m256 __B, __m256 __C)
;
#undef __DISABLE_FMA__
#pragma GCC pop_options
#define _F16CINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("f16c")
#define __DISABLE_F16C__
extern float __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_cvtsh_ss (unsigned short __S)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtph_ps (__m128i __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtph_ps (__m128i __A)
;
#define _cvtss_sh(__F,__I) (__extension__ ({ __v4sf __A = __extension__ (__v4sf){ __F, 0, 0, 0 }; __v8hi __H = __builtin_ia32_vcvtps2ph (__A, __I); (unsigned short) __builtin_ia32_vec_ext_v8hi (__H, 0); }))
#define _mm_cvtps_ph(A,I) ((__m128i) __builtin_ia32_vcvtps2ph ((__v4sf)(__m128) A, (int) (I)))
#define _mm256_cvtps_ph(A,I) ((__m128i) __builtin_ia32_vcvtps2ph256 ((__v8sf)(__m256) A, (int) (I)))
#undef __DISABLE_F16C__
#pragma GCC pop_options
#define _RTMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("rtm")
#define __DISABLE_RTM__
#define _XBEGIN_STARTED (~0u)
#define _XABORT_EXPLICIT (1 << 0)
#define _XABORT_RETRY (1 << 1)
#define _XABORT_CONFLICT (1 << 2)
#define _XABORT_CAPACITY (1 << 3)
#define _XABORT_DEBUG (1 << 4)
#define _XABORT_NESTED (1 << 5)
#define _XABORT_CODE(x) (((x) >> 24) & 0xFF)
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xbegin (void)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xend (void)
;
#define _xabort(N) __builtin_ia32_xabort (N)
#undef __DISABLE_RTM__
#pragma GCC pop_options
#define _XTESTINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("rtm")
#define __DISABLE_RTM__
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xtest (void)
;
#undef __DISABLE_RTM__
#pragma GCC pop_options
#pragma GCC push_options
#pragma GCC target("rdrnd")
#define __DISABLE_RDRND__
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_rdrand16_step (unsigned short *__P)
;
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_rdrand32_step (unsigned int *__P)
;
#undef __DISABLE_RDRND__
#pragma GCC pop_options
#pragma GCC push_options
#pragma GCC target("fsgsbase")
#define __DISABLE_FSGSBASE__
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_readfsbase_u32 (void)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_readfsbase_u64 (void)
;
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_readgsbase_u32 (void)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_readgsbase_u64 (void)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_writefsbase_u32 (unsigned int __B)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_writefsbase_u64 (unsigned long long __B)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_writegsbase_u32 (unsigned int __B)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_writegsbase_u64 (unsigned long long __B)
;
#undef __DISABLE_FSGSBASE__
#pragma GCC pop_options
#pragma GCC push_options
#pragma GCC target("rdrnd")
#define __DISABLE_RDRND__
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_rdrand64_step (unsigned long long *__P)
;
#undef __DISABLE_RDRND__
#pragma GCC pop_options
#define _MM3DNOW_H_INCLUDED
#define _PRFCHWINTRIN_H_INCLUDED
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_prefetchw (void *__P)
;
#pragma GCC push_options
#pragma GCC target("3dnow")
#define __DISABLE_3dNOW__
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_femms (void)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pavgusb (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pf2id (__m64 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfacc (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfadd (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfcmpeq (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfcmpge (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfcmpgt (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfmax (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfmin (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfmul (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfrcp (__m64 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfrcpit1 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfrcpit2 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfrsqrt (__m64 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfrsqit1 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfsub (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfsubr (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pi2fd (__m64 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmulhrw (__m64 __A, __m64 __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_prefetch (void *__P)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_from_float (float __A)
;
extern float __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_to_float (__m64 __A)
;
#undef __DISABLE_3dNOW__
#pragma GCC pop_options
#define _FMA4INTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("fma4")
#define __DISABLE_FMA4__
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macc_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macc_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macc_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macc_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_msub_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_msub_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_msub_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_msub_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmacc_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmacc_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmacc_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmacc_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmsub_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmsub_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmsub_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmsub_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maddsub_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maddsub_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_msubadd_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_msubadd_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_macc_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_macc_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_msub_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_msub_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_nmacc_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_nmacc_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_nmsub_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_nmsub_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maddsub_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maddsub_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_msubadd_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_msubadd_pd (__m256d __A, __m256d __B, __m256d __C)
;
#undef __DISABLE_FMA4__
#pragma GCC pop_options
#define _XOPMMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("xop")
#define __DISABLE_XOP__
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maccs_epi16(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macc_epi16(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maccsd_epi16(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maccd_epi16(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maccs_epi32(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macc_epi32(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maccslo_epi32(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macclo_epi32(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maccshi_epi32(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macchi_epi32(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maddsd_epi16(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maddd_epi16(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddw_epi8(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddd_epi8(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddq_epi8(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddd_epi16(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddq_epi16(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddq_epi32(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddw_epu8(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddd_epu8(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddq_epu8(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddd_epu16(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddq_epu16(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddq_epu32(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsubw_epi8(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsubd_epi16(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsubq_epi32(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmov_si128(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_perm_epi8(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rot_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rot_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rot_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rot_epi64(__m128i __A, __m128i __B)
;
#define _mm_roti_epi8(A,N) ((__m128i) __builtin_ia32_vprotbi ((__v16qi)(__m128i)(A), (int)(N)))
#define _mm_roti_epi16(A,N) ((__m128i) __builtin_ia32_vprotwi ((__v8hi)(__m128i)(A), (int)(N)))
#define _mm_roti_epi32(A,N) ((__m128i) __builtin_ia32_vprotdi ((__v4si)(__m128i)(A), (int)(N)))
#define _mm_roti_epi64(A,N) ((__m128i) __builtin_ia32_vprotqi ((__v2di)(__m128i)(A), (int)(N)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shl_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shl_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shl_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shl_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epi64(__m128i __A, __m128i __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_frcz_ps (__m128 __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_frcz_pd (__m128d __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_frcz_ss (__m128 __A, __m128 __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_frcz_sd (__m128d __A, __m128d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_frcz_ps (__m256 __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_frcz_pd (__m256d __A)
;
#define _mm_permute2_pd(X,Y,C,I) ((__m128d) __builtin_ia32_vpermil2pd ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128d)(C), (int)(I)))
#define _mm256_permute2_pd(X,Y,C,I) ((__m256d) __builtin_ia32_vpermil2pd256 ((__v4df)(__m256d)(X), (__v4df)(__m256d)(Y), (__v4di)(__m256d)(C), (int)(I)))
#define _mm_permute2_ps(X,Y,C,I) ((__m128) __builtin_ia32_vpermil2ps ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128)(C), (int)(I)))
#define _mm256_permute2_ps(X,Y,C,I) ((__m256) __builtin_ia32_vpermil2ps256 ((__v8sf)(__m256)(X), (__v8sf)(__m256)(Y), (__v8si)(__m256)(C), (int)(I)))
#undef __DISABLE_XOP__
#pragma GCC pop_options
#define _LWPINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("lwp")
#define __DISABLE_LWP__
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__llwpcb (void *pcbAddress)
;
extern void * __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__slwpcb (void)
;
#define __lwpval32(D2,D1,F) (__builtin_ia32_lwpval32 ((unsigned int) (D2), (unsigned int) (D1), (unsigned int) (F)))
#define __lwpval64(D2,D1,F) (__builtin_ia32_lwpval64 ((unsigned long long) (D2), (unsigned int) (D1), (unsigned int) (F)))
#define __lwpins32(D2,D1,F) (__builtin_ia32_lwpins32 ((unsigned int) (D2), (unsigned int) (D1), (unsigned int) (F)))
#define __lwpins64(D2,D1,F) (__builtin_ia32_lwpins64 ((unsigned long long) (D2), (unsigned int) (D1), (unsigned int) (F)))
#undef __DISABLE_LWP__
#pragma GCC pop_options
#define _TBMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("tbm")
#define __DISABLE_TBM__
#define __bextri_u32(X,I) ((unsigned int)__builtin_ia32_bextri_u32 ((unsigned int)(X), (unsigned int)(I)))
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcfill_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blci_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcic_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcmsk_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcs_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsfill_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsic_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__t1mskc_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__tzmsk_u32 (unsigned int __X)
;
#define __bextri_u64(X,I) ((unsigned long long)__builtin_ia32_bextri_u64 ((unsigned long long)(X), (unsigned long long)(I)))
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcfill_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blci_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcic_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcmsk_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcs_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsfill_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsic_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__t1mskc_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__tzmsk_u64 (unsigned long long __X)
;
#undef __DISABLE_TBM__
#pragma GCC pop_options
#define _RDSEEDINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("rdseed")
#define __DISABLE_RDSEED__
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_rdseed16_step (unsigned short *p)
;
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_rdseed32_step (unsigned int *p)
;
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_rdseed64_step (unsigned long long *p)
;
#undef __DISABLE_RDSEED__
#pragma GCC pop_options
#define _FXSRINTRIN_H_INCLUDED
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_fxsave (void *__P)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_fxrstor (void *__P)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_fxsave64 (void *__P)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_fxrstor64 (void *__P)
;
#define _XSAVEINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("xsave")
#define __DISABLE_XSAVE__
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsave (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xrstor (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsave64 (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xrstor64 (void *__P, long long __M)
;
#undef __DISABLE_XSAVE__
#pragma GCC pop_options
#define _XSAVEOPTINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("xsaveopt")
#define __DISABLE_XSAVEOPT__
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsaveopt (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsaveopt64 (void *__P, long long __M)
;
#undef __DISABLE_XSAVEOPT__
#pragma GCC pop_options
#define _ADXINTRIN_H_INCLUDED
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_subborrow_u32 (unsigned char __CF, unsigned int __X,
unsigned int __Y, unsigned int *__P)
;
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_addcarry_u32 (unsigned char __CF, unsigned int __X,
unsigned int __Y, unsigned int *__P)
;
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_addcarryx_u32 (unsigned char __CF, unsigned int __X,
unsigned int __Y, unsigned int *__P)
;
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_subborrow_u64 (unsigned char __CF, unsigned long __X,
unsigned long __Y, unsigned long long *__P)
;
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_addcarry_u64 (unsigned char __CF, unsigned long __X,
unsigned long __Y, unsigned long long *__P)
;
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_addcarryx_u64 (unsigned char __CF, unsigned long __X,
unsigned long __Y, unsigned long long *__P)
;
#define _CLFLUSHOPTINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("clflushopt")
#define __DISABLE_CLFLUSHOPT__
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_clflushopt (void *__A)
;
#undef __DISABLE_CLFLUSHOPT__
#pragma GCC pop_options
#define _XSAVESINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("xsaves")
#define __DISABLE_XSAVES__
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsaves (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xrstors (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xrstors64 (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsaves64 (void *__P, long long __M)
;
#undef __DISABLE_XSAVES__
#pragma GCC pop_options
#define _XSAVECINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("xsavec")
#define __DISABLE_XSAVEC__
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsavec (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsavec64 (void *__P, long long __M)
;
#undef __DISABLE_XSAVEC__
#pragma GCC pop_options
namespace std __attribute__ ((__visibility__ ("default")))
{
}
#define _RANDOM_TCC 1
#define _GLIBCXX_NUMERIC 1
#define _STL_NUMERIC_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _ForwardIterator, typename _Tp>
void
iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _InputIterator, typename _Tp>
_Tp
accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
;
template<typename _InputIterator, typename _Tp, typename _BinaryOperation>
_Tp
accumulate(_InputIterator __first, _InputIterator __last, _Tp __init,
_BinaryOperation __binary_op)
;
template<typename _InputIterator1, typename _InputIterator2, typename _Tp>
_Tp
inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _Tp __init)
;
template<typename _InputIterator1, typename _InputIterator2, typename _Tp,
typename _BinaryOperation1, typename _BinaryOperation2>
_Tp
inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _Tp __init,
_BinaryOperation1 __binary_op1,
_BinaryOperation2 __binary_op2)
;
template<typename _InputIterator, typename _OutputIterator>
_OutputIterator
partial_sum(_InputIterator __first, _InputIterator __last,
_OutputIterator __result)
;
template<typename _InputIterator, typename _OutputIterator,
typename _BinaryOperation>
_OutputIterator
partial_sum(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _BinaryOperation __binary_op)
;
template<typename _InputIterator, typename _OutputIterator>
_OutputIterator
adjacent_difference(_InputIterator __first,
_InputIterator __last, _OutputIterator __result)
;
template<typename _InputIterator, typename _OutputIterator,
typename _BinaryOperation>
_OutputIterator
adjacent_difference(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _BinaryOperation __binary_op)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
namespace __detail
{
template<typename _InputIterator, typename _OutputIterator,
typename _Tp>
_OutputIterator
__normalize(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, const _Tp& __factor)
;
}
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
constexpr _UIntType
linear_congruential_engine<_UIntType, __a, __c, __m>::multiplier;
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
constexpr _UIntType
linear_congruential_engine<_UIntType, __a, __c, __m>::increment;
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
constexpr _UIntType
linear_congruential_engine<_UIntType, __a, __c, __m>::modulus;
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
constexpr _UIntType
linear_congruential_engine<_UIntType, __a, __c, __m>::default_seed;
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const linear_congruential_engine<_UIntType,
__a, __c, __m>& __lcr)
;
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
linear_congruential_engine<_UIntType, __a, __c, __m>& __lcr)
;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::word_size;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::state_size;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::shift_size;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::mask_bits;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr _UIntType
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::xor_mask;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::tempering_u;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr _UIntType
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::tempering_d;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::tempering_s;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr _UIntType
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::tempering_b;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::tempering_t;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr _UIntType
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::tempering_c;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::tempering_l;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr _UIntType
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::
initialization_multiplier;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr _UIntType
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::default_seed;
template<typename _UIntType, size_t __w,
size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const mersenne_twister_engine<_UIntType, __w, __n, __m,
__r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __x)
;
template<typename _UIntType, size_t __w,
size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
mersenne_twister_engine<_UIntType, __w, __n, __m,
__r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __x)
;
template<typename _UIntType, size_t __w, size_t __s, size_t __r>
constexpr size_t
subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size;
template<typename _UIntType, size_t __w, size_t __s, size_t __r>
constexpr size_t
subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag;
template<typename _UIntType, size_t __w, size_t __s, size_t __r>
constexpr size_t
subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag;
template<typename _UIntType, size_t __w, size_t __s, size_t __r>
constexpr _UIntType
subtract_with_carry_engine<_UIntType, __w, __s, __r>::default_seed;
template<typename _UIntType, size_t __w, size_t __s, size_t __r,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const subtract_with_carry_engine<_UIntType,
__w, __s, __r>& __x)
;
template<typename _UIntType, size_t __w, size_t __s, size_t __r,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
subtract_with_carry_engine<_UIntType, __w, __s, __r>& __x)
;
template<typename _RandomNumberEngine, size_t __p, size_t __r>
constexpr size_t
discard_block_engine<_RandomNumberEngine, __p, __r>::block_size;
template<typename _RandomNumberEngine, size_t __p, size_t __r>
constexpr size_t
discard_block_engine<_RandomNumberEngine, __p, __r>::used_block;
template<typename _RandomNumberEngine, size_t __p, size_t __r,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const discard_block_engine<_RandomNumberEngine,
__p, __r>& __x)
;
template<typename _RandomNumberEngine, size_t __p, size_t __r,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
discard_block_engine<_RandomNumberEngine, __p, __r>& __x)
;
template<typename _RandomNumberEngine, size_t __k>
constexpr size_t
shuffle_order_engine<_RandomNumberEngine, __k>::table_size;
template<typename _RandomNumberEngine, size_t __k,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const shuffle_order_engine<_RandomNumberEngine, __k>& __x)
;
template<typename _RandomNumberEngine, size_t __k,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
shuffle_order_engine<_RandomNumberEngine, __k>& __x)
;
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const uniform_int_distribution<_IntType>& __x)
;
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
uniform_int_distribution<_IntType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const uniform_real_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
uniform_real_distribution<_RealType>& __x)
;
template<typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const bernoulli_distribution& __x)
;
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const geometric_distribution<_IntType>& __x)
;
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
geometric_distribution<_IntType>& __x)
;
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const negative_binomial_distribution<_IntType>& __x)
;
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
negative_binomial_distribution<_IntType>& __x)
;
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const poisson_distribution<_IntType>& __x)
;
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
poisson_distribution<_IntType>& __x)
;
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const binomial_distribution<_IntType>& __x)
;
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
binomial_distribution<_IntType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const exponential_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
exponential_distribution<_RealType>& __x)
;
template<typename _RealType>
bool
operator==(const std::normal_distribution<_RealType>& __d1,
const std::normal_distribution<_RealType>& __d2)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const normal_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
normal_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const lognormal_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
lognormal_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const chi_squared_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
chi_squared_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const cauchy_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
cauchy_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const fisher_f_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
fisher_f_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const student_t_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
student_t_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const gamma_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
gamma_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const weibull_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
weibull_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const extreme_value_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
extreme_value_distribution<_RealType>& __x)
;
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const discrete_distribution<_IntType>& __x)
;
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
discrete_distribution<_IntType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const piecewise_constant_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
piecewise_constant_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const piecewise_linear_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
piecewise_linear_distribution<_RealType>& __x)
;
template<typename _RealType, size_t __bits,
typename _UniformRandomNumberGenerator>
_RealType
generate_canonical(_UniformRandomNumberGenerator& __urng)
;
}
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)
;
template<typename _InputIterator, typename _Predicate>
_InputIterator
__find_if(_InputIterator __first, _InputIterator __last,
_Predicate __pred, input_iterator_tag)
;
template<typename _RandomAccessIterator, typename _Predicate>
_RandomAccessIterator
__find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Predicate __pred, random_access_iterator_tag)
;
template<typename _Iterator, typename _Predicate>
_Iterator
__find_if(_Iterator __first, _Iterator __last, _Predicate __pred)
;
template<typename _InputIterator, typename _Predicate>
_InputIterator
__find_if_not(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
;
template<typename _InputIterator, typename _Predicate, typename _Distance>
_InputIterator
__find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
;
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
_ForwardIterator1
__search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2,
_BinaryPredicate __predicate)
;
template<typename _ForwardIterator, typename _Integer,
typename _UnaryPredicate>
_ForwardIterator
__search_n_aux(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count, _UnaryPredicate __unary_pred,
std::forward_iterator_tag)
;
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)
;
template<typename _ForwardIterator, typename _Integer,
typename _UnaryPredicate>
_ForwardIterator
__search_n(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count,
_UnaryPredicate __unary_pred)
;
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)
;
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)
;
template<typename _ForwardIterator1, typename _ForwardIterator2>
_ForwardIterator1
find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2)
;
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
_ForwardIterator1
find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2,
_BinaryPredicate __comp)
;
template<typename _InputIterator, typename _Predicate>
bool
all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
;
template<typename _InputIterator, typename _Predicate>
bool
none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
;
template<typename _InputIterator, typename _Predicate>
bool
any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
;
template<typename _InputIterator, typename _Predicate>
_InputIterator
find_if_not(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
;
template<typename _InputIterator, typename _Predicate>
bool
is_partitioned(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
partition_point(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _InputIterator, typename _OutputIterator,
typename _Predicate>
_OutputIterator
__remove_copy_if(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _Predicate __pred)
;
template<typename _InputIterator, typename _OutputIterator, typename _Tp>
_OutputIterator
remove_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, const _Tp& __value)
;
template<typename _InputIterator, typename _OutputIterator,
typename _Predicate>
_OutputIterator
remove_copy_if(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _Predicate __pred)
;
template<typename _InputIterator, typename _OutputIterator,
typename _Predicate>
_OutputIterator
copy_if(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _Predicate __pred)
;
template<typename _InputIterator, typename _Size, typename _OutputIterator>
_OutputIterator
__copy_n(_InputIterator __first, _Size __n,
_OutputIterator __result, input_iterator_tag)
;
template<typename _RandomAccessIterator, typename _Size,
typename _OutputIterator>
_OutputIterator
__copy_n(_RandomAccessIterator __first, _Size __n,
_OutputIterator __result, random_access_iterator_tag)
;
template<typename _InputIterator, typename _Size, typename _OutputIterator>
_OutputIterator
copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
;
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)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
__remove_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _ForwardIterator, typename _Tp>
_ForwardIterator
remove(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __value)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
remove_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _ForwardIterator, typename _BinaryPredicate>
_ForwardIterator
__adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __binary_pred)
;
template<typename _ForwardIterator, typename _BinaryPredicate>
_ForwardIterator
__unique(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __binary_pred)
;
template<typename _ForwardIterator>
_ForwardIterator
unique(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _BinaryPredicate>
_ForwardIterator
unique(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __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)
;
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)
;
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)
;
template<typename _BidirectionalIterator>
void
__reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
bidirectional_iterator_tag)
;
template<typename _RandomAccessIterator>
void
__reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
random_access_iterator_tag)
;
template<typename _BidirectionalIterator>
void
reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
;
template<typename _BidirectionalIterator, typename _OutputIterator>
_OutputIterator
reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
_OutputIterator __result)
;
template<typename _EuclideanRingElement>
_EuclideanRingElement
__gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
;
template<typename _ForwardIterator>
void
__rotate(_ForwardIterator __first,
_ForwardIterator __middle,
_ForwardIterator __last,
forward_iterator_tag)
;
template<typename _BidirectionalIterator>
void
__rotate(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
bidirectional_iterator_tag)
;
template<typename _RandomAccessIterator>
void
__rotate(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last,
random_access_iterator_tag)
;
template<typename _ForwardIterator>
void
rotate(_ForwardIterator __first, _ForwardIterator __middle,
_ForwardIterator __last)
;
template<typename _ForwardIterator, typename _OutputIterator>
_OutputIterator
rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
_ForwardIterator __last, _OutputIterator __result)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
__partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred, forward_iterator_tag)
;
template<typename _BidirectionalIterator, typename _Predicate>
_BidirectionalIterator
__partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
_Predicate __pred, bidirectional_iterator_tag)
;
template<typename _ForwardIterator, typename _Predicate, typename _Distance>
_ForwardIterator
__inplace_stable_partition(_ForwardIterator __first,
_Predicate __pred, _Distance __len)
;
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)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
__stable_partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
stable_partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__heap_select(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _InputIterator, typename _RandomAccessIterator,
typename _Compare>
_RandomAccessIterator
__partial_sort_copy(_InputIterator __first, _InputIterator __last,
_RandomAccessIterator __result_first,
_RandomAccessIterator __result_last,
_Compare __comp)
;
template<typename _InputIterator, typename _RandomAccessIterator>
_RandomAccessIterator
partial_sort_copy(_InputIterator __first, _InputIterator __last,
_RandomAccessIterator __result_first,
_RandomAccessIterator __result_last)
;
template<typename _InputIterator, typename _RandomAccessIterator,
typename _Compare>
_RandomAccessIterator
partial_sort_copy(_InputIterator __first, _InputIterator __last,
_RandomAccessIterator __result_first,
_RandomAccessIterator __result_last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__unguarded_linear_insert(_RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__unguarded_insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
enum { _S_threshold = 16 };
template<typename _RandomAccessIterator, typename _Compare>
void
__final_insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
_RandomAccessIterator
__unguarded_partition(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_RandomAccessIterator __pivot, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
_RandomAccessIterator
__unguarded_partition_pivot(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__partial_sort(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Size, typename _Compare>
void
__introsort_loop(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Size __depth_limit, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Size, typename _Compare>
void
__introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last, _Size __depth_limit,
_Compare __comp)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
_ForwardIterator
lower_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
_ForwardIterator
__upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
;
template<typename _ForwardIterator, typename _Tp>
_ForwardIterator
upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
_ForwardIterator
upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __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)
;
template<typename _ForwardIterator, typename _Tp>
pair<_ForwardIterator, _ForwardIterator>
equal_range(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
pair<_ForwardIterator, _ForwardIterator>
equal_range(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
;
template<typename _ForwardIterator, typename _Tp>
bool
binary_search(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
bool
binary_search(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
;
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)
;
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)
;
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)
;
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)
;
template<typename _BidirectionalIterator, typename _Distance,
typename _Compare>
void
__merge_without_buffer(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Distance __len1, _Distance __len2,
_Compare __comp)
;
template<typename _BidirectionalIterator, typename _Compare>
void
__inplace_merge(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Compare __comp)
;
template<typename _BidirectionalIterator>
void
inplace_merge(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last)
;
template<typename _BidirectionalIterator, typename _Compare>
void
inplace_merge(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Compare __comp)
;
template<typename _InputIterator, typename _OutputIterator,
typename _Compare>
_OutputIterator
__move_merge(_InputIterator __first1, _InputIterator __last1,
_InputIterator __first2, _InputIterator __last2,
_OutputIterator __result, _Compare __comp)
;
template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
typename _Distance, typename _Compare>
void
__merge_sort_loop(_RandomAccessIterator1 __first,
_RandomAccessIterator1 __last,
_RandomAccessIterator2 __result, _Distance __step_size,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Distance,
typename _Compare>
void
__chunk_insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Distance __chunk_size, _Compare __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)
;
template<typename _RandomAccessIterator, typename _Pointer,
typename _Distance, typename _Compare>
void
__stable_sort_adaptive(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Pointer __buffer, _Distance __buffer_size,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__inplace_stable_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _Compare>
bool
__includes(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2>
bool
includes(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _Compare>
bool
includes(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_Compare __comp)
;
template<typename _BidirectionalIterator, typename _Compare>
bool
__next_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last, _Compare __comp)
;
template<typename _BidirectionalIterator>
bool
next_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last)
;
template<typename _BidirectionalIterator, typename _Compare>
bool
next_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last, _Compare __comp)
;
template<typename _BidirectionalIterator, typename _Compare>
bool
__prev_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last, _Compare __comp)
;
template<typename _BidirectionalIterator>
bool
prev_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last)
;
template<typename _BidirectionalIterator, typename _Compare>
bool
prev_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last, _Compare __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)
;
template<typename _InputIterator, typename _OutputIterator, typename _Tp>
_OutputIterator
replace_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result,
const _Tp& __old_value, const _Tp& __new_value)
;
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)
;
template<typename _InputIterator, typename _Predicate>
typename iterator_traits<_InputIterator>::difference_type
__count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
;
template<typename _ForwardIterator>
bool
is_sorted(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Compare>
bool
is_sorted(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
__is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _ForwardIterator>
_ForwardIterator
is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _Tp>
pair<const _Tp&, const _Tp&>
minmax(const _Tp& __a, const _Tp& __b)
;
template<typename _Tp, typename _Compare>
pair<const _Tp&, const _Tp&>
minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
;
template<typename _ForwardIterator, typename _Compare>
pair<_ForwardIterator, _ForwardIterator>
__minmax_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _ForwardIterator>
pair<_ForwardIterator, _ForwardIterator>
minmax_element(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Compare>
pair<_ForwardIterator, _ForwardIterator>
minmax_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _Tp>
_Tp
min(initializer_list<_Tp> __l)
;
template<typename _Tp, typename _Compare>
_Tp
min(initializer_list<_Tp> __l, _Compare __comp)
;
template<typename _Tp>
_Tp
max(initializer_list<_Tp> __l)
;
template<typename _Tp, typename _Compare>
_Tp
max(initializer_list<_Tp> __l, _Compare __comp)
;
template<typename _Tp>
pair<_Tp, _Tp>
minmax(initializer_list<_Tp> __l)
;
template<typename _Tp, typename _Compare>
pair<_Tp, _Tp>
minmax(initializer_list<_Tp> __l, _Compare __comp)
;
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
bool
__is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _BinaryPredicate __pred)
;
template<typename _ForwardIterator1, typename _ForwardIterator2>
bool
is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2)
;
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
bool
is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _BinaryPredicate __pred)
;
template<typename _RandomAccessIterator,
typename _UniformRandomNumberGenerator>
void
shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
_UniformRandomNumberGenerator&& __g)
;
template<typename _InputIterator, typename _Function>
_Function
for_each(_InputIterator __first, _InputIterator __last, _Function __f)
;
template<typename _InputIterator, typename _Tp>
_InputIterator
find(_InputIterator __first, _InputIterator __last,
const _Tp& __val)
;
template<typename _InputIterator, typename _Predicate>
_InputIterator
find_if(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
;
template<typename _InputIterator, typename _ForwardIterator>
_InputIterator
find_first_of(_InputIterator __first1, _InputIterator __last1,
_ForwardIterator __first2, _ForwardIterator __last2)
;
template<typename _InputIterator, typename _ForwardIterator,
typename _BinaryPredicate>
_InputIterator
find_first_of(_InputIterator __first1, _InputIterator __last1,
_ForwardIterator __first2, _ForwardIterator __last2,
_BinaryPredicate __comp)
;
template<typename _ForwardIterator>
_ForwardIterator
adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _BinaryPredicate>
_ForwardIterator
adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __binary_pred)
;
template<typename _InputIterator, typename _Tp>
typename iterator_traits<_InputIterator>::difference_type
count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
;
template<typename _InputIterator, typename _Predicate>
typename iterator_traits<_InputIterator>::difference_type
count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
;
template<typename _ForwardIterator1, typename _ForwardIterator2>
_ForwardIterator1
search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2)
;
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
_ForwardIterator1
search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2,
_BinaryPredicate __predicate)
;
template<typename _ForwardIterator, typename _Integer, typename _Tp>
_ForwardIterator
search_n(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count, const _Tp& __val)
;
template<typename _ForwardIterator, typename _Integer, typename _Tp,
typename _BinaryPredicate>
_ForwardIterator
search_n(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count, const _Tp& __val,
_BinaryPredicate __binary_pred)
;
template<typename _InputIterator, typename _OutputIterator,
typename _UnaryOperation>
_OutputIterator
transform(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _UnaryOperation __unary_op)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _BinaryOperation>
_OutputIterator
transform(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _OutputIterator __result,
_BinaryOperation __binary_op)
;
template<typename _ForwardIterator, typename _Tp>
void
replace(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __old_value, const _Tp& __new_value)
;
template<typename _ForwardIterator, typename _Predicate, typename _Tp>
void
replace_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred, const _Tp& __new_value)
;
template<typename _ForwardIterator, typename _Generator>
void
generate(_ForwardIterator __first, _ForwardIterator __last,
_Generator __gen)
;
template<typename _OutputIterator, typename _Size, typename _Generator>
_OutputIterator
generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
;
template<typename _InputIterator, typename _OutputIterator>
_OutputIterator
unique_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result)
;
template<typename _InputIterator, typename _OutputIterator,
typename _BinaryPredicate>
_OutputIterator
unique_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result,
_BinaryPredicate __binary_pred)
;
template<typename _RandomAccessIterator>
void
random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
void
random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
_RandomNumberGenerator&& __rand)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _RandomAccessIterator>
void
partial_sort(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
partial_sort(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator>
void
nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _RandomAccessIterator>
void
sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
_OutputIterator
__merge(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
_OutputIterator
merge(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
_OutputIterator
merge(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator>
void
stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __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)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
_OutputIterator
set_union(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
_OutputIterator
set_union(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __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)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
_OutputIterator
set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
_OutputIterator
set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __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)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
_OutputIterator
set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
_OutputIterator
set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __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)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
_OutputIterator
set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
;
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)
;
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
__min_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _ForwardIterator>
_ForwardIterator
min_element(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
min_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
__max_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _ForwardIterator>
_ForwardIterator
max_element(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
max_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
}
namespace boost
{
template<class T> class shared_ptr;
template<class T> class weak_ptr;
template<class T> class enable_shared_from_this;
class enable_shared_from_raw;
namespace detail
{
template< class T > struct sp_element
{
typedef T type;
};
template< class T > struct sp_element< T[] >
{
typedef T type;
};
template< class T, std::size_t N > struct sp_element< T[N] >
{
typedef T type;
};
template< class T > struct sp_dereference
{
typedef T & type;
};
template<> struct sp_dereference< void >
{
typedef void type;
};
template<> struct sp_dereference< void const >
{
typedef void type;
};
template<> struct sp_dereference< void volatile >
{
typedef void type;
};
template<> struct sp_dereference< void const volatile >
{
typedef void type;
};
template< class T > struct sp_dereference< T[] >
{
typedef void type;
};
template< class T, std::size_t N > struct sp_dereference< T[N] >
{
typedef void type;
};
template< class T > struct sp_member_access
{
typedef T * type;
};
template< class T > struct sp_member_access< T[] >
{
typedef void type;
};
template< class T, std::size_t N > struct sp_member_access< T[N] >
{
typedef void type;
};
template< class T > struct sp_array_access
{
typedef void type;
};
template< class T > struct sp_array_access< T[] >
{
typedef T & type;
};
template< class T, std::size_t N > struct sp_array_access< T[N] >
{
typedef T & type;
};
template< class T > struct sp_extent
{
enum _vt { value = 0 };
};
template< class T, std::size_t N > struct sp_extent< T[N] >
{
enum _vt { value = N };
};
template< class X, class Y, class T > void sp_enable_shared_from_this( boost::shared_ptr<X> const * ppx, Y const * py, boost::enable_shared_from_this< T > const * pe )
;
template< class X, class Y > inline void sp_enable_shared_from_this( boost::shared_ptr<X> * ppx, Y const * py, boost::enable_shared_from_raw const * pe );
void sp_enable_shared_from_this( ... )
;
template< class T, class R > struct sp_enable_if_auto_ptr
{
};
template< class T, class R > struct sp_enable_if_auto_ptr< std::auto_ptr< T >, R >
{
typedef R type;
};
template< class Y, class T > void sp_assert_convertible()
;
template< class T, class Y > void sp_pointer_construct( boost::shared_ptr< T > * ppx, Y * p, boost::detail::shared_count & pn )
;
template< class T, class Y > void sp_pointer_construct( boost::shared_ptr< T[] > * , Y * p, boost::detail::shared_count & pn )
;
template< class T, std::size_t N, class Y > void sp_pointer_construct( boost::shared_ptr< T[N] > * , Y * p, boost::detail::shared_count & pn )
;
template< class T, class Y > void sp_deleter_construct( boost::shared_ptr< T > * ppx, Y * p )
;
template< class T, class Y > void sp_deleter_construct( boost::shared_ptr< T[] > * , Y * )
;
template< class T, std::size_t N, class Y > void sp_deleter_construct( boost::shared_ptr< T[N] > * , Y * )
;
}
template<class T> class shared_ptr
{
private:
typedef shared_ptr<T> this_type;
public:
typedef typename boost::detail::sp_element< T >::type element_type;
shared_ptr() noexcept : px( 0 ), pn()
{
}
shared_ptr( boost::detail::sp_nullptr_t ) noexcept : px( 0 ), pn()
{
}
template<class Y>
explicit shared_ptr( Y * p ): px( p ), pn()
{
boost::detail::sp_pointer_construct( this, p, pn );
}
template<class Y, class D> shared_ptr( Y * p, D d ): px( p ), pn( p, d )
{
boost::detail::sp_deleter_construct( this, p );
}
template<class D> shared_ptr( boost::detail::sp_nullptr_t p, D d ): px( p ), pn( p, d )
{
}
template<class Y, class D, class A> shared_ptr( Y * p, D d, A a ): px( p ), pn( p, d, a )
{
boost::detail::sp_deleter_construct( this, p );
}
template<class D, class A> shared_ptr( boost::detail::sp_nullptr_t p, D d, A a ): px( p ), pn( p, d, a )
{
}
shared_ptr( shared_ptr const & r ) noexcept : px( r.px ), pn( r.pn )
{
}
template<class Y>
explicit shared_ptr( weak_ptr<Y> const & r ): pn( r.pn )
{
boost::detail::sp_assert_convertible< Y, T >();
px = r.px;
}
template<class Y>
shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag )
noexcept : px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() )
{
if( !pn.empty() )
{
px = r.px;
}
}
template<class Y>
shared_ptr( shared_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
noexcept : px( r.px ), pn( r.pn )
{
boost::detail::sp_assert_convertible< Y, T >();
}
template< class Y >
shared_ptr( shared_ptr<Y> const & r, element_type * p ) noexcept : px( p ), pn( r.pn )
{
}
template<class Y>
explicit shared_ptr( std::auto_ptr<Y> & r ): px(r.get()), pn()
{
boost::detail::sp_assert_convertible< Y, T >();
Y * tmp = r.get();
pn = boost::detail::shared_count( r );
boost::detail::sp_deleter_construct( this, tmp );
}
template<class Y>
shared_ptr( std::auto_ptr<Y> && r ): px(r.get()), pn()
{
boost::detail::sp_assert_convertible< Y, T >();
Y * tmp = r.get();
pn = boost::detail::shared_count( r );
boost::detail::sp_deleter_construct( this, tmp );
}
template< class Y, class D >
shared_ptr( std::unique_ptr< Y, D > && r ): px( r.get() ), pn()
{
boost::detail::sp_assert_convertible< Y, T >();
typename std::unique_ptr< Y, D >::pointer tmp = r.get();
pn = boost::detail::shared_count( r );
boost::detail::sp_deleter_construct( this, tmp );
}
shared_ptr & operator=( shared_ptr const & r ) noexcept
{
this_type(r).swap(*this);
return *this;
}
template<class Y>
shared_ptr & operator=(shared_ptr<Y> const & r) noexcept
{
this_type(r).swap(*this);
return *this;
}
template<class Y>
shared_ptr & operator=( std::auto_ptr<Y> & r )
{
this_type( r ).swap( *this );
return *this;
}
template<class Y>
shared_ptr & operator=( std::auto_ptr<Y> && r )
{
this_type( static_cast< std::auto_ptr<Y> && >( r ) ).swap( *this );
return *this;
}
template<class Y, class D>
shared_ptr & operator=( std::unique_ptr<Y, D> && r )
{
this_type( static_cast< std::unique_ptr<Y, D> && >( r ) ).swap(*this);
return *this;
}
shared_ptr( shared_ptr && r ) noexcept : px( r.px ), pn()
{
pn.swap( r.pn );
r.px = 0;
}
template<class Y>
shared_ptr( shared_ptr<Y> && r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
noexcept : px( r.px ), pn()
{
boost::detail::sp_assert_convertible< Y, T >();
pn.swap( r.pn );
r.px = 0;
}
shared_ptr & operator=( shared_ptr && r ) noexcept
{
this_type( static_cast< shared_ptr && >( r ) ).swap( *this );
return *this;
}
template<class Y>
shared_ptr & operator=( shared_ptr<Y> && r ) noexcept
{
this_type( static_cast< shared_ptr<Y> && >( r ) ).swap( *this );
return *this;
}
shared_ptr & operator=( boost::detail::sp_nullptr_t ) noexcept
{
this_type().swap(*this);
return *this;
}
void reset() noexcept
{
this_type().swap(*this);
}
template<class Y> void reset( Y * p )
{
(static_cast<void> (0));
this_type( p ).swap( *this );
}
template<class Y, class D> void reset( Y * p, D d )
{
this_type( p, d ).swap( *this );
}
template<class Y, class D, class A> void reset( Y * p, D d, A a )
{
this_type( p, d, a ).swap( *this );
}
template<class Y> void reset( shared_ptr<Y> const & r, element_type * p )
{
this_type( r, p ).swap( *this );
}
typename boost::detail::sp_dereference< T >::type operator* () const
{
(static_cast<void> (0));
return *px;
}
typename boost::detail::sp_member_access< T >::type operator-> () const
{
(static_cast<void> (0));
return px;
}
typename boost::detail::sp_array_access< T >::type operator[] ( std::ptrdiff_t i ) const
{
(static_cast<void> (0));
(static_cast<void> (0));
return px[ i ];
}
element_type * get() const noexcept
{
return px;
}
explicit operator bool () const noexcept
{
return px != 0;
}
bool operator! () const noexcept
{
return px == 0;
}
bool unique() const noexcept
{
return pn.unique();
}
long use_count() const noexcept
{
return pn.use_count();
}
void swap( shared_ptr & other ) noexcept
{
std::swap(px, other.px);
pn.swap(other.pn);
}
template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const noexcept
{
return pn < rhs.pn;
}
template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const noexcept
{
return pn < rhs.pn;
}
void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const noexcept
{
return pn.get_deleter( ti );
}
void * _internal_get_untyped_deleter() const noexcept
{
return pn.get_untyped_deleter();
}
bool _internal_equiv( shared_ptr const & r ) const noexcept
{
return px == r.px && pn == r.pn;
}
private:
template<class Y> friend class shared_ptr;
template<class Y> friend class weak_ptr;
element_type * px;
boost::detail::shared_count pn;
};
template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept
{
return a.get() == b.get();
}
template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept
{
return a.get() != b.get();
}
template<class T> inline bool operator==( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) noexcept
{
return p.get() == 0;
}
template<class T> inline bool operator==( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) noexcept
{
return p.get() == 0;
}
template<class T> inline bool operator!=( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) noexcept
{
return p.get() != 0;
}
template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) noexcept
{
return p.get() != 0;
}
template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept
{
return a.owner_before( b );
}
template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b) noexcept
{
a.swap(b);
}
template<class T, class U> shared_ptr<T> static_pointer_cast( shared_ptr<U> const & r ) noexcept
{
(void) static_cast< T* >( static_cast< U* >( 0 ) );
typedef typename shared_ptr<T>::element_type E;
E * p = static_cast< E* >( r.get() );
return shared_ptr<T>( r, p );
}
template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> const & r ) noexcept
{
(void) const_cast< T* >( static_cast< U* >( 0 ) );
typedef typename shared_ptr<T>::element_type E;
E * p = const_cast< E* >( r.get() );
return shared_ptr<T>( r, p );
}
template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> const & r ) noexcept
{
(void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
typedef typename shared_ptr<T>::element_type E;
E * p = dynamic_cast< E* >( r.get() );
return p? shared_ptr<T>( r, p ): shared_ptr<T>();
}
template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U> const & r ) noexcept
{
(void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
typedef typename shared_ptr<T>::element_type E;
E * p = reinterpret_cast< E* >( r.get() );
return shared_ptr<T>( r, p );
}
template<class T> inline typename shared_ptr<T>::element_type * get_pointer(shared_ptr<T> const & p) noexcept
{
return p.get();
}
template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)
{
os << p.get();
return os;
}
namespace detail
{
template<class D, class T> D * basic_get_deleter( shared_ptr<T> const & p ) noexcept
{
return static_cast<D *>( p._internal_get_deleter(typeid(D)) );
}
class esft2_deleter_wrapper
{
private:
shared_ptr<void> deleter_;
public:
esft2_deleter_wrapper()
{
}
template< class T > void set_deleter( shared_ptr<T> const & deleter )
{
deleter_ = deleter;
}
template<typename D> D* get_deleter() const noexcept
{
return boost::detail::basic_get_deleter<D>( deleter_ );
}
template< class T> void operator()( T* )
{
(static_cast<void> (0));
deleter_.reset();
}
};
}
template<class D, class T> D * get_deleter( shared_ptr<T> const & p ) noexcept
{
D *del = boost::detail::basic_get_deleter<D>(p);
if(del == 0)
{
boost::detail::esft2_deleter_wrapper *del_wrapper = boost::detail::basic_get_deleter<boost::detail::esft2_deleter_wrapper>(p);
if(del_wrapper) del = del_wrapper->::boost::detail::esft2_deleter_wrapper::get_deleter<D>();
}
return del;
}
template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * ) noexcept
{
return false;
}
template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p )
{
boost::detail::spinlock_pool<2>::scoped_lock lock( p );
return *p;
}
template<class T> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, memory_order )
{
return atomic_load( p );
}
template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r )
{
boost::detail::spinlock_pool<2>::scoped_lock lock( p );
p->swap( r );
}
template<class T> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order )
{
atomic_store( p, r );
}
template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r )
{
boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
sp.lock();
p->swap( r );
sp.unlock();
return r;
}
template<class T> shared_ptr<T> atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order )
{
return atomic_exchange( p, r );
}
template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w )
{
boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
sp.lock();
if( p->_internal_equiv( *v ) )
{
p->swap( w );
sp.unlock();
return true;
}
else
{
shared_ptr<T> tmp( *p );
sp.unlock();
tmp.swap( *v );
return false;
}
}
template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, memory_order , memory_order )
{
return atomic_compare_exchange( p, v, w );
}
template< class T > struct hash;
template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p ) noexcept
{
return boost::hash< T* >()( p.get() );
}
}
namespace boost {
namespace date_time {
template<class time_type>
class second_clock
{
public:
typedef typename time_type::date_type date_type;
typedef typename time_type::time_duration_type time_duration_type;
static time_type local_time()
;
static time_type universal_time()
;
template<class time_zone_type>
static time_type local_time(boost::shared_ptr<time_zone_type> tz_ptr)
;
private:
static time_type create_time(::std::tm* current)
;
};
} }
#define DATE_TIME_HIGHRES_TIME_CLOCK_HPP___
#define DATE_TIME_FILETIME_FUNCTIONS_HPP__
namespace boost {
namespace date_time {
template<class time_type>
class microsec_clock
{
private:
typedef std::tm* (*time_converter)(const std::time_t*, std::tm*);
public:
typedef typename time_type::date_type date_type;
typedef typename time_type::time_duration_type time_duration_type;
typedef typename time_duration_type::rep_type resolution_traits_type;
template<class time_zone_type>
static time_type local_time(shared_ptr<time_zone_type> tz_ptr)
;
static time_type local_time()
;
static time_type universal_time()
;
private:
static time_type create_time(time_converter converter)
;
};
} }
#define POSIX_PTIME_HPP___
#define POSIX_TIME_SYSTEM_HPP___
#define POSIX_TIME_CONFIG_HPP___
#define BOOST_CONFIG_CMATH
#define BOOST_TR1_NO_RECURSION
#define BOOST_CONFIG_NO_CMATH_RECURSION
#undef BOOST_TR1_NO_RECURSION
#undef BOOST_CONFIG_NO_CMATH_RECURSION
#define DATE_TIME_TIME_DURATION_HPP___
#define BOOST_STATIC_ASSERT_HPP
#define BOOST_STATIC_ASSERT_MSG(...) static_assert(__VA_ARGS__)
#define BOOST_STATIC_ASSERT_BOOL_CAST(...) ((__VA_ARGS__) == 0 ? false : true)
#define BOOST_STATIC_ASSERT_UNUSED_ATTRIBUTE __attribute__((unused))
#define BOOST_STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
#define DATE_TIME_TIME_PRECISION_LIMITS_HPP
namespace boost {
namespace date_time {
enum time_resolutions {
sec,
tenth,
hundreth,
hundredth = hundreth,
milli,
ten_thousandth,
micro,
nano,
NumResolutions
};
enum dst_flags {not_dst, is_dst, calculate};
} }
#define DATE_TIME_SPECIAL_DEFS_HPP__
namespace boost {
namespace date_time {
enum special_values {not_a_date_time,
neg_infin, pos_infin,
min_date_time, max_date_time,
not_special, NumSpecialValues};
} }
namespace boost {
namespace date_time {
template<class T, typename rep_type>
class time_duration : private
boost::less_than_comparable<T
, boost::equality_comparable<T
> >
{
public:
typedef T duration_type;
typedef rep_type traits_type;
typedef typename rep_type::day_type day_type;
typedef typename rep_type::hour_type hour_type;
typedef typename rep_type::min_type min_type;
typedef typename rep_type::sec_type sec_type;
typedef typename rep_type::fractional_seconds_type fractional_seconds_type;
typedef typename rep_type::tick_type tick_type;
typedef typename rep_type::impl_type impl_type;
time_duration() ;
time_duration(hour_type hours_in,
min_type minutes_in,
sec_type seconds_in=0,
fractional_seconds_type frac_sec_in = 0)
;
time_duration(const time_duration<T, rep_type>& other)
;
time_duration(special_values sv)
;
static duration_type unit()
;
static tick_type ticks_per_second()
;
static time_resolutions resolution()
;
hour_type hours() const
;
min_type minutes() const
;
sec_type seconds() const
;
sec_type total_seconds() const
;
tick_type total_milliseconds() const
;
tick_type total_nanoseconds() const
;
tick_type total_microseconds() const
;
fractional_seconds_type fractional_seconds() const
;
static unsigned short num_fractional_digits()
;
duration_type invert_sign() const
;
bool is_negative() const
;
bool operator<(const time_duration& rhs) const
;
bool operator==(const time_duration& rhs) const
;
duration_type operator-()const
;
duration_type operator-(const duration_type& d) const
;
duration_type operator+(const duration_type& d) const
;
duration_type operator/(int divisor) const
;
duration_type operator-=(const duration_type& d)
;
duration_type operator+=(const duration_type& d)
;
duration_type operator/=(int divisor)
;
duration_type operator*(int rhs) const
;
duration_type operator*=(int divisor)
;
tick_type ticks() const
;
bool is_special()const
;
bool is_pos_infinity()const
;
bool is_neg_infinity()const
;
bool is_not_a_date_time()const
;
impl_type get_rep()const
;
protected:
explicit time_duration(impl_type in) ;
impl_type ticks_;
};
template<class base_duration, boost::int64_t frac_of_second>
class subsecond_duration : public base_duration
{
public:
typedef typename base_duration::impl_type impl_type;
typedef typename base_duration::traits_type traits_type;
private:
static_assert((traits_type::ticks_per_second >= frac_of_second ? traits_type::ticks_per_second % frac_of_second : frac_of_second % traits_type::ticks_per_second) == 0, "The base duration resolution must be a multiple of the subsecond duration resolution");
static const boost::int64_t adjustment_ratio = (traits_type::ticks_per_second >= frac_of_second ? traits_type::ticks_per_second / frac_of_second : frac_of_second / traits_type::ticks_per_second);
public:
explicit subsecond_duration(boost::int64_t ss)
;
};
} }
#define DATE_TIME_TIME_RESOLUTION_TRAITS_HPP
#define _DATE_TIME_INT_ADAPTER_HPP__
namespace boost {
namespace date_time {
template<typename int_type_>
class int_adapter {
public:
typedef int_type_ int_type;
int_adapter(int_type v)
;
static bool has_infinity()
;
static const int_adapter pos_infinity()
;
static const int_adapter neg_infinity()
;
static const int_adapter not_a_number()
;
static int_adapter max ()
;
static int_adapter min ()
;
static int_adapter from_special(special_values sv)
;
static bool is_inf(int_type v)
;
static bool is_neg_inf(int_type v)
;
static bool is_pos_inf(int_type v)
;
static bool is_not_a_number(int_type v)
;
static special_values to_special(int_type v)
;
static int_type maxcount()
;
bool is_infinity() const
;
bool is_pos_infinity()const
;
bool is_neg_infinity()const
;
bool is_nan() const
;
bool is_special() const
;
bool operator==(const int_adapter& rhs) const
;
bool operator==(const int& rhs) const
;
bool operator!=(const int_adapter& rhs) const
;
bool operator!=(const int& rhs) const
;
bool operator<(const int_adapter& rhs) const
;
bool operator<(const int& rhs) const
;
bool operator>(const int_adapter& rhs) const
;
int_type as_number() const
;
special_values as_special() const
;
template<class rhs_type>
int_adapter operator+(const int_adapter<rhs_type>& rhs) const
;
int_adapter operator+(const int_type rhs) const
;
template<class rhs_type>
int_adapter operator-(const int_adapter<rhs_type>& rhs)const
;
int_adapter operator-(const int_type rhs) const
;
int_adapter operator*(const int_adapter& rhs)const
;
int_adapter operator*(const int rhs) const
;
int_adapter operator/(const int_adapter& rhs)const
;
int_adapter operator/(const int rhs) const
;
int_adapter operator%(const int_adapter& rhs)const
;
int_adapter operator%(const int rhs) const
;
private:
int_type value_;
int compare(const int_adapter& rhs)const
;
int_adapter mult_div_specials(const int_adapter& rhs)const
;
int_adapter mult_div_specials(const int& rhs) const
;
};
template<class charT, class traits, typename int_type>
std::basic_ostream<charT, traits>&
operator<<(std::basic_ostream<charT, traits>& os, const int_adapter<int_type>& ia)
;
} }
namespace boost {
namespace date_time {
template <typename T>
T absolute_value(T x)
;
struct time_resolution_traits_bi32_impl {
typedef boost::int32_t int_type;
typedef boost::int32_t impl_type;
static int_type as_number(impl_type i);
static bool is_adapted() ;
};
struct time_resolution_traits_adapted32_impl {
typedef boost::int32_t int_type;
typedef boost::date_time::int_adapter<boost::int32_t> impl_type;
static int_type as_number(impl_type i);
static bool is_adapted() ;
};
struct time_resolution_traits_bi64_impl {
typedef boost::int64_t int_type;
typedef boost::int64_t impl_type;
static int_type as_number(impl_type i);
static bool is_adapted() ;
};
struct time_resolution_traits_adapted64_impl {
typedef boost::int64_t int_type;
typedef boost::date_time::int_adapter<boost::int64_t> impl_type;
static int_type as_number(impl_type i);
static bool is_adapted() ;
};
template<typename frac_sec_type,
time_resolutions res,
typename frac_sec_type::int_type resolution_adjust,
unsigned short frac_digits,
typename v_type = boost::int32_t >
class time_resolution_traits {
public:
typedef typename frac_sec_type::int_type fractional_seconds_type;
typedef typename frac_sec_type::int_type tick_type;
typedef typename frac_sec_type::impl_type impl_type;
typedef v_type day_type;
typedef v_type hour_type;
typedef v_type min_type;
typedef v_type sec_type;
static fractional_seconds_type as_number(impl_type i)
;
static bool is_adapted()
;
static const fractional_seconds_type ticks_per_second = resolution_adjust;
static time_resolutions resolution()
;
static unsigned short num_fractional_digits()
;
static fractional_seconds_type res_adjust()
;
static tick_type to_tick_count(hour_type hours,
min_type minutes,
sec_type seconds,
fractional_seconds_type fs)
;
};
typedef time_resolution_traits<time_resolution_traits_adapted32_impl, milli, 1000, 3 > milli_res;
typedef time_resolution_traits<time_resolution_traits_adapted64_impl, micro, 1000000, 6 > micro_res;
typedef time_resolution_traits<time_resolution_traits_adapted64_impl, nano, 1000000000, 9 > nano_res;
} }
#define _GREGORIAN_TYPES_HPP__
#define DATE_TIME_DATE_HPP___
#define YearMonthDayBase_HPP__
namespace boost {
namespace date_time {
template<typename YearType, typename MonthType, typename DayType>
struct year_month_day_base {
year_month_day_base(YearType year,
MonthType month,
DayType day);
YearType year;
MonthType month;
DayType day;
typedef YearType year_type;
typedef MonthType month_type;
typedef DayType day_type;
};
} }
namespace boost {
namespace date_time {
template<class T, class calendar, class duration_type_>
class date : private
boost::less_than_comparable<T
, boost::equality_comparable<T
> >
{
public:
typedef T date_type;
typedef calendar calendar_type;
typedef typename calendar::date_traits_type traits_type;
typedef duration_type_ duration_type;
typedef typename calendar::year_type year_type;
typedef typename calendar::month_type month_type;
typedef typename calendar::day_type day_type;
typedef typename calendar::ymd_type ymd_type;
typedef typename calendar::date_rep_type date_rep_type;
typedef typename calendar::date_int_type date_int_type;
typedef typename calendar::day_of_week_type day_of_week_type;
date(year_type y, month_type m, day_type d)
;
date(const ymd_type& ymd)
;
year_type year() const
;
month_type month() const
;
day_type day() const
;
day_of_week_type day_of_week() const
;
ymd_type year_month_day() const
;
bool operator<(const date_type& rhs) const
;
bool operator==(const date_type& rhs) const
;
bool is_special()const
;
bool is_not_a_date() const
;
bool is_infinity() const
;
bool is_pos_infinity() const
;
bool is_neg_infinity() const
;
special_values as_special() const
;
duration_type operator-(const date_type& d) const
;
date_type operator-(const duration_type& dd) const
;
date_type operator-=(const duration_type& dd)
;
date_rep_type day_count() const
;
date_type operator+(const duration_type& dd) const
;
date_type operator+=(const duration_type& dd)
;
protected:
explicit date(date_int_type days) ;
explicit date(date_rep_type days) ;
date_int_type days_;
};
} }
#define DATE_TIME_PERIOD_HPP___
namespace boost {
namespace date_time {
template<class point_rep, class duration_rep>
class period : private
boost::less_than_comparable<period<point_rep, duration_rep>
, boost::equality_comparable< period<point_rep, duration_rep>
> >
{
public:
typedef point_rep point_type;
typedef duration_rep duration_type;
period(point_rep first_point, point_rep end_point);
period(point_rep first_point, duration_rep len);
point_rep begin() const;
point_rep end() const;
point_rep last() const;
duration_rep length() const;
bool is_null() const;
bool operator==(const period& rhs) const;
bool operator<(const period& rhs) const;
void shift(const duration_rep& d);
void expand(const duration_rep& d);
bool contains(const point_rep& point) const;
bool contains(const period& other) const;
bool intersects(const period& other) const;
bool is_adjacent(const period& other) const;
bool is_before(const point_rep& point) const;
bool is_after(const point_rep& point) const;
period intersection(const period& other) const;
period merge(const period& other) const;
period span(const period& other) const;
private:
point_rep begin_;
point_rep last_;
};
} }
#define GREGORIAN_GREGORIAN_CALENDAR_HPP__
#define GREG_WEEKDAY_HPP___
#define CONSTRAINED_VALUE_HPP___
#define BOOST_MPL_IF_HPP_INCLUDED
#define BOOST_MPL_AUX_VALUE_WKND_HPP_INCLUDED
#define BOOST_MPL_AUX_STATIC_CAST_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED
#define BOOST_MPL_AUX_STATIC_CAST(T,expr) static_cast<T>(expr)
#define BOOST_MPL_AUX_CONFIG_INTEGRAL_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_ETI_HPP_INCLUDED
#define BOOST_MPL_AUX_VALUE_WKND(C) C
#define BOOST_MPL_AUX_MSVC_VALUE_WKND(C) C
#define BOOST_MPL_AUX_NESTED_VALUE_WKND(T,C) BOOST_MPL_AUX_VALUE_WKND(C)::value
namespace boost { namespace mpl { namespace aux {
template< typename T > struct value_type_wknd
{
typedef typename T::value_type type;
};
}}}
#define BOOST_MPL_AUX_NA_SPEC_HPP_INCLUDED
#define BOOST_MPL_LAMBDA_FWD_HPP_INCLUDED
#define BOOST_MPL_VOID_FWD_HPP_INCLUDED
#define BOOST_MPL_AUX_ADL_BARRIER_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_ADL_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_INTEL_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_GCC_HPP_INCLUDED
#define BOOST_MPL_CFG_GCC ((__GNUC__ << 8) | __GNUC_MINOR__)
#define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE mpl_
#define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN namespace mpl_ {
#define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE }
#define BOOST_MPL_AUX_ADL_BARRIER_DECL(type) namespace boost { namespace mpl { using ::BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::type; } }
namespace mpl_ { namespace aux {} }
namespace boost { namespace mpl { using namespace mpl_;
namespace aux { using namespace mpl_::aux; }
}}
namespace mpl_ {
struct void_;
}
namespace boost { namespace mpl { using ::mpl_::void_; } }
#define BOOST_MPL_AUX_NA_HPP_INCLUDED
#define BOOST_MPL_BOOL_HPP_INCLUDED
#define BOOST_MPL_BOOL_FWD_HPP_INCLUDED
namespace mpl_ {
template< bool C_ > struct bool_;
typedef bool_<true> true_;
typedef bool_<false> false_;
}
namespace boost { namespace mpl { using ::mpl_::bool_; } }
namespace boost { namespace mpl { using ::mpl_::true_; } }
namespace boost { namespace mpl { using ::mpl_::false_; } }
#define BOOST_MPL_INTEGRAL_C_TAG_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED
namespace mpl_ {
struct integral_c_tag { static const int value = 0; };
}
namespace boost { namespace mpl { using ::mpl_::integral_c_tag; } }
namespace mpl_ {
template< bool C_ > struct bool_
{
static const bool value = C_;
typedef integral_c_tag tag;
typedef bool_ type;
typedef bool value_type;
operator bool() const ;
};
template< bool C_ >
bool const bool_<C_>::value;
}
#define BOOST_MPL_AUX_NA_FWD_HPP_INCLUDED
namespace mpl_ {
struct na
{
typedef na type;
enum { value = 0 };
};
}
namespace boost { namespace mpl { using ::mpl_::na; } }
#define BOOST_MPL_AUX_CONFIG_CTPS_HPP_INCLUDED
namespace boost { namespace mpl {
template< typename T >
struct is_na
: false_
{
};
template<>
struct is_na<na>
: true_
{
};
template< typename T >
struct is_not_na
: true_
{
};
template<>
struct is_not_na<na>
: false_
{
};
template< typename T, typename U > struct if_na
{
typedef T type;
};
template< typename U > struct if_na<na,U>
{
typedef U type;
};
}}
#define BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_TTP_HPP_INCLUDED
#define BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING
#define BOOST_MPL_INT_HPP_INCLUDED
#define BOOST_MPL_INT_FWD_HPP_INCLUDED
#define BOOST_MPL_AUX_NTTP_DECL_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_NTTP_HPP_INCLUDED
#define BOOST_MPL_AUX_NTTP_DECL(T,x) T x
namespace mpl_ {
template< int N > struct int_;
}
namespace boost { namespace mpl { using ::mpl_::int_; } }
#define AUX_WRAPPER_VALUE_TYPE int
#define BOOST_PREPROCESSOR_CAT_HPP
#define BOOST_PREPROCESSOR_CONFIG_CONFIG_HPP
#define BOOST_PP_CONFIG_STRICT() 0x0001
#define BOOST_PP_CONFIG_IDEAL() 0x0002
#define BOOST_PP_CONFIG_MSVC() 0x0004
#define BOOST_PP_CONFIG_MWCC() 0x0008
#define BOOST_PP_CONFIG_BCC() 0x0010
#define BOOST_PP_CONFIG_EDG() 0x0020
#define BOOST_PP_CONFIG_DMC() 0x0040
#define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT())
#define BOOST_PP_CONFIG_EXTENDED_LINE_INFO 0
#define BOOST_PP_CONFIG_ERRORS 0
#define BOOST_PP_VARIADICS 1
#define BOOST_PP_CAT(a,b) BOOST_PP_CAT_I(a, b)
#define BOOST_PP_CAT_I(a,b) a ## b
#define AUX_WRAPPER_NAME BOOST_PP_CAT(AUX_WRAPPER_VALUE_TYPE,_)
#define AUX_WRAPPER_PARAMS(N) BOOST_MPL_AUX_NTTP_DECL(AUX_WRAPPER_VALUE_TYPE, N)
#define AUX_WRAPPER_INST(value) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::AUX_WRAPPER_NAME< value >
namespace mpl_ {
template< int N >
struct int_
{
static const int value = N;
typedef int_ type;
typedef int value_type;
typedef integral_c_tag tag;
typedef mpl_::int_< static_cast<int>((value + 1)) > next;
typedef mpl_::int_< static_cast<int>((value - 1)) > prior;
operator int() const ;
};
template< int N >
int const mpl_::int_< N >::value;
}
#undef AUX_WRAPPER_NAME
#undef AUX_WRAPPER_PARAMS
#undef AUX_WRAPPER_INST
#undef AUX_WRAPPER_VALUE_TYPE
#define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED
#define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(param) , param
#define BOOST_MPL_AUX_TEMPLATE_ARITY_FWD_HPP_INCLUDED
namespace boost { namespace mpl { namespace aux {
template< typename F > struct template_arity;
}}}
namespace boost { namespace mpl {
template<
typename T = na
, typename Tag = void_
, typename Arity = int_< aux::template_arity<T>::value >
>
struct lambda;
}}
#define BOOST_MPL_AUX_ARITY_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_DTP_HPP_INCLUDED
#define BOOST_MPL_AUX_PREPROCESSOR_PARAMS_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_PREPROCESSOR_HPP_INCLUDED
#define BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES
#define BOOST_PREPROCESSOR_COMMA_IF_HPP
#define BOOST_PREPROCESSOR_PUNCTUATION_COMMA_IF_HPP
#define BOOST_PREPROCESSOR_CONTROL_IF_HPP
#define BOOST_PREPROCESSOR_CONTROL_IIF_HPP
#define BOOST_PP_IIF(bit,t,f) BOOST_PP_IIF_I(bit, t, f)
#define BOOST_PP_IIF_I(bit,t,f) BOOST_PP_IIF_ ## bit(t, f)
#define BOOST_PP_IIF_0(t,f) f
#define BOOST_PP_IIF_1(t,f) t
#define BOOST_PREPROCESSOR_LOGICAL_BOOL_HPP
#define BOOST_PP_BOOL(x) BOOST_PP_BOOL_I(x)
#define BOOST_PP_BOOL_I(x) BOOST_PP_BOOL_ ## x
#define BOOST_PP_BOOL_0 0
#define BOOST_PP_BOOL_1 1
#define BOOST_PP_BOOL_2 1
#define BOOST_PP_BOOL_3 1
#define BOOST_PP_BOOL_4 1
#define BOOST_PP_BOOL_5 1
#define BOOST_PP_BOOL_6 1
#define BOOST_PP_BOOL_7 1
#define BOOST_PP_BOOL_8 1
#define BOOST_PP_BOOL_9 1
#define BOOST_PP_BOOL_10 1
#define BOOST_PP_BOOL_11 1
#define BOOST_PP_BOOL_12 1
#define BOOST_PP_BOOL_13 1
#define BOOST_PP_BOOL_14 1
#define BOOST_PP_BOOL_15 1
#define BOOST_PP_BOOL_16 1
#define BOOST_PP_BOOL_17 1
#define BOOST_PP_BOOL_18 1
#define BOOST_PP_BOOL_19 1
#define BOOST_PP_BOOL_20 1
#define BOOST_PP_BOOL_21 1
#define BOOST_PP_BOOL_22 1
#define BOOST_PP_BOOL_23 1
#define BOOST_PP_BOOL_24 1
#define BOOST_PP_BOOL_25 1
#define BOOST_PP_BOOL_26 1
#define BOOST_PP_BOOL_27 1
#define BOOST_PP_BOOL_28 1
#define BOOST_PP_BOOL_29 1
#define BOOST_PP_BOOL_30 1
#define BOOST_PP_BOOL_31 1
#define BOOST_PP_BOOL_32 1
#define BOOST_PP_BOOL_33 1
#define BOOST_PP_BOOL_34 1
#define BOOST_PP_BOOL_35 1
#define BOOST_PP_BOOL_36 1
#define BOOST_PP_BOOL_37 1
#define BOOST_PP_BOOL_38 1
#define BOOST_PP_BOOL_39 1
#define BOOST_PP_BOOL_40 1
#define BOOST_PP_BOOL_41 1
#define BOOST_PP_BOOL_42 1
#define BOOST_PP_BOOL_43 1
#define BOOST_PP_BOOL_44 1
#define BOOST_PP_BOOL_45 1
#define BOOST_PP_BOOL_46 1
#define BOOST_PP_BOOL_47 1
#define BOOST_PP_BOOL_48 1
#define BOOST_PP_BOOL_49 1
#define BOOST_PP_BOOL_50 1
#define BOOST_PP_BOOL_51 1
#define BOOST_PP_BOOL_52 1
#define BOOST_PP_BOOL_53 1
#define BOOST_PP_BOOL_54 1
#define BOOST_PP_BOOL_55 1
#define BOOST_PP_BOOL_56 1
#define BOOST_PP_BOOL_57 1
#define BOOST_PP_BOOL_58 1
#define BOOST_PP_BOOL_59 1
#define BOOST_PP_BOOL_60 1
#define BOOST_PP_BOOL_61 1
#define BOOST_PP_BOOL_62 1
#define BOOST_PP_BOOL_63 1
#define BOOST_PP_BOOL_64 1
#define BOOST_PP_BOOL_65 1
#define BOOST_PP_BOOL_66 1
#define BOOST_PP_BOOL_67 1
#define BOOST_PP_BOOL_68 1
#define BOOST_PP_BOOL_69 1
#define BOOST_PP_BOOL_70 1
#define BOOST_PP_BOOL_71 1
#define BOOST_PP_BOOL_72 1
#define BOOST_PP_BOOL_73 1
#define BOOST_PP_BOOL_74 1
#define BOOST_PP_BOOL_75 1
#define BOOST_PP_BOOL_76 1
#define BOOST_PP_BOOL_77 1
#define BOOST_PP_BOOL_78 1
#define BOOST_PP_BOOL_79 1
#define BOOST_PP_BOOL_80 1
#define BOOST_PP_BOOL_81 1
#define BOOST_PP_BOOL_82 1
#define BOOST_PP_BOOL_83 1
#define BOOST_PP_BOOL_84 1
#define BOOST_PP_BOOL_85 1
#define BOOST_PP_BOOL_86 1
#define BOOST_PP_BOOL_87 1
#define BOOST_PP_BOOL_88 1
#define BOOST_PP_BOOL_89 1
#define BOOST_PP_BOOL_90 1
#define BOOST_PP_BOOL_91 1
#define BOOST_PP_BOOL_92 1
#define BOOST_PP_BOOL_93 1
#define BOOST_PP_BOOL_94 1
#define BOOST_PP_BOOL_95 1
#define BOOST_PP_BOOL_96 1
#define BOOST_PP_BOOL_97 1
#define BOOST_PP_BOOL_98 1
#define BOOST_PP_BOOL_99 1
#define BOOST_PP_BOOL_100 1
#define BOOST_PP_BOOL_101 1
#define BOOST_PP_BOOL_102 1
#define BOOST_PP_BOOL_103 1
#define BOOST_PP_BOOL_104 1
#define BOOST_PP_BOOL_105 1
#define BOOST_PP_BOOL_106 1
#define BOOST_PP_BOOL_107 1
#define BOOST_PP_BOOL_108 1
#define BOOST_PP_BOOL_109 1
#define BOOST_PP_BOOL_110 1
#define BOOST_PP_BOOL_111 1
#define BOOST_PP_BOOL_112 1
#define BOOST_PP_BOOL_113 1
#define BOOST_PP_BOOL_114 1
#define BOOST_PP_BOOL_115 1
#define BOOST_PP_BOOL_116 1
#define BOOST_PP_BOOL_117 1
#define BOOST_PP_BOOL_118 1
#define BOOST_PP_BOOL_119 1
#define BOOST_PP_BOOL_120 1
#define BOOST_PP_BOOL_121 1
#define BOOST_PP_BOOL_122 1
#define BOOST_PP_BOOL_123 1
#define BOOST_PP_BOOL_124 1
#define BOOST_PP_BOOL_125 1
#define BOOST_PP_BOOL_126 1
#define BOOST_PP_BOOL_127 1
#define BOOST_PP_BOOL_128 1
#define BOOST_PP_BOOL_129 1
#define BOOST_PP_BOOL_130 1
#define BOOST_PP_BOOL_131 1
#define BOOST_PP_BOOL_132 1
#define BOOST_PP_BOOL_133 1
#define BOOST_PP_BOOL_134 1
#define BOOST_PP_BOOL_135 1
#define BOOST_PP_BOOL_136 1
#define BOOST_PP_BOOL_137 1
#define BOOST_PP_BOOL_138 1
#define BOOST_PP_BOOL_139 1
#define BOOST_PP_BOOL_140 1
#define BOOST_PP_BOOL_141 1
#define BOOST_PP_BOOL_142 1
#define BOOST_PP_BOOL_143 1
#define BOOST_PP_BOOL_144 1
#define BOOST_PP_BOOL_145 1
#define BOOST_PP_BOOL_146 1
#define BOOST_PP_BOOL_147 1
#define BOOST_PP_BOOL_148 1
#define BOOST_PP_BOOL_149 1
#define BOOST_PP_BOOL_150 1
#define BOOST_PP_BOOL_151 1
#define BOOST_PP_BOOL_152 1
#define BOOST_PP_BOOL_153 1
#define BOOST_PP_BOOL_154 1
#define BOOST_PP_BOOL_155 1
#define BOOST_PP_BOOL_156 1
#define BOOST_PP_BOOL_157 1
#define BOOST_PP_BOOL_158 1
#define BOOST_PP_BOOL_159 1
#define BOOST_PP_BOOL_160 1
#define BOOST_PP_BOOL_161 1
#define BOOST_PP_BOOL_162 1
#define BOOST_PP_BOOL_163 1
#define BOOST_PP_BOOL_164 1
#define BOOST_PP_BOOL_165 1
#define BOOST_PP_BOOL_166 1
#define BOOST_PP_BOOL_167 1
#define BOOST_PP_BOOL_168 1
#define BOOST_PP_BOOL_169 1
#define BOOST_PP_BOOL_170 1
#define BOOST_PP_BOOL_171 1
#define BOOST_PP_BOOL_172 1
#define BOOST_PP_BOOL_173 1
#define BOOST_PP_BOOL_174 1
#define BOOST_PP_BOOL_175 1
#define BOOST_PP_BOOL_176 1
#define BOOST_PP_BOOL_177 1
#define BOOST_PP_BOOL_178 1
#define BOOST_PP_BOOL_179 1
#define BOOST_PP_BOOL_180 1
#define BOOST_PP_BOOL_181 1
#define BOOST_PP_BOOL_182 1
#define BOOST_PP_BOOL_183 1
#define BOOST_PP_BOOL_184 1
#define BOOST_PP_BOOL_185 1
#define BOOST_PP_BOOL_186 1
#define BOOST_PP_BOOL_187 1
#define BOOST_PP_BOOL_188 1
#define BOOST_PP_BOOL_189 1
#define BOOST_PP_BOOL_190 1
#define BOOST_PP_BOOL_191 1
#define BOOST_PP_BOOL_192 1
#define BOOST_PP_BOOL_193 1
#define BOOST_PP_BOOL_194 1
#define BOOST_PP_BOOL_195 1
#define BOOST_PP_BOOL_196 1
#define BOOST_PP_BOOL_197 1
#define BOOST_PP_BOOL_198 1
#define BOOST_PP_BOOL_199 1
#define BOOST_PP_BOOL_200 1
#define BOOST_PP_BOOL_201 1
#define BOOST_PP_BOOL_202 1
#define BOOST_PP_BOOL_203 1
#define BOOST_PP_BOOL_204 1
#define BOOST_PP_BOOL_205 1
#define BOOST_PP_BOOL_206 1
#define BOOST_PP_BOOL_207 1
#define BOOST_PP_BOOL_208 1
#define BOOST_PP_BOOL_209 1
#define BOOST_PP_BOOL_210 1
#define BOOST_PP_BOOL_211 1
#define BOOST_PP_BOOL_212 1
#define BOOST_PP_BOOL_213 1
#define BOOST_PP_BOOL_214 1
#define BOOST_PP_BOOL_215 1
#define BOOST_PP_BOOL_216 1
#define BOOST_PP_BOOL_217 1
#define BOOST_PP_BOOL_218 1
#define BOOST_PP_BOOL_219 1
#define BOOST_PP_BOOL_220 1
#define BOOST_PP_BOOL_221 1
#define BOOST_PP_BOOL_222 1
#define BOOST_PP_BOOL_223 1
#define BOOST_PP_BOOL_224 1
#define BOOST_PP_BOOL_225 1
#define BOOST_PP_BOOL_226 1
#define BOOST_PP_BOOL_227 1
#define BOOST_PP_BOOL_228 1
#define BOOST_PP_BOOL_229 1
#define BOOST_PP_BOOL_230 1
#define BOOST_PP_BOOL_231 1
#define BOOST_PP_BOOL_232 1
#define BOOST_PP_BOOL_233 1
#define BOOST_PP_BOOL_234 1
#define BOOST_PP_BOOL_235 1
#define BOOST_PP_BOOL_236 1
#define BOOST_PP_BOOL_237 1
#define BOOST_PP_BOOL_238 1
#define BOOST_PP_BOOL_239 1
#define BOOST_PP_BOOL_240 1
#define BOOST_PP_BOOL_241 1
#define BOOST_PP_BOOL_242 1
#define BOOST_PP_BOOL_243 1
#define BOOST_PP_BOOL_244 1
#define BOOST_PP_BOOL_245 1
#define BOOST_PP_BOOL_246 1
#define BOOST_PP_BOOL_247 1
#define BOOST_PP_BOOL_248 1
#define BOOST_PP_BOOL_249 1
#define BOOST_PP_BOOL_250 1
#define BOOST_PP_BOOL_251 1
#define BOOST_PP_BOOL_252 1
#define BOOST_PP_BOOL_253 1
#define BOOST_PP_BOOL_254 1
#define BOOST_PP_BOOL_255 1
#define BOOST_PP_BOOL_256 1
#define BOOST_PP_IF(cond,t,f) BOOST_PP_IIF(BOOST_PP_BOOL(cond), t, f)
#define BOOST_PREPROCESSOR_FACILITIES_EMPTY_HPP
#define BOOST_PP_EMPTY()
#define BOOST_PREPROCESSOR_PUNCTUATION_COMMA_HPP
#define BOOST_PP_COMMA() ,
#define BOOST_PP_COMMA_IF(cond) BOOST_PP_IF(cond, BOOST_PP_COMMA, BOOST_PP_EMPTY)()
#define BOOST_PREPROCESSOR_REPEAT_HPP
#define BOOST_PREPROCESSOR_REPETITION_REPEAT_HPP
#define BOOST_PREPROCESSOR_DEBUG_ERROR_HPP
#define BOOST_PP_ERROR_0x0000 BOOST_PP_ERROR(0x0000, BOOST_PP_INDEX_OUT_OF_BOUNDS)
#define BOOST_PP_ERROR_0x0001 BOOST_PP_ERROR(0x0001, BOOST_PP_WHILE_OVERFLOW)
#define BOOST_PP_ERROR_0x0002 BOOST_PP_ERROR(0x0002, BOOST_PP_FOR_OVERFLOW)
#define BOOST_PP_ERROR_0x0003 BOOST_PP_ERROR(0x0003, BOOST_PP_REPEAT_OVERFLOW)
#define BOOST_PP_ERROR_0x0004 BOOST_PP_ERROR(0x0004, BOOST_PP_LIST_FOLD_OVERFLOW)
#define BOOST_PP_ERROR_0x0005 BOOST_PP_ERROR(0x0005, BOOST_PP_SEQ_FOLD_OVERFLOW)
#define BOOST_PP_ERROR_0x0006 BOOST_PP_ERROR(0x0006, BOOST_PP_ARITHMETIC_OVERFLOW)
#define BOOST_PP_ERROR_0x0007 BOOST_PP_ERROR(0x0007, BOOST_PP_DIVISION_BY_ZERO)
#define BOOST_PREPROCESSOR_DETAIL_AUTO_REC_HPP
#define BOOST_PP_AUTO_REC(pred,n) BOOST_PP_NODE_ENTRY_ ## n(pred)
#define BOOST_PP_NODE_ENTRY_256(p) BOOST_PP_NODE_128(p)(p)(p)(p)(p)(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_128(p) BOOST_PP_NODE_64(p)(p)(p)(p)(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_64(p) BOOST_PP_NODE_32(p)(p)(p)(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_32(p) BOOST_PP_NODE_16(p)(p)(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_16(p) BOOST_PP_NODE_8(p)(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_8(p) BOOST_PP_NODE_4(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_4(p) BOOST_PP_NODE_2(p)(p)
#define BOOST_PP_NODE_ENTRY_2(p) BOOST_PP_NODE_1(p)
#define BOOST_PP_NODE_128(p) BOOST_PP_IIF(p(128), BOOST_PP_NODE_64, BOOST_PP_NODE_192)
#define BOOST_PP_NODE_64(p) BOOST_PP_IIF(p(64), BOOST_PP_NODE_32, BOOST_PP_NODE_96)
#define BOOST_PP_NODE_32(p) BOOST_PP_IIF(p(32), BOOST_PP_NODE_16, BOOST_PP_NODE_48)
#define BOOST_PP_NODE_16(p) BOOST_PP_IIF(p(16), BOOST_PP_NODE_8, BOOST_PP_NODE_24)
#define BOOST_PP_NODE_8(p) BOOST_PP_IIF(p(8), BOOST_PP_NODE_4, BOOST_PP_NODE_12)
#define BOOST_PP_NODE_4(p) BOOST_PP_IIF(p(4), BOOST_PP_NODE_2, BOOST_PP_NODE_6)
#define BOOST_PP_NODE_2(p) BOOST_PP_IIF(p(2), BOOST_PP_NODE_1, BOOST_PP_NODE_3)
#define BOOST_PP_NODE_1(p) BOOST_PP_IIF(p(1), 1, 2)
#define BOOST_PP_NODE_3(p) BOOST_PP_IIF(p(3), 3, 4)
#define BOOST_PP_NODE_6(p) BOOST_PP_IIF(p(6), BOOST_PP_NODE_5, BOOST_PP_NODE_7)
#define BOOST_PP_NODE_5(p) BOOST_PP_IIF(p(5), 5, 6)
#define BOOST_PP_NODE_7(p) BOOST_PP_IIF(p(7), 7, 8)
#define BOOST_PP_NODE_12(p) BOOST_PP_IIF(p(12), BOOST_PP_NODE_10, BOOST_PP_NODE_14)
#define BOOST_PP_NODE_10(p) BOOST_PP_IIF(p(10), BOOST_PP_NODE_9, BOOST_PP_NODE_11)
#define BOOST_PP_NODE_9(p) BOOST_PP_IIF(p(9), 9, 10)
#define BOOST_PP_NODE_11(p) BOOST_PP_IIF(p(11), 11, 12)
#define BOOST_PP_NODE_14(p) BOOST_PP_IIF(p(14), BOOST_PP_NODE_13, BOOST_PP_NODE_15)
#define BOOST_PP_NODE_13(p) BOOST_PP_IIF(p(13), 13, 14)
#define BOOST_PP_NODE_15(p) BOOST_PP_IIF(p(15), 15, 16)
#define BOOST_PP_NODE_24(p) BOOST_PP_IIF(p(24), BOOST_PP_NODE_20, BOOST_PP_NODE_28)
#define BOOST_PP_NODE_20(p) BOOST_PP_IIF(p(20), BOOST_PP_NODE_18, BOOST_PP_NODE_22)
#define BOOST_PP_NODE_18(p) BOOST_PP_IIF(p(18), BOOST_PP_NODE_17, BOOST_PP_NODE_19)
#define BOOST_PP_NODE_17(p) BOOST_PP_IIF(p(17), 17, 18)
#define BOOST_PP_NODE_19(p) BOOST_PP_IIF(p(19), 19, 20)
#define BOOST_PP_NODE_22(p) BOOST_PP_IIF(p(22), BOOST_PP_NODE_21, BOOST_PP_NODE_23)
#define BOOST_PP_NODE_21(p) BOOST_PP_IIF(p(21), 21, 22)
#define BOOST_PP_NODE_23(p) BOOST_PP_IIF(p(23), 23, 24)
#define BOOST_PP_NODE_28(p) BOOST_PP_IIF(p(28), BOOST_PP_NODE_26, BOOST_PP_NODE_30)
#define BOOST_PP_NODE_26(p) BOOST_PP_IIF(p(26), BOOST_PP_NODE_25, BOOST_PP_NODE_27)
#define BOOST_PP_NODE_25(p) BOOST_PP_IIF(p(25), 25, 26)
#define BOOST_PP_NODE_27(p) BOOST_PP_IIF(p(27), 27, 28)
#define BOOST_PP_NODE_30(p) BOOST_PP_IIF(p(30), BOOST_PP_NODE_29, BOOST_PP_NODE_31)
#define BOOST_PP_NODE_29(p) BOOST_PP_IIF(p(29), 29, 30)
#define BOOST_PP_NODE_31(p) BOOST_PP_IIF(p(31), 31, 32)
#define BOOST_PP_NODE_48(p) BOOST_PP_IIF(p(48), BOOST_PP_NODE_40, BOOST_PP_NODE_56)
#define BOOST_PP_NODE_40(p) BOOST_PP_IIF(p(40), BOOST_PP_NODE_36, BOOST_PP_NODE_44)
#define BOOST_PP_NODE_36(p) BOOST_PP_IIF(p(36), BOOST_PP_NODE_34, BOOST_PP_NODE_38)
#define BOOST_PP_NODE_34(p) BOOST_PP_IIF(p(34), BOOST_PP_NODE_33, BOOST_PP_NODE_35)
#define BOOST_PP_NODE_33(p) BOOST_PP_IIF(p(33), 33, 34)
#define BOOST_PP_NODE_35(p) BOOST_PP_IIF(p(35), 35, 36)
#define BOOST_PP_NODE_38(p) BOOST_PP_IIF(p(38), BOOST_PP_NODE_37, BOOST_PP_NODE_39)
#define BOOST_PP_NODE_37(p) BOOST_PP_IIF(p(37), 37, 38)
#define BOOST_PP_NODE_39(p) BOOST_PP_IIF(p(39), 39, 40)
#define BOOST_PP_NODE_44(p) BOOST_PP_IIF(p(44), BOOST_PP_NODE_42, BOOST_PP_NODE_46)
#define BOOST_PP_NODE_42(p) BOOST_PP_IIF(p(42), BOOST_PP_NODE_41, BOOST_PP_NODE_43)
#define BOOST_PP_NODE_41(p) BOOST_PP_IIF(p(41), 41, 42)
#define BOOST_PP_NODE_43(p) BOOST_PP_IIF(p(43), 43, 44)
#define BOOST_PP_NODE_46(p) BOOST_PP_IIF(p(46), BOOST_PP_NODE_45, BOOST_PP_NODE_47)
#define BOOST_PP_NODE_45(p) BOOST_PP_IIF(p(45), 45, 46)
#define BOOST_PP_NODE_47(p) BOOST_PP_IIF(p(47), 47, 48)
#define BOOST_PP_NODE_56(p) BOOST_PP_IIF(p(56), BOOST_PP_NODE_52, BOOST_PP_NODE_60)
#define BOOST_PP_NODE_52(p) BOOST_PP_IIF(p(52), BOOST_PP_NODE_50, BOOST_PP_NODE_54)
#define BOOST_PP_NODE_50(p) BOOST_PP_IIF(p(50), BOOST_PP_NODE_49, BOOST_PP_NODE_51)
#define BOOST_PP_NODE_49(p) BOOST_PP_IIF(p(49), 49, 50)
#define BOOST_PP_NODE_51(p) BOOST_PP_IIF(p(51), 51, 52)
#define BOOST_PP_NODE_54(p) BOOST_PP_IIF(p(54), BOOST_PP_NODE_53, BOOST_PP_NODE_55)
#define BOOST_PP_NODE_53(p) BOOST_PP_IIF(p(53), 53, 54)
#define BOOST_PP_NODE_55(p) BOOST_PP_IIF(p(55), 55, 56)
#define BOOST_PP_NODE_60(p) BOOST_PP_IIF(p(60), BOOST_PP_NODE_58, BOOST_PP_NODE_62)
#define BOOST_PP_NODE_58(p) BOOST_PP_IIF(p(58), BOOST_PP_NODE_57, BOOST_PP_NODE_59)
#define BOOST_PP_NODE_57(p) BOOST_PP_IIF(p(57), 57, 58)
#define BOOST_PP_NODE_59(p) BOOST_PP_IIF(p(59), 59, 60)
#define BOOST_PP_NODE_62(p) BOOST_PP_IIF(p(62), BOOST_PP_NODE_61, BOOST_PP_NODE_63)
#define BOOST_PP_NODE_61(p) BOOST_PP_IIF(p(61), 61, 62)
#define BOOST_PP_NODE_63(p) BOOST_PP_IIF(p(63), 63, 64)
#define BOOST_PP_NODE_96(p) BOOST_PP_IIF(p(96), BOOST_PP_NODE_80, BOOST_PP_NODE_112)
#define BOOST_PP_NODE_80(p) BOOST_PP_IIF(p(80), BOOST_PP_NODE_72, BOOST_PP_NODE_88)
#define BOOST_PP_NODE_72(p) BOOST_PP_IIF(p(72), BOOST_PP_NODE_68, BOOST_PP_NODE_76)
#define BOOST_PP_NODE_68(p) BOOST_PP_IIF(p(68), BOOST_PP_NODE_66, BOOST_PP_NODE_70)
#define BOOST_PP_NODE_66(p) BOOST_PP_IIF(p(66), BOOST_PP_NODE_65, BOOST_PP_NODE_67)
#define BOOST_PP_NODE_65(p) BOOST_PP_IIF(p(65), 65, 66)
#define BOOST_PP_NODE_67(p) BOOST_PP_IIF(p(67), 67, 68)
#define BOOST_PP_NODE_70(p) BOOST_PP_IIF(p(70), BOOST_PP_NODE_69, BOOST_PP_NODE_71)
#define BOOST_PP_NODE_69(p) BOOST_PP_IIF(p(69), 69, 70)
#define BOOST_PP_NODE_71(p) BOOST_PP_IIF(p(71), 71, 72)
#define BOOST_PP_NODE_76(p) BOOST_PP_IIF(p(76), BOOST_PP_NODE_74, BOOST_PP_NODE_78)
#define BOOST_PP_NODE_74(p) BOOST_PP_IIF(p(74), BOOST_PP_NODE_73, BOOST_PP_NODE_75)
#define BOOST_PP_NODE_73(p) BOOST_PP_IIF(p(73), 73, 74)
#define BOOST_PP_NODE_75(p) BOOST_PP_IIF(p(75), 75, 76)
#define BOOST_PP_NODE_78(p) BOOST_PP_IIF(p(78), BOOST_PP_NODE_77, BOOST_PP_NODE_79)
#define BOOST_PP_NODE_77(p) BOOST_PP_IIF(p(77), 77, 78)
#define BOOST_PP_NODE_79(p) BOOST_PP_IIF(p(79), 79, 80)
#define BOOST_PP_NODE_88(p) BOOST_PP_IIF(p(88), BOOST_PP_NODE_84, BOOST_PP_NODE_92)
#define BOOST_PP_NODE_84(p) BOOST_PP_IIF(p(84), BOOST_PP_NODE_82, BOOST_PP_NODE_86)
#define BOOST_PP_NODE_82(p) BOOST_PP_IIF(p(82), BOOST_PP_NODE_81, BOOST_PP_NODE_83)
#define BOOST_PP_NODE_81(p) BOOST_PP_IIF(p(81), 81, 82)
#define BOOST_PP_NODE_83(p) BOOST_PP_IIF(p(83), 83, 84)
#define BOOST_PP_NODE_86(p) BOOST_PP_IIF(p(86), BOOST_PP_NODE_85, BOOST_PP_NODE_87)
#define BOOST_PP_NODE_85(p) BOOST_PP_IIF(p(85), 85, 86)
#define BOOST_PP_NODE_87(p) BOOST_PP_IIF(p(87), 87, 88)
#define BOOST_PP_NODE_92(p) BOOST_PP_IIF(p(92), BOOST_PP_NODE_90, BOOST_PP_NODE_94)
#define BOOST_PP_NODE_90(p) BOOST_PP_IIF(p(90), BOOST_PP_NODE_89, BOOST_PP_NODE_91)
#define BOOST_PP_NODE_89(p) BOOST_PP_IIF(p(89), 89, 90)
#define BOOST_PP_NODE_91(p) BOOST_PP_IIF(p(91), 91, 92)
#define BOOST_PP_NODE_94(p) BOOST_PP_IIF(p(94), BOOST_PP_NODE_93, BOOST_PP_NODE_95)
#define BOOST_PP_NODE_93(p) BOOST_PP_IIF(p(93), 93, 94)
#define BOOST_PP_NODE_95(p) BOOST_PP_IIF(p(95), 95, 96)
#define BOOST_PP_NODE_112(p) BOOST_PP_IIF(p(112), BOOST_PP_NODE_104, BOOST_PP_NODE_120)
#define BOOST_PP_NODE_104(p) BOOST_PP_IIF(p(104), BOOST_PP_NODE_100, BOOST_PP_NODE_108)
#define BOOST_PP_NODE_100(p) BOOST_PP_IIF(p(100), BOOST_PP_NODE_98, BOOST_PP_NODE_102)
#define BOOST_PP_NODE_98(p) BOOST_PP_IIF(p(98), BOOST_PP_NODE_97, BOOST_PP_NODE_99)
#define BOOST_PP_NODE_97(p) BOOST_PP_IIF(p(97), 97, 98)
#define BOOST_PP_NODE_99(p) BOOST_PP_IIF(p(99), 99, 100)
#define BOOST_PP_NODE_102(p) BOOST_PP_IIF(p(102), BOOST_PP_NODE_101, BOOST_PP_NODE_103)
#define BOOST_PP_NODE_101(p) BOOST_PP_IIF(p(101), 101, 102)
#define BOOST_PP_NODE_103(p) BOOST_PP_IIF(p(103), 103, 104)
#define BOOST_PP_NODE_108(p) BOOST_PP_IIF(p(108), BOOST_PP_NODE_106, BOOST_PP_NODE_110)
#define BOOST_PP_NODE_106(p) BOOST_PP_IIF(p(106), BOOST_PP_NODE_105, BOOST_PP_NODE_107)
#define BOOST_PP_NODE_105(p) BOOST_PP_IIF(p(105), 105, 106)
#define BOOST_PP_NODE_107(p) BOOST_PP_IIF(p(107), 107, 108)
#define BOOST_PP_NODE_110(p) BOOST_PP_IIF(p(110), BOOST_PP_NODE_109, BOOST_PP_NODE_111)
#define BOOST_PP_NODE_109(p) BOOST_PP_IIF(p(109), 109, 110)
#define BOOST_PP_NODE_111(p) BOOST_PP_IIF(p(111), 111, 112)
#define BOOST_PP_NODE_120(p) BOOST_PP_IIF(p(120), BOOST_PP_NODE_116, BOOST_PP_NODE_124)
#define BOOST_PP_NODE_116(p) BOOST_PP_IIF(p(116), BOOST_PP_NODE_114, BOOST_PP_NODE_118)
#define BOOST_PP_NODE_114(p) BOOST_PP_IIF(p(114), BOOST_PP_NODE_113, BOOST_PP_NODE_115)
#define BOOST_PP_NODE_113(p) BOOST_PP_IIF(p(113), 113, 114)
#define BOOST_PP_NODE_115(p) BOOST_PP_IIF(p(115), 115, 116)
#define BOOST_PP_NODE_118(p) BOOST_PP_IIF(p(118), BOOST_PP_NODE_117, BOOST_PP_NODE_119)
#define BOOST_PP_NODE_117(p) BOOST_PP_IIF(p(117), 117, 118)
#define BOOST_PP_NODE_119(p) BOOST_PP_IIF(p(119), 119, 120)
#define BOOST_PP_NODE_124(p) BOOST_PP_IIF(p(124), BOOST_PP_NODE_122, BOOST_PP_NODE_126)
#define BOOST_PP_NODE_122(p) BOOST_PP_IIF(p(122), BOOST_PP_NODE_121, BOOST_PP_NODE_123)
#define BOOST_PP_NODE_121(p) BOOST_PP_IIF(p(121), 121, 122)
#define BOOST_PP_NODE_123(p) BOOST_PP_IIF(p(123), 123, 124)
#define BOOST_PP_NODE_126(p) BOOST_PP_IIF(p(126), BOOST_PP_NODE_125, BOOST_PP_NODE_127)
#define BOOST_PP_NODE_125(p) BOOST_PP_IIF(p(125), 125, 126)
#define BOOST_PP_NODE_127(p) BOOST_PP_IIF(p(127), 127, 128)
#define BOOST_PP_NODE_192(p) BOOST_PP_IIF(p(192), BOOST_PP_NODE_160, BOOST_PP_NODE_224)
#define BOOST_PP_NODE_160(p) BOOST_PP_IIF(p(160), BOOST_PP_NODE_144, BOOST_PP_NODE_176)
#define BOOST_PP_NODE_144(p) BOOST_PP_IIF(p(144), BOOST_PP_NODE_136, BOOST_PP_NODE_152)
#define BOOST_PP_NODE_136(p) BOOST_PP_IIF(p(136), BOOST_PP_NODE_132, BOOST_PP_NODE_140)
#define BOOST_PP_NODE_132(p) BOOST_PP_IIF(p(132), BOOST_PP_NODE_130, BOOST_PP_NODE_134)
#define BOOST_PP_NODE_130(p) BOOST_PP_IIF(p(130), BOOST_PP_NODE_129, BOOST_PP_NODE_131)
#define BOOST_PP_NODE_129(p) BOOST_PP_IIF(p(129), 129, 130)
#define BOOST_PP_NODE_131(p) BOOST_PP_IIF(p(131), 131, 132)
#define BOOST_PP_NODE_134(p) BOOST_PP_IIF(p(134), BOOST_PP_NODE_133, BOOST_PP_NODE_135)
#define BOOST_PP_NODE_133(p) BOOST_PP_IIF(p(133), 133, 134)
#define BOOST_PP_NODE_135(p) BOOST_PP_IIF(p(135), 135, 136)
#define BOOST_PP_NODE_140(p) BOOST_PP_IIF(p(140), BOOST_PP_NODE_138, BOOST_PP_NODE_142)
#define BOOST_PP_NODE_138(p) BOOST_PP_IIF(p(138), BOOST_PP_NODE_137, BOOST_PP_NODE_139)
#define BOOST_PP_NODE_137(p) BOOST_PP_IIF(p(137), 137, 138)
#define BOOST_PP_NODE_139(p) BOOST_PP_IIF(p(139), 139, 140)
#define BOOST_PP_NODE_142(p) BOOST_PP_IIF(p(142), BOOST_PP_NODE_141, BOOST_PP_NODE_143)
#define BOOST_PP_NODE_141(p) BOOST_PP_IIF(p(141), 141, 142)
#define BOOST_PP_NODE_143(p) BOOST_PP_IIF(p(143), 143, 144)
#define BOOST_PP_NODE_152(p) BOOST_PP_IIF(p(152), BOOST_PP_NODE_148, BOOST_PP_NODE_156)
#define BOOST_PP_NODE_148(p) BOOST_PP_IIF(p(148), BOOST_PP_NODE_146, BOOST_PP_NODE_150)
#define BOOST_PP_NODE_146(p) BOOST_PP_IIF(p(146), BOOST_PP_NODE_145, BOOST_PP_NODE_147)
#define BOOST_PP_NODE_145(p) BOOST_PP_IIF(p(145), 145, 146)
#define BOOST_PP_NODE_147(p) BOOST_PP_IIF(p(147), 147, 148)
#define BOOST_PP_NODE_150(p) BOOST_PP_IIF(p(150), BOOST_PP_NODE_149, BOOST_PP_NODE_151)
#define BOOST_PP_NODE_149(p) BOOST_PP_IIF(p(149), 149, 150)
#define BOOST_PP_NODE_151(p) BOOST_PP_IIF(p(151), 151, 152)
#define BOOST_PP_NODE_156(p) BOOST_PP_IIF(p(156), BOOST_PP_NODE_154, BOOST_PP_NODE_158)
#define BOOST_PP_NODE_154(p) BOOST_PP_IIF(p(154), BOOST_PP_NODE_153, BOOST_PP_NODE_155)
#define BOOST_PP_NODE_153(p) BOOST_PP_IIF(p(153), 153, 154)
#define BOOST_PP_NODE_155(p) BOOST_PP_IIF(p(155), 155, 156)
#define BOOST_PP_NODE_158(p) BOOST_PP_IIF(p(158), BOOST_PP_NODE_157, BOOST_PP_NODE_159)
#define BOOST_PP_NODE_157(p) BOOST_PP_IIF(p(157), 157, 158)
#define BOOST_PP_NODE_159(p) BOOST_PP_IIF(p(159), 159, 160)
#define BOOST_PP_NODE_176(p) BOOST_PP_IIF(p(176), BOOST_PP_NODE_168, BOOST_PP_NODE_184)
#define BOOST_PP_NODE_168(p) BOOST_PP_IIF(p(168), BOOST_PP_NODE_164, BOOST_PP_NODE_172)
#define BOOST_PP_NODE_164(p) BOOST_PP_IIF(p(164), BOOST_PP_NODE_162, BOOST_PP_NODE_166)
#define BOOST_PP_NODE_162(p) BOOST_PP_IIF(p(162), BOOST_PP_NODE_161, BOOST_PP_NODE_163)
#define BOOST_PP_NODE_161(p) BOOST_PP_IIF(p(161), 161, 162)
#define BOOST_PP_NODE_163(p) BOOST_PP_IIF(p(163), 163, 164)
#define BOOST_PP_NODE_166(p) BOOST_PP_IIF(p(166), BOOST_PP_NODE_165, BOOST_PP_NODE_167)
#define BOOST_PP_NODE_165(p) BOOST_PP_IIF(p(165), 165, 166)
#define BOOST_PP_NODE_167(p) BOOST_PP_IIF(p(167), 167, 168)
#define BOOST_PP_NODE_172(p) BOOST_PP_IIF(p(172), BOOST_PP_NODE_170, BOOST_PP_NODE_174)
#define BOOST_PP_NODE_170(p) BOOST_PP_IIF(p(170), BOOST_PP_NODE_169, BOOST_PP_NODE_171)
#define BOOST_PP_NODE_169(p) BOOST_PP_IIF(p(169), 169, 170)
#define BOOST_PP_NODE_171(p) BOOST_PP_IIF(p(171), 171, 172)
#define BOOST_PP_NODE_174(p) BOOST_PP_IIF(p(174), BOOST_PP_NODE_173, BOOST_PP_NODE_175)
#define BOOST_PP_NODE_173(p) BOOST_PP_IIF(p(173), 173, 174)
#define BOOST_PP_NODE_175(p) BOOST_PP_IIF(p(175), 175, 176)
#define BOOST_PP_NODE_184(p) BOOST_PP_IIF(p(184), BOOST_PP_NODE_180, BOOST_PP_NODE_188)
#define BOOST_PP_NODE_180(p) BOOST_PP_IIF(p(180), BOOST_PP_NODE_178, BOOST_PP_NODE_182)
#define BOOST_PP_NODE_178(p) BOOST_PP_IIF(p(178), BOOST_PP_NODE_177, BOOST_PP_NODE_179)
#define BOOST_PP_NODE_177(p) BOOST_PP_IIF(p(177), 177, 178)
#define BOOST_PP_NODE_179(p) BOOST_PP_IIF(p(179), 179, 180)
#define BOOST_PP_NODE_182(p) BOOST_PP_IIF(p(182), BOOST_PP_NODE_181, BOOST_PP_NODE_183)
#define BOOST_PP_NODE_181(p) BOOST_PP_IIF(p(181), 181, 182)
#define BOOST_PP_NODE_183(p) BOOST_PP_IIF(p(183), 183, 184)
#define BOOST_PP_NODE_188(p) BOOST_PP_IIF(p(188), BOOST_PP_NODE_186, BOOST_PP_NODE_190)
#define BOOST_PP_NODE_186(p) BOOST_PP_IIF(p(186), BOOST_PP_NODE_185, BOOST_PP_NODE_187)
#define BOOST_PP_NODE_185(p) BOOST_PP_IIF(p(185), 185, 186)
#define BOOST_PP_NODE_187(p) BOOST_PP_IIF(p(187), 187, 188)
#define BOOST_PP_NODE_190(p) BOOST_PP_IIF(p(190), BOOST_PP_NODE_189, BOOST_PP_NODE_191)
#define BOOST_PP_NODE_189(p) BOOST_PP_IIF(p(189), 189, 190)
#define BOOST_PP_NODE_191(p) BOOST_PP_IIF(p(191), 191, 192)
#define BOOST_PP_NODE_224(p) BOOST_PP_IIF(p(224), BOOST_PP_NODE_208, BOOST_PP_NODE_240)
#define BOOST_PP_NODE_208(p) BOOST_PP_IIF(p(208), BOOST_PP_NODE_200, BOOST_PP_NODE_216)
#define BOOST_PP_NODE_200(p) BOOST_PP_IIF(p(200), BOOST_PP_NODE_196, BOOST_PP_NODE_204)
#define BOOST_PP_NODE_196(p) BOOST_PP_IIF(p(196), BOOST_PP_NODE_194, BOOST_PP_NODE_198)
#define BOOST_PP_NODE_194(p) BOOST_PP_IIF(p(194), BOOST_PP_NODE_193, BOOST_PP_NODE_195)
#define BOOST_PP_NODE_193(p) BOOST_PP_IIF(p(193), 193, 194)
#define BOOST_PP_NODE_195(p) BOOST_PP_IIF(p(195), 195, 196)
#define BOOST_PP_NODE_198(p) BOOST_PP_IIF(p(198), BOOST_PP_NODE_197, BOOST_PP_NODE_199)
#define BOOST_PP_NODE_197(p) BOOST_PP_IIF(p(197), 197, 198)
#define BOOST_PP_NODE_199(p) BOOST_PP_IIF(p(199), 199, 200)
#define BOOST_PP_NODE_204(p) BOOST_PP_IIF(p(204), BOOST_PP_NODE_202, BOOST_PP_NODE_206)
#define BOOST_PP_NODE_202(p) BOOST_PP_IIF(p(202), BOOST_PP_NODE_201, BOOST_PP_NODE_203)
#define BOOST_PP_NODE_201(p) BOOST_PP_IIF(p(201), 201, 202)
#define BOOST_PP_NODE_203(p) BOOST_PP_IIF(p(203), 203, 204)
#define BOOST_PP_NODE_206(p) BOOST_PP_IIF(p(206), BOOST_PP_NODE_205, BOOST_PP_NODE_207)
#define BOOST_PP_NODE_205(p) BOOST_PP_IIF(p(205), 205, 206)
#define BOOST_PP_NODE_207(p) BOOST_PP_IIF(p(207), 207, 208)
#define BOOST_PP_NODE_216(p) BOOST_PP_IIF(p(216), BOOST_PP_NODE_212, BOOST_PP_NODE_220)
#define BOOST_PP_NODE_212(p) BOOST_PP_IIF(p(212), BOOST_PP_NODE_210, BOOST_PP_NODE_214)
#define BOOST_PP_NODE_210(p) BOOST_PP_IIF(p(210), BOOST_PP_NODE_209, BOOST_PP_NODE_211)
#define BOOST_PP_NODE_209(p) BOOST_PP_IIF(p(209), 209, 210)
#define BOOST_PP_NODE_211(p) BOOST_PP_IIF(p(211), 211, 212)
#define BOOST_PP_NODE_214(p) BOOST_PP_IIF(p(214), BOOST_PP_NODE_213, BOOST_PP_NODE_215)
#define BOOST_PP_NODE_213(p) BOOST_PP_IIF(p(213), 213, 214)
#define BOOST_PP_NODE_215(p) BOOST_PP_IIF(p(215), 215, 216)
#define BOOST_PP_NODE_220(p) BOOST_PP_IIF(p(220), BOOST_PP_NODE_218, BOOST_PP_NODE_222)
#define BOOST_PP_NODE_218(p) BOOST_PP_IIF(p(218), BOOST_PP_NODE_217, BOOST_PP_NODE_219)
#define BOOST_PP_NODE_217(p) BOOST_PP_IIF(p(217), 217, 218)
#define BOOST_PP_NODE_219(p) BOOST_PP_IIF(p(219), 219, 220)
#define BOOST_PP_NODE_222(p) BOOST_PP_IIF(p(222), BOOST_PP_NODE_221, BOOST_PP_NODE_223)
#define BOOST_PP_NODE_221(p) BOOST_PP_IIF(p(221), 221, 222)
#define BOOST_PP_NODE_223(p) BOOST_PP_IIF(p(223), 223, 224)
#define BOOST_PP_NODE_240(p) BOOST_PP_IIF(p(240), BOOST_PP_NODE_232, BOOST_PP_NODE_248)
#define BOOST_PP_NODE_232(p) BOOST_PP_IIF(p(232), BOOST_PP_NODE_228, BOOST_PP_NODE_236)
#define BOOST_PP_NODE_228(p) BOOST_PP_IIF(p(228), BOOST_PP_NODE_226, BOOST_PP_NODE_230)
#define BOOST_PP_NODE_226(p) BOOST_PP_IIF(p(226), BOOST_PP_NODE_225, BOOST_PP_NODE_227)
#define BOOST_PP_NODE_225(p) BOOST_PP_IIF(p(225), 225, 226)
#define BOOST_PP_NODE_227(p) BOOST_PP_IIF(p(227), 227, 228)
#define BOOST_PP_NODE_230(p) BOOST_PP_IIF(p(230), BOOST_PP_NODE_229, BOOST_PP_NODE_231)
#define BOOST_PP_NODE_229(p) BOOST_PP_IIF(p(229), 229, 230)
#define BOOST_PP_NODE_231(p) BOOST_PP_IIF(p(231), 231, 232)
#define BOOST_PP_NODE_236(p) BOOST_PP_IIF(p(236), BOOST_PP_NODE_234, BOOST_PP_NODE_238)
#define BOOST_PP_NODE_234(p) BOOST_PP_IIF(p(234), BOOST_PP_NODE_233, BOOST_PP_NODE_235)
#define BOOST_PP_NODE_233(p) BOOST_PP_IIF(p(233), 233, 234)
#define BOOST_PP_NODE_235(p) BOOST_PP_IIF(p(235), 235, 236)
#define BOOST_PP_NODE_238(p) BOOST_PP_IIF(p(238), BOOST_PP_NODE_237, BOOST_PP_NODE_239)
#define BOOST_PP_NODE_237(p) BOOST_PP_IIF(p(237), 237, 238)
#define BOOST_PP_NODE_239(p) BOOST_PP_IIF(p(239), 239, 240)
#define BOOST_PP_NODE_248(p) BOOST_PP_IIF(p(248), BOOST_PP_NODE_244, BOOST_PP_NODE_252)
#define BOOST_PP_NODE_244(p) BOOST_PP_IIF(p(244), BOOST_PP_NODE_242, BOOST_PP_NODE_246)
#define BOOST_PP_NODE_242(p) BOOST_PP_IIF(p(242), BOOST_PP_NODE_241, BOOST_PP_NODE_243)
#define BOOST_PP_NODE_241(p) BOOST_PP_IIF(p(241), 241, 242)
#define BOOST_PP_NODE_243(p) BOOST_PP_IIF(p(243), 243, 244)
#define BOOST_PP_NODE_246(p) BOOST_PP_IIF(p(246), BOOST_PP_NODE_245, BOOST_PP_NODE_247)
#define BOOST_PP_NODE_245(p) BOOST_PP_IIF(p(245), 245, 246)
#define BOOST_PP_NODE_247(p) BOOST_PP_IIF(p(247), 247, 248)
#define BOOST_PP_NODE_252(p) BOOST_PP_IIF(p(252), BOOST_PP_NODE_250, BOOST_PP_NODE_254)
#define BOOST_PP_NODE_250(p) BOOST_PP_IIF(p(250), BOOST_PP_NODE_249, BOOST_PP_NODE_251)
#define BOOST_PP_NODE_249(p) BOOST_PP_IIF(p(249), 249, 250)
#define BOOST_PP_NODE_251(p) BOOST_PP_IIF(p(251), 251, 252)
#define BOOST_PP_NODE_254(p) BOOST_PP_IIF(p(254), BOOST_PP_NODE_253, BOOST_PP_NODE_255)
#define BOOST_PP_NODE_253(p) BOOST_PP_IIF(p(253), 253, 254)
#define BOOST_PP_NODE_255(p) BOOST_PP_IIF(p(255), 255, 256)
#define BOOST_PREPROCESSOR_TUPLE_EAT_HPP
#define BOOST_PP_EAT(...)
#define BOOST_PP_TUPLE_EAT(size) BOOST_PP_EAT
#define BOOST_PP_TUPLE_EAT_1(e0)
#define BOOST_PP_TUPLE_EAT_2(e0,e1)
#define BOOST_PP_TUPLE_EAT_3(e0,e1,e2)
#define BOOST_PP_TUPLE_EAT_4(e0,e1,e2,e3)
#define BOOST_PP_TUPLE_EAT_5(e0,e1,e2,e3,e4)
#define BOOST_PP_TUPLE_EAT_6(e0,e1,e2,e3,e4,e5)
#define BOOST_PP_TUPLE_EAT_7(e0,e1,e2,e3,e4,e5,e6)
#define BOOST_PP_TUPLE_EAT_8(e0,e1,e2,e3,e4,e5,e6,e7)
#define BOOST_PP_TUPLE_EAT_9(e0,e1,e2,e3,e4,e5,e6,e7,e8)
#define BOOST_PP_TUPLE_EAT_10(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9)
#define BOOST_PP_TUPLE_EAT_11(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10)
#define BOOST_PP_TUPLE_EAT_12(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11)
#define BOOST_PP_TUPLE_EAT_13(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12)
#define BOOST_PP_TUPLE_EAT_14(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13)
#define BOOST_PP_TUPLE_EAT_15(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14)
#define BOOST_PP_TUPLE_EAT_16(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15)
#define BOOST_PP_TUPLE_EAT_17(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16)
#define BOOST_PP_TUPLE_EAT_18(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17)
#define BOOST_PP_TUPLE_EAT_19(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18)
#define BOOST_PP_TUPLE_EAT_20(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19)
#define BOOST_PP_TUPLE_EAT_21(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20)
#define BOOST_PP_TUPLE_EAT_22(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21)
#define BOOST_PP_TUPLE_EAT_23(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22)
#define BOOST_PP_TUPLE_EAT_24(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23)
#define BOOST_PP_TUPLE_EAT_25(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24)
#define BOOST_PP_TUPLE_EAT_26(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25)
#define BOOST_PP_TUPLE_EAT_27(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26)
#define BOOST_PP_TUPLE_EAT_28(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27)
#define BOOST_PP_TUPLE_EAT_29(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28)
#define BOOST_PP_TUPLE_EAT_30(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29)
#define BOOST_PP_TUPLE_EAT_31(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30)
#define BOOST_PP_TUPLE_EAT_32(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31)
#define BOOST_PP_TUPLE_EAT_33(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32)
#define BOOST_PP_TUPLE_EAT_34(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33)
#define BOOST_PP_TUPLE_EAT_35(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34)
#define BOOST_PP_TUPLE_EAT_36(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35)
#define BOOST_PP_TUPLE_EAT_37(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36)
#define BOOST_PP_TUPLE_EAT_38(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37)
#define BOOST_PP_TUPLE_EAT_39(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38)
#define BOOST_PP_TUPLE_EAT_40(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39)
#define BOOST_PP_TUPLE_EAT_41(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40)
#define BOOST_PP_TUPLE_EAT_42(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41)
#define BOOST_PP_TUPLE_EAT_43(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42)
#define BOOST_PP_TUPLE_EAT_44(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43)
#define BOOST_PP_TUPLE_EAT_45(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44)
#define BOOST_PP_TUPLE_EAT_46(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45)
#define BOOST_PP_TUPLE_EAT_47(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46)
#define BOOST_PP_TUPLE_EAT_48(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47)
#define BOOST_PP_TUPLE_EAT_49(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48)
#define BOOST_PP_TUPLE_EAT_50(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49)
#define BOOST_PP_TUPLE_EAT_51(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50)
#define BOOST_PP_TUPLE_EAT_52(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51)
#define BOOST_PP_TUPLE_EAT_53(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52)
#define BOOST_PP_TUPLE_EAT_54(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53)
#define BOOST_PP_TUPLE_EAT_55(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54)
#define BOOST_PP_TUPLE_EAT_56(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55)
#define BOOST_PP_TUPLE_EAT_57(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56)
#define BOOST_PP_TUPLE_EAT_58(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57)
#define BOOST_PP_TUPLE_EAT_59(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58)
#define BOOST_PP_TUPLE_EAT_60(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59)
#define BOOST_PP_TUPLE_EAT_61(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60)
#define BOOST_PP_TUPLE_EAT_62(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61)
#define BOOST_PP_TUPLE_EAT_63(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62)
#define BOOST_PP_TUPLE_EAT_64(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62,e63)
#define BOOST_PP_REPEAT BOOST_PP_CAT(BOOST_PP_REPEAT_, BOOST_PP_AUTO_REC(BOOST_PP_REPEAT_P, 4))
#define BOOST_PP_REPEAT_P(n) BOOST_PP_CAT(BOOST_PP_REPEAT_CHECK_, BOOST_PP_REPEAT_ ## n(1, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3, BOOST_PP_NIL))
#define BOOST_PP_REPEAT_CHECK_BOOST_PP_NIL 1
#define BOOST_PP_REPEAT_CHECK_BOOST_PP_REPEAT_1(c,m,d) 0
#define BOOST_PP_REPEAT_CHECK_BOOST_PP_REPEAT_2(c,m,d) 0
#define BOOST_PP_REPEAT_CHECK_BOOST_PP_REPEAT_3(c,m,d) 0
#define BOOST_PP_REPEAT_1(c,m,d) BOOST_PP_REPEAT_1_I(c, m, d)
#define BOOST_PP_REPEAT_2(c,m,d) BOOST_PP_REPEAT_2_I(c, m, d)
#define BOOST_PP_REPEAT_3(c,m,d) BOOST_PP_REPEAT_3_I(c, m, d)
#define BOOST_PP_REPEAT_4(c,m,d) BOOST_PP_ERROR(0x0003)
#define BOOST_PP_REPEAT_1_I(c,m,d) BOOST_PP_REPEAT_1_ ## c(m, d)
#define BOOST_PP_REPEAT_2_I(c,m,d) BOOST_PP_REPEAT_2_ ## c(m, d)
#define BOOST_PP_REPEAT_3_I(c,m,d) BOOST_PP_REPEAT_3_ ## c(m, d)
#define BOOST_PP_REPEAT_1ST BOOST_PP_REPEAT_1
#define BOOST_PP_REPEAT_2ND BOOST_PP_REPEAT_2
#define BOOST_PP_REPEAT_3RD BOOST_PP_REPEAT_3
#define BOOST_PP_REPEAT_1_0(m,d)
#define BOOST_PP_REPEAT_1_1(m,d) m(2, 0, d)
#define BOOST_PP_REPEAT_1_2(m,d) BOOST_PP_REPEAT_1_1(m, d) m(2, 1, d)
#define BOOST_PP_REPEAT_1_3(m,d) BOOST_PP_REPEAT_1_2(m, d) m(2, 2, d)
#define BOOST_PP_REPEAT_1_4(m,d) BOOST_PP_REPEAT_1_3(m, d) m(2, 3, d)
#define BOOST_PP_REPEAT_1_5(m,d) BOOST_PP_REPEAT_1_4(m, d) m(2, 4, d)
#define BOOST_PP_REPEAT_1_6(m,d) BOOST_PP_REPEAT_1_5(m, d) m(2, 5, d)
#define BOOST_PP_REPEAT_1_7(m,d) BOOST_PP_REPEAT_1_6(m, d) m(2, 6, d)
#define BOOST_PP_REPEAT_1_8(m,d) BOOST_PP_REPEAT_1_7(m, d) m(2, 7, d)
#define BOOST_PP_REPEAT_1_9(m,d) BOOST_PP_REPEAT_1_8(m, d) m(2, 8, d)
#define BOOST_PP_REPEAT_1_10(m,d) BOOST_PP_REPEAT_1_9(m, d) m(2, 9, d)
#define BOOST_PP_REPEAT_1_11(m,d) BOOST_PP_REPEAT_1_10(m, d) m(2, 10, d)
#define BOOST_PP_REPEAT_1_12(m,d) BOOST_PP_REPEAT_1_11(m, d) m(2, 11, d)
#define BOOST_PP_REPEAT_1_13(m,d) BOOST_PP_REPEAT_1_12(m, d) m(2, 12, d)
#define BOOST_PP_REPEAT_1_14(m,d) BOOST_PP_REPEAT_1_13(m, d) m(2, 13, d)
#define BOOST_PP_REPEAT_1_15(m,d) BOOST_PP_REPEAT_1_14(m, d) m(2, 14, d)
#define BOOST_PP_REPEAT_1_16(m,d) BOOST_PP_REPEAT_1_15(m, d) m(2, 15, d)
#define BOOST_PP_REPEAT_1_17(m,d) BOOST_PP_REPEAT_1_16(m, d) m(2, 16, d)
#define BOOST_PP_REPEAT_1_18(m,d) BOOST_PP_REPEAT_1_17(m, d) m(2, 17, d)
#define BOOST_PP_REPEAT_1_19(m,d) BOOST_PP_REPEAT_1_18(m, d) m(2, 18, d)
#define BOOST_PP_REPEAT_1_20(m,d) BOOST_PP_REPEAT_1_19(m, d) m(2, 19, d)
#define BOOST_PP_REPEAT_1_21(m,d) BOOST_PP_REPEAT_1_20(m, d) m(2, 20, d)
#define BOOST_PP_REPEAT_1_22(m,d) BOOST_PP_REPEAT_1_21(m, d) m(2, 21, d)
#define BOOST_PP_REPEAT_1_23(m,d) BOOST_PP_REPEAT_1_22(m, d) m(2, 22, d)
#define BOOST_PP_REPEAT_1_24(m,d) BOOST_PP_REPEAT_1_23(m, d) m(2, 23, d)
#define BOOST_PP_REPEAT_1_25(m,d) BOOST_PP_REPEAT_1_24(m, d) m(2, 24, d)
#define BOOST_PP_REPEAT_1_26(m,d) BOOST_PP_REPEAT_1_25(m, d) m(2, 25, d)
#define BOOST_PP_REPEAT_1_27(m,d) BOOST_PP_REPEAT_1_26(m, d) m(2, 26, d)
#define BOOST_PP_REPEAT_1_28(m,d) BOOST_PP_REPEAT_1_27(m, d) m(2, 27, d)
#define BOOST_PP_REPEAT_1_29(m,d) BOOST_PP_REPEAT_1_28(m, d) m(2, 28, d)
#define BOOST_PP_REPEAT_1_30(m,d) BOOST_PP_REPEAT_1_29(m, d) m(2, 29, d)
#define BOOST_PP_REPEAT_1_31(m,d) BOOST_PP_REPEAT_1_30(m, d) m(2, 30, d)
#define BOOST_PP_REPEAT_1_32(m,d) BOOST_PP_REPEAT_1_31(m, d) m(2, 31, d)
#define BOOST_PP_REPEAT_1_33(m,d) BOOST_PP_REPEAT_1_32(m, d) m(2, 32, d)
#define BOOST_PP_REPEAT_1_34(m,d) BOOST_PP_REPEAT_1_33(m, d) m(2, 33, d)
#define BOOST_PP_REPEAT_1_35(m,d) BOOST_PP_REPEAT_1_34(m, d) m(2, 34, d)
#define BOOST_PP_REPEAT_1_36(m,d) BOOST_PP_REPEAT_1_35(m, d) m(2, 35, d)
#define BOOST_PP_REPEAT_1_37(m,d) BOOST_PP_REPEAT_1_36(m, d) m(2, 36, d)
#define BOOST_PP_REPEAT_1_38(m,d) BOOST_PP_REPEAT_1_37(m, d) m(2, 37, d)
#define BOOST_PP_REPEAT_1_39(m,d) BOOST_PP_REPEAT_1_38(m, d) m(2, 38, d)
#define BOOST_PP_REPEAT_1_40(m,d) BOOST_PP_REPEAT_1_39(m, d) m(2, 39, d)
#define BOOST_PP_REPEAT_1_41(m,d) BOOST_PP_REPEAT_1_40(m, d) m(2, 40, d)
#define BOOST_PP_REPEAT_1_42(m,d) BOOST_PP_REPEAT_1_41(m, d) m(2, 41, d)
#define BOOST_PP_REPEAT_1_43(m,d) BOOST_PP_REPEAT_1_42(m, d) m(2, 42, d)
#define BOOST_PP_REPEAT_1_44(m,d) BOOST_PP_REPEAT_1_43(m, d) m(2, 43, d)
#define BOOST_PP_REPEAT_1_45(m,d) BOOST_PP_REPEAT_1_44(m, d) m(2, 44, d)
#define BOOST_PP_REPEAT_1_46(m,d) BOOST_PP_REPEAT_1_45(m, d) m(2, 45, d)
#define BOOST_PP_REPEAT_1_47(m,d) BOOST_PP_REPEAT_1_46(m, d) m(2, 46, d)
#define BOOST_PP_REPEAT_1_48(m,d) BOOST_PP_REPEAT_1_47(m, d) m(2, 47, d)
#define BOOST_PP_REPEAT_1_49(m,d) BOOST_PP_REPEAT_1_48(m, d) m(2, 48, d)
#define BOOST_PP_REPEAT_1_50(m,d) BOOST_PP_REPEAT_1_49(m, d) m(2, 49, d)
#define BOOST_PP_REPEAT_1_51(m,d) BOOST_PP_REPEAT_1_50(m, d) m(2, 50, d)
#define BOOST_PP_REPEAT_1_52(m,d) BOOST_PP_REPEAT_1_51(m, d) m(2, 51, d)
#define BOOST_PP_REPEAT_1_53(m,d) BOOST_PP_REPEAT_1_52(m, d) m(2, 52, d)
#define BOOST_PP_REPEAT_1_54(m,d) BOOST_PP_REPEAT_1_53(m, d) m(2, 53, d)
#define BOOST_PP_REPEAT_1_55(m,d) BOOST_PP_REPEAT_1_54(m, d) m(2, 54, d)
#define BOOST_PP_REPEAT_1_56(m,d) BOOST_PP_REPEAT_1_55(m, d) m(2, 55, d)
#define BOOST_PP_REPEAT_1_57(m,d) BOOST_PP_REPEAT_1_56(m, d) m(2, 56, d)
#define BOOST_PP_REPEAT_1_58(m,d) BOOST_PP_REPEAT_1_57(m, d) m(2, 57, d)
#define BOOST_PP_REPEAT_1_59(m,d) BOOST_PP_REPEAT_1_58(m, d) m(2, 58, d)
#define BOOST_PP_REPEAT_1_60(m,d) BOOST_PP_REPEAT_1_59(m, d) m(2, 59, d)
#define BOOST_PP_REPEAT_1_61(m,d) BOOST_PP_REPEAT_1_60(m, d) m(2, 60, d)
#define BOOST_PP_REPEAT_1_62(m,d) BOOST_PP_REPEAT_1_61(m, d) m(2, 61, d)
#define BOOST_PP_REPEAT_1_63(m,d) BOOST_PP_REPEAT_1_62(m, d) m(2, 62, d)
#define BOOST_PP_REPEAT_1_64(m,d) BOOST_PP_REPEAT_1_63(m, d) m(2, 63, d)
#define BOOST_PP_REPEAT_1_65(m,d) BOOST_PP_REPEAT_1_64(m, d) m(2, 64, d)
#define BOOST_PP_REPEAT_1_66(m,d) BOOST_PP_REPEAT_1_65(m, d) m(2, 65, d)
#define BOOST_PP_REPEAT_1_67(m,d) BOOST_PP_REPEAT_1_66(m, d) m(2, 66, d)
#define BOOST_PP_REPEAT_1_68(m,d) BOOST_PP_REPEAT_1_67(m, d) m(2, 67, d)
#define BOOST_PP_REPEAT_1_69(m,d) BOOST_PP_REPEAT_1_68(m, d) m(2, 68, d)
#define BOOST_PP_REPEAT_1_70(m,d) BOOST_PP_REPEAT_1_69(m, d) m(2, 69, d)
#define BOOST_PP_REPEAT_1_71(m,d) BOOST_PP_REPEAT_1_70(m, d) m(2, 70, d)
#define BOOST_PP_REPEAT_1_72(m,d) BOOST_PP_REPEAT_1_71(m, d) m(2, 71, d)
#define BOOST_PP_REPEAT_1_73(m,d) BOOST_PP_REPEAT_1_72(m, d) m(2, 72, d)
#define BOOST_PP_REPEAT_1_74(m,d) BOOST_PP_REPEAT_1_73(m, d) m(2, 73, d)
#define BOOST_PP_REPEAT_1_75(m,d) BOOST_PP_REPEAT_1_74(m, d) m(2, 74, d)
#define BOOST_PP_REPEAT_1_76(m,d) BOOST_PP_REPEAT_1_75(m, d) m(2, 75, d)
#define BOOST_PP_REPEAT_1_77(m,d) BOOST_PP_REPEAT_1_76(m, d) m(2, 76, d)
#define BOOST_PP_REPEAT_1_78(m,d) BOOST_PP_REPEAT_1_77(m, d) m(2, 77, d)
#define BOOST_PP_REPEAT_1_79(m,d) BOOST_PP_REPEAT_1_78(m, d) m(2, 78, d)
#define BOOST_PP_REPEAT_1_80(m,d) BOOST_PP_REPEAT_1_79(m, d) m(2, 79, d)
#define BOOST_PP_REPEAT_1_81(m,d) BOOST_PP_REPEAT_1_80(m, d) m(2, 80, d)
#define BOOST_PP_REPEAT_1_82(m,d) BOOST_PP_REPEAT_1_81(m, d) m(2, 81, d)
#define BOOST_PP_REPEAT_1_83(m,d) BOOST_PP_REPEAT_1_82(m, d) m(2, 82, d)
#define BOOST_PP_REPEAT_1_84(m,d) BOOST_PP_REPEAT_1_83(m, d) m(2, 83, d)
#define BOOST_PP_REPEAT_1_85(m,d) BOOST_PP_REPEAT_1_84(m, d) m(2, 84, d)
#define BOOST_PP_REPEAT_1_86(m,d) BOOST_PP_REPEAT_1_85(m, d) m(2, 85, d)
#define BOOST_PP_REPEAT_1_87(m,d) BOOST_PP_REPEAT_1_86(m, d) m(2, 86, d)
#define BOOST_PP_REPEAT_1_88(m,d) BOOST_PP_REPEAT_1_87(m, d) m(2, 87, d)
#define BOOST_PP_REPEAT_1_89(m,d) BOOST_PP_REPEAT_1_88(m, d) m(2, 88, d)
#define BOOST_PP_REPEAT_1_90(m,d) BOOST_PP_REPEAT_1_89(m, d) m(2, 89, d)
#define BOOST_PP_REPEAT_1_91(m,d) BOOST_PP_REPEAT_1_90(m, d) m(2, 90, d)
#define BOOST_PP_REPEAT_1_92(m,d) BOOST_PP_REPEAT_1_91(m, d) m(2, 91, d)
#define BOOST_PP_REPEAT_1_93(m,d) BOOST_PP_REPEAT_1_92(m, d) m(2, 92, d)
#define BOOST_PP_REPEAT_1_94(m,d) BOOST_PP_REPEAT_1_93(m, d) m(2, 93, d)
#define BOOST_PP_REPEAT_1_95(m,d) BOOST_PP_REPEAT_1_94(m, d) m(2, 94, d)
#define BOOST_PP_REPEAT_1_96(m,d) BOOST_PP_REPEAT_1_95(m, d) m(2, 95, d)
#define BOOST_PP_REPEAT_1_97(m,d) BOOST_PP_REPEAT_1_96(m, d) m(2, 96, d)
#define BOOST_PP_REPEAT_1_98(m,d) BOOST_PP_REPEAT_1_97(m, d) m(2, 97, d)
#define BOOST_PP_REPEAT_1_99(m,d) BOOST_PP_REPEAT_1_98(m, d) m(2, 98, d)
#define BOOST_PP_REPEAT_1_100(m,d) BOOST_PP_REPEAT_1_99(m, d) m(2, 99, d)
#define BOOST_PP_REPEAT_1_101(m,d) BOOST_PP_REPEAT_1_100(m, d) m(2, 100, d)
#define BOOST_PP_REPEAT_1_102(m,d) BOOST_PP_REPEAT_1_101(m, d) m(2, 101, d)
#define BOOST_PP_REPEAT_1_103(m,d) BOOST_PP_REPEAT_1_102(m, d) m(2, 102, d)
#define BOOST_PP_REPEAT_1_104(m,d) BOOST_PP_REPEAT_1_103(m, d) m(2, 103, d)
#define BOOST_PP_REPEAT_1_105(m,d) BOOST_PP_REPEAT_1_104(m, d) m(2, 104, d)
#define BOOST_PP_REPEAT_1_106(m,d) BOOST_PP_REPEAT_1_105(m, d) m(2, 105, d)
#define BOOST_PP_REPEAT_1_107(m,d) BOOST_PP_REPEAT_1_106(m, d) m(2, 106, d)
#define BOOST_PP_REPEAT_1_108(m,d) BOOST_PP_REPEAT_1_107(m, d) m(2, 107, d)
#define BOOST_PP_REPEAT_1_109(m,d) BOOST_PP_REPEAT_1_108(m, d) m(2, 108, d)
#define BOOST_PP_REPEAT_1_110(m,d) BOOST_PP_REPEAT_1_109(m, d) m(2, 109, d)
#define BOOST_PP_REPEAT_1_111(m,d) BOOST_PP_REPEAT_1_110(m, d) m(2, 110, d)
#define BOOST_PP_REPEAT_1_112(m,d) BOOST_PP_REPEAT_1_111(m, d) m(2, 111, d)
#define BOOST_PP_REPEAT_1_113(m,d) BOOST_PP_REPEAT_1_112(m, d) m(2, 112, d)
#define BOOST_PP_REPEAT_1_114(m,d) BOOST_PP_REPEAT_1_113(m, d) m(2, 113, d)
#define BOOST_PP_REPEAT_1_115(m,d) BOOST_PP_REPEAT_1_114(m, d) m(2, 114, d)
#define BOOST_PP_REPEAT_1_116(m,d) BOOST_PP_REPEAT_1_115(m, d) m(2, 115, d)
#define BOOST_PP_REPEAT_1_117(m,d) BOOST_PP_REPEAT_1_116(m, d) m(2, 116, d)
#define BOOST_PP_REPEAT_1_118(m,d) BOOST_PP_REPEAT_1_117(m, d) m(2, 117, d)
#define BOOST_PP_REPEAT_1_119(m,d) BOOST_PP_REPEAT_1_118(m, d) m(2, 118, d)
#define BOOST_PP_REPEAT_1_120(m,d) BOOST_PP_REPEAT_1_119(m, d) m(2, 119, d)
#define BOOST_PP_REPEAT_1_121(m,d) BOOST_PP_REPEAT_1_120(m, d) m(2, 120, d)
#define BOOST_PP_REPEAT_1_122(m,d) BOOST_PP_REPEAT_1_121(m, d) m(2, 121, d)
#define BOOST_PP_REPEAT_1_123(m,d) BOOST_PP_REPEAT_1_122(m, d) m(2, 122, d)
#define BOOST_PP_REPEAT_1_124(m,d) BOOST_PP_REPEAT_1_123(m, d) m(2, 123, d)
#define BOOST_PP_REPEAT_1_125(m,d) BOOST_PP_REPEAT_1_124(m, d) m(2, 124, d)
#define BOOST_PP_REPEAT_1_126(m,d) BOOST_PP_REPEAT_1_125(m, d) m(2, 125, d)
#define BOOST_PP_REPEAT_1_127(m,d) BOOST_PP_REPEAT_1_126(m, d) m(2, 126, d)
#define BOOST_PP_REPEAT_1_128(m,d) BOOST_PP_REPEAT_1_127(m, d) m(2, 127, d)
#define BOOST_PP_REPEAT_1_129(m,d) BOOST_PP_REPEAT_1_128(m, d) m(2, 128, d)
#define BOOST_PP_REPEAT_1_130(m,d) BOOST_PP_REPEAT_1_129(m, d) m(2, 129, d)
#define BOOST_PP_REPEAT_1_131(m,d) BOOST_PP_REPEAT_1_130(m, d) m(2, 130, d)
#define BOOST_PP_REPEAT_1_132(m,d) BOOST_PP_REPEAT_1_131(m, d) m(2, 131, d)
#define BOOST_PP_REPEAT_1_133(m,d) BOOST_PP_REPEAT_1_132(m, d) m(2, 132, d)
#define BOOST_PP_REPEAT_1_134(m,d) BOOST_PP_REPEAT_1_133(m, d) m(2, 133, d)
#define BOOST_PP_REPEAT_1_135(m,d) BOOST_PP_REPEAT_1_134(m, d) m(2, 134, d)
#define BOOST_PP_REPEAT_1_136(m,d) BOOST_PP_REPEAT_1_135(m, d) m(2, 135, d)
#define BOOST_PP_REPEAT_1_137(m,d) BOOST_PP_REPEAT_1_136(m, d) m(2, 136, d)
#define BOOST_PP_REPEAT_1_138(m,d) BOOST_PP_REPEAT_1_137(m, d) m(2, 137, d)
#define BOOST_PP_REPEAT_1_139(m,d) BOOST_PP_REPEAT_1_138(m, d) m(2, 138, d)
#define BOOST_PP_REPEAT_1_140(m,d) BOOST_PP_REPEAT_1_139(m, d) m(2, 139, d)
#define BOOST_PP_REPEAT_1_141(m,d) BOOST_PP_REPEAT_1_140(m, d) m(2, 140, d)
#define BOOST_PP_REPEAT_1_142(m,d) BOOST_PP_REPEAT_1_141(m, d) m(2, 141, d)
#define BOOST_PP_REPEAT_1_143(m,d) BOOST_PP_REPEAT_1_142(m, d) m(2, 142, d)
#define BOOST_PP_REPEAT_1_144(m,d) BOOST_PP_REPEAT_1_143(m, d) m(2, 143, d)
#define BOOST_PP_REPEAT_1_145(m,d) BOOST_PP_REPEAT_1_144(m, d) m(2, 144, d)
#define BOOST_PP_REPEAT_1_146(m,d) BOOST_PP_REPEAT_1_145(m, d) m(2, 145, d)
#define BOOST_PP_REPEAT_1_147(m,d) BOOST_PP_REPEAT_1_146(m, d) m(2, 146, d)
#define BOOST_PP_REPEAT_1_148(m,d) BOOST_PP_REPEAT_1_147(m, d) m(2, 147, d)
#define BOOST_PP_REPEAT_1_149(m,d) BOOST_PP_REPEAT_1_148(m, d) m(2, 148, d)
#define BOOST_PP_REPEAT_1_150(m,d) BOOST_PP_REPEAT_1_149(m, d) m(2, 149, d)
#define BOOST_PP_REPEAT_1_151(m,d) BOOST_PP_REPEAT_1_150(m, d) m(2, 150, d)
#define BOOST_PP_REPEAT_1_152(m,d) BOOST_PP_REPEAT_1_151(m, d) m(2, 151, d)
#define BOOST_PP_REPEAT_1_153(m,d) BOOST_PP_REPEAT_1_152(m, d) m(2, 152, d)
#define BOOST_PP_REPEAT_1_154(m,d) BOOST_PP_REPEAT_1_153(m, d) m(2, 153, d)
#define BOOST_PP_REPEAT_1_155(m,d) BOOST_PP_REPEAT_1_154(m, d) m(2, 154, d)
#define BOOST_PP_REPEAT_1_156(m,d) BOOST_PP_REPEAT_1_155(m, d) m(2, 155, d)
#define BOOST_PP_REPEAT_1_157(m,d) BOOST_PP_REPEAT_1_156(m, d) m(2, 156, d)
#define BOOST_PP_REPEAT_1_158(m,d) BOOST_PP_REPEAT_1_157(m, d) m(2, 157, d)
#define BOOST_PP_REPEAT_1_159(m,d) BOOST_PP_REPEAT_1_158(m, d) m(2, 158, d)
#define BOOST_PP_REPEAT_1_160(m,d) BOOST_PP_REPEAT_1_159(m, d) m(2, 159, d)
#define BOOST_PP_REPEAT_1_161(m,d) BOOST_PP_REPEAT_1_160(m, d) m(2, 160, d)
#define BOOST_PP_REPEAT_1_162(m,d) BOOST_PP_REPEAT_1_161(m, d) m(2, 161, d)
#define BOOST_PP_REPEAT_1_163(m,d) BOOST_PP_REPEAT_1_162(m, d) m(2, 162, d)
#define BOOST_PP_REPEAT_1_164(m,d) BOOST_PP_REPEAT_1_163(m, d) m(2, 163, d)
#define BOOST_PP_REPEAT_1_165(m,d) BOOST_PP_REPEAT_1_164(m, d) m(2, 164, d)
#define BOOST_PP_REPEAT_1_166(m,d) BOOST_PP_REPEAT_1_165(m, d) m(2, 165, d)
#define BOOST_PP_REPEAT_1_167(m,d) BOOST_PP_REPEAT_1_166(m, d) m(2, 166, d)
#define BOOST_PP_REPEAT_1_168(m,d) BOOST_PP_REPEAT_1_167(m, d) m(2, 167, d)
#define BOOST_PP_REPEAT_1_169(m,d) BOOST_PP_REPEAT_1_168(m, d) m(2, 168, d)
#define BOOST_PP_REPEAT_1_170(m,d) BOOST_PP_REPEAT_1_169(m, d) m(2, 169, d)
#define BOOST_PP_REPEAT_1_171(m,d) BOOST_PP_REPEAT_1_170(m, d) m(2, 170, d)
#define BOOST_PP_REPEAT_1_172(m,d) BOOST_PP_REPEAT_1_171(m, d) m(2, 171, d)
#define BOOST_PP_REPEAT_1_173(m,d) BOOST_PP_REPEAT_1_172(m, d) m(2, 172, d)
#define BOOST_PP_REPEAT_1_174(m,d) BOOST_PP_REPEAT_1_173(m, d) m(2, 173, d)
#define BOOST_PP_REPEAT_1_175(m,d) BOOST_PP_REPEAT_1_174(m, d) m(2, 174, d)
#define BOOST_PP_REPEAT_1_176(m,d) BOOST_PP_REPEAT_1_175(m, d) m(2, 175, d)
#define BOOST_PP_REPEAT_1_177(m,d) BOOST_PP_REPEAT_1_176(m, d) m(2, 176, d)
#define BOOST_PP_REPEAT_1_178(m,d) BOOST_PP_REPEAT_1_177(m, d) m(2, 177, d)
#define BOOST_PP_REPEAT_1_179(m,d) BOOST_PP_REPEAT_1_178(m, d) m(2, 178, d)
#define BOOST_PP_REPEAT_1_180(m,d) BOOST_PP_REPEAT_1_179(m, d) m(2, 179, d)
#define BOOST_PP_REPEAT_1_181(m,d) BOOST_PP_REPEAT_1_180(m, d) m(2, 180, d)
#define BOOST_PP_REPEAT_1_182(m,d) BOOST_PP_REPEAT_1_181(m, d) m(2, 181, d)
#define BOOST_PP_REPEAT_1_183(m,d) BOOST_PP_REPEAT_1_182(m, d) m(2, 182, d)
#define BOOST_PP_REPEAT_1_184(m,d) BOOST_PP_REPEAT_1_183(m, d) m(2, 183, d)
#define BOOST_PP_REPEAT_1_185(m,d) BOOST_PP_REPEAT_1_184(m, d) m(2, 184, d)
#define BOOST_PP_REPEAT_1_186(m,d) BOOST_PP_REPEAT_1_185(m, d) m(2, 185, d)
#define BOOST_PP_REPEAT_1_187(m,d) BOOST_PP_REPEAT_1_186(m, d) m(2, 186, d)
#define BOOST_PP_REPEAT_1_188(m,d) BOOST_PP_REPEAT_1_187(m, d) m(2, 187, d)
#define BOOST_PP_REPEAT_1_189(m,d) BOOST_PP_REPEAT_1_188(m, d) m(2, 188, d)
#define BOOST_PP_REPEAT_1_190(m,d) BOOST_PP_REPEAT_1_189(m, d) m(2, 189, d)
#define BOOST_PP_REPEAT_1_191(m,d) BOOST_PP_REPEAT_1_190(m, d) m(2, 190, d)
#define BOOST_PP_REPEAT_1_192(m,d) BOOST_PP_REPEAT_1_191(m, d) m(2, 191, d)
#define BOOST_PP_REPEAT_1_193(m,d) BOOST_PP_REPEAT_1_192(m, d) m(2, 192, d)
#define BOOST_PP_REPEAT_1_194(m,d) BOOST_PP_REPEAT_1_193(m, d) m(2, 193, d)
#define BOOST_PP_REPEAT_1_195(m,d) BOOST_PP_REPEAT_1_194(m, d) m(2, 194, d)
#define BOOST_PP_REPEAT_1_196(m,d) BOOST_PP_REPEAT_1_195(m, d) m(2, 195, d)
#define BOOST_PP_REPEAT_1_197(m,d) BOOST_PP_REPEAT_1_196(m, d) m(2, 196, d)
#define BOOST_PP_REPEAT_1_198(m,d) BOOST_PP_REPEAT_1_197(m, d) m(2, 197, d)
#define BOOST_PP_REPEAT_1_199(m,d) BOOST_PP_REPEAT_1_198(m, d) m(2, 198, d)
#define BOOST_PP_REPEAT_1_200(m,d) BOOST_PP_REPEAT_1_199(m, d) m(2, 199, d)
#define BOOST_PP_REPEAT_1_201(m,d) BOOST_PP_REPEAT_1_200(m, d) m(2, 200, d)
#define BOOST_PP_REPEAT_1_202(m,d) BOOST_PP_REPEAT_1_201(m, d) m(2, 201, d)
#define BOOST_PP_REPEAT_1_203(m,d) BOOST_PP_REPEAT_1_202(m, d) m(2, 202, d)
#define BOOST_PP_REPEAT_1_204(m,d) BOOST_PP_REPEAT_1_203(m, d) m(2, 203, d)
#define BOOST_PP_REPEAT_1_205(m,d) BOOST_PP_REPEAT_1_204(m, d) m(2, 204, d)
#define BOOST_PP_REPEAT_1_206(m,d) BOOST_PP_REPEAT_1_205(m, d) m(2, 205, d)
#define BOOST_PP_REPEAT_1_207(m,d) BOOST_PP_REPEAT_1_206(m, d) m(2, 206, d)
#define BOOST_PP_REPEAT_1_208(m,d) BOOST_PP_REPEAT_1_207(m, d) m(2, 207, d)
#define BOOST_PP_REPEAT_1_209(m,d) BOOST_PP_REPEAT_1_208(m, d) m(2, 208, d)
#define BOOST_PP_REPEAT_1_210(m,d) BOOST_PP_REPEAT_1_209(m, d) m(2, 209, d)
#define BOOST_PP_REPEAT_1_211(m,d) BOOST_PP_REPEAT_1_210(m, d) m(2, 210, d)
#define BOOST_PP_REPEAT_1_212(m,d) BOOST_PP_REPEAT_1_211(m, d) m(2, 211, d)
#define BOOST_PP_REPEAT_1_213(m,d) BOOST_PP_REPEAT_1_212(m, d) m(2, 212, d)
#define BOOST_PP_REPEAT_1_214(m,d) BOOST_PP_REPEAT_1_213(m, d) m(2, 213, d)
#define BOOST_PP_REPEAT_1_215(m,d) BOOST_PP_REPEAT_1_214(m, d) m(2, 214, d)
#define BOOST_PP_REPEAT_1_216(m,d) BOOST_PP_REPEAT_1_215(m, d) m(2, 215, d)
#define BOOST_PP_REPEAT_1_217(m,d) BOOST_PP_REPEAT_1_216(m, d) m(2, 216, d)
#define BOOST_PP_REPEAT_1_218(m,d) BOOST_PP_REPEAT_1_217(m, d) m(2, 217, d)
#define BOOST_PP_REPEAT_1_219(m,d) BOOST_PP_REPEAT_1_218(m, d) m(2, 218, d)
#define BOOST_PP_REPEAT_1_220(m,d) BOOST_PP_REPEAT_1_219(m, d) m(2, 219, d)
#define BOOST_PP_REPEAT_1_221(m,d) BOOST_PP_REPEAT_1_220(m, d) m(2, 220, d)
#define BOOST_PP_REPEAT_1_222(m,d) BOOST_PP_REPEAT_1_221(m, d) m(2, 221, d)
#define BOOST_PP_REPEAT_1_223(m,d) BOOST_PP_REPEAT_1_222(m, d) m(2, 222, d)
#define BOOST_PP_REPEAT_1_224(m,d) BOOST_PP_REPEAT_1_223(m, d) m(2, 223, d)
#define BOOST_PP_REPEAT_1_225(m,d) BOOST_PP_REPEAT_1_224(m, d) m(2, 224, d)
#define BOOST_PP_REPEAT_1_226(m,d) BOOST_PP_REPEAT_1_225(m, d) m(2, 225, d)
#define BOOST_PP_REPEAT_1_227(m,d) BOOST_PP_REPEAT_1_226(m, d) m(2, 226, d)
#define BOOST_PP_REPEAT_1_228(m,d) BOOST_PP_REPEAT_1_227(m, d) m(2, 227, d)
#define BOOST_PP_REPEAT_1_229(m,d) BOOST_PP_REPEAT_1_228(m, d) m(2, 228, d)
#define BOOST_PP_REPEAT_1_230(m,d) BOOST_PP_REPEAT_1_229(m, d) m(2, 229, d)
#define BOOST_PP_REPEAT_1_231(m,d) BOOST_PP_REPEAT_1_230(m, d) m(2, 230, d)
#define BOOST_PP_REPEAT_1_232(m,d) BOOST_PP_REPEAT_1_231(m, d) m(2, 231, d)
#define BOOST_PP_REPEAT_1_233(m,d) BOOST_PP_REPEAT_1_232(m, d) m(2, 232, d)
#define BOOST_PP_REPEAT_1_234(m,d) BOOST_PP_REPEAT_1_233(m, d) m(2, 233, d)
#define BOOST_PP_REPEAT_1_235(m,d) BOOST_PP_REPEAT_1_234(m, d) m(2, 234, d)
#define BOOST_PP_REPEAT_1_236(m,d) BOOST_PP_REPEAT_1_235(m, d) m(2, 235, d)
#define BOOST_PP_REPEAT_1_237(m,d) BOOST_PP_REPEAT_1_236(m, d) m(2, 236, d)
#define BOOST_PP_REPEAT_1_238(m,d) BOOST_PP_REPEAT_1_237(m, d) m(2, 237, d)
#define BOOST_PP_REPEAT_1_239(m,d) BOOST_PP_REPEAT_1_238(m, d) m(2, 238, d)
#define BOOST_PP_REPEAT_1_240(m,d) BOOST_PP_REPEAT_1_239(m, d) m(2, 239, d)
#define BOOST_PP_REPEAT_1_241(m,d) BOOST_PP_REPEAT_1_240(m, d) m(2, 240, d)
#define BOOST_PP_REPEAT_1_242(m,d) BOOST_PP_REPEAT_1_241(m, d) m(2, 241, d)
#define BOOST_PP_REPEAT_1_243(m,d) BOOST_PP_REPEAT_1_242(m, d) m(2, 242, d)
#define BOOST_PP_REPEAT_1_244(m,d) BOOST_PP_REPEAT_1_243(m, d) m(2, 243, d)
#define BOOST_PP_REPEAT_1_245(m,d) BOOST_PP_REPEAT_1_244(m, d) m(2, 244, d)
#define BOOST_PP_REPEAT_1_246(m,d) BOOST_PP_REPEAT_1_245(m, d) m(2, 245, d)
#define BOOST_PP_REPEAT_1_247(m,d) BOOST_PP_REPEAT_1_246(m, d) m(2, 246, d)
#define BOOST_PP_REPEAT_1_248(m,d) BOOST_PP_REPEAT_1_247(m, d) m(2, 247, d)
#define BOOST_PP_REPEAT_1_249(m,d) BOOST_PP_REPEAT_1_248(m, d) m(2, 248, d)
#define BOOST_PP_REPEAT_1_250(m,d) BOOST_PP_REPEAT_1_249(m, d) m(2, 249, d)
#define BOOST_PP_REPEAT_1_251(m,d) BOOST_PP_REPEAT_1_250(m, d) m(2, 250, d)
#define BOOST_PP_REPEAT_1_252(m,d) BOOST_PP_REPEAT_1_251(m, d) m(2, 251, d)
#define BOOST_PP_REPEAT_1_253(m,d) BOOST_PP_REPEAT_1_252(m, d) m(2, 252, d)
#define BOOST_PP_REPEAT_1_254(m,d) BOOST_PP_REPEAT_1_253(m, d) m(2, 253, d)
#define BOOST_PP_REPEAT_1_255(m,d) BOOST_PP_REPEAT_1_254(m, d) m(2, 254, d)
#define BOOST_PP_REPEAT_1_256(m,d) BOOST_PP_REPEAT_1_255(m, d) m(2, 255, d)
#define BOOST_PP_REPEAT_2_0(m,d)
#define BOOST_PP_REPEAT_2_1(m,d) m(3, 0, d)
#define BOOST_PP_REPEAT_2_2(m,d) BOOST_PP_REPEAT_2_1(m, d) m(3, 1, d)
#define BOOST_PP_REPEAT_2_3(m,d) BOOST_PP_REPEAT_2_2(m, d) m(3, 2, d)
#define BOOST_PP_REPEAT_2_4(m,d) BOOST_PP_REPEAT_2_3(m, d) m(3, 3, d)
#define BOOST_PP_REPEAT_2_5(m,d) BOOST_PP_REPEAT_2_4(m, d) m(3, 4, d)
#define BOOST_PP_REPEAT_2_6(m,d) BOOST_PP_REPEAT_2_5(m, d) m(3, 5, d)
#define BOOST_PP_REPEAT_2_7(m,d) BOOST_PP_REPEAT_2_6(m, d) m(3, 6, d)
#define BOOST_PP_REPEAT_2_8(m,d) BOOST_PP_REPEAT_2_7(m, d) m(3, 7, d)
#define BOOST_PP_REPEAT_2_9(m,d) BOOST_PP_REPEAT_2_8(m, d) m(3, 8, d)
#define BOOST_PP_REPEAT_2_10(m,d) BOOST_PP_REPEAT_2_9(m, d) m(3, 9, d)
#define BOOST_PP_REPEAT_2_11(m,d) BOOST_PP_REPEAT_2_10(m, d) m(3, 10, d)
#define BOOST_PP_REPEAT_2_12(m,d) BOOST_PP_REPEAT_2_11(m, d) m(3, 11, d)
#define BOOST_PP_REPEAT_2_13(m,d) BOOST_PP_REPEAT_2_12(m, d) m(3, 12, d)
#define BOOST_PP_REPEAT_2_14(m,d) BOOST_PP_REPEAT_2_13(m, d) m(3, 13, d)
#define BOOST_PP_REPEAT_2_15(m,d) BOOST_PP_REPEAT_2_14(m, d) m(3, 14, d)
#define BOOST_PP_REPEAT_2_16(m,d) BOOST_PP_REPEAT_2_15(m, d) m(3, 15, d)
#define BOOST_PP_REPEAT_2_17(m,d) BOOST_PP_REPEAT_2_16(m, d) m(3, 16, d)
#define BOOST_PP_REPEAT_2_18(m,d) BOOST_PP_REPEAT_2_17(m, d) m(3, 17, d)
#define BOOST_PP_REPEAT_2_19(m,d) BOOST_PP_REPEAT_2_18(m, d) m(3, 18, d)
#define BOOST_PP_REPEAT_2_20(m,d) BOOST_PP_REPEAT_2_19(m, d) m(3, 19, d)
#define BOOST_PP_REPEAT_2_21(m,d) BOOST_PP_REPEAT_2_20(m, d) m(3, 20, d)
#define BOOST_PP_REPEAT_2_22(m,d) BOOST_PP_REPEAT_2_21(m, d) m(3, 21, d)
#define BOOST_PP_REPEAT_2_23(m,d) BOOST_PP_REPEAT_2_22(m, d) m(3, 22, d)
#define BOOST_PP_REPEAT_2_24(m,d) BOOST_PP_REPEAT_2_23(m, d) m(3, 23, d)
#define BOOST_PP_REPEAT_2_25(m,d) BOOST_PP_REPEAT_2_24(m, d) m(3, 24, d)
#define BOOST_PP_REPEAT_2_26(m,d) BOOST_PP_REPEAT_2_25(m, d) m(3, 25, d)
#define BOOST_PP_REPEAT_2_27(m,d) BOOST_PP_REPEAT_2_26(m, d) m(3, 26, d)
#define BOOST_PP_REPEAT_2_28(m,d) BOOST_PP_REPEAT_2_27(m, d) m(3, 27, d)
#define BOOST_PP_REPEAT_2_29(m,d) BOOST_PP_REPEAT_2_28(m, d) m(3, 28, d)
#define BOOST_PP_REPEAT_2_30(m,d) BOOST_PP_REPEAT_2_29(m, d) m(3, 29, d)
#define BOOST_PP_REPEAT_2_31(m,d) BOOST_PP_REPEAT_2_30(m, d) m(3, 30, d)
#define BOOST_PP_REPEAT_2_32(m,d) BOOST_PP_REPEAT_2_31(m, d) m(3, 31, d)
#define BOOST_PP_REPEAT_2_33(m,d) BOOST_PP_REPEAT_2_32(m, d) m(3, 32, d)
#define BOOST_PP_REPEAT_2_34(m,d) BOOST_PP_REPEAT_2_33(m, d) m(3, 33, d)
#define BOOST_PP_REPEAT_2_35(m,d) BOOST_PP_REPEAT_2_34(m, d) m(3, 34, d)
#define BOOST_PP_REPEAT_2_36(m,d) BOOST_PP_REPEAT_2_35(m, d) m(3, 35, d)
#define BOOST_PP_REPEAT_2_37(m,d) BOOST_PP_REPEAT_2_36(m, d) m(3, 36, d)
#define BOOST_PP_REPEAT_2_38(m,d) BOOST_PP_REPEAT_2_37(m, d) m(3, 37, d)
#define BOOST_PP_REPEAT_2_39(m,d) BOOST_PP_REPEAT_2_38(m, d) m(3, 38, d)
#define BOOST_PP_REPEAT_2_40(m,d) BOOST_PP_REPEAT_2_39(m, d) m(3, 39, d)
#define BOOST_PP_REPEAT_2_41(m,d) BOOST_PP_REPEAT_2_40(m, d) m(3, 40, d)
#define BOOST_PP_REPEAT_2_42(m,d) BOOST_PP_REPEAT_2_41(m, d) m(3, 41, d)
#define BOOST_PP_REPEAT_2_43(m,d) BOOST_PP_REPEAT_2_42(m, d) m(3, 42, d)
#define BOOST_PP_REPEAT_2_44(m,d) BOOST_PP_REPEAT_2_43(m, d) m(3, 43, d)
#define BOOST_PP_REPEAT_2_45(m,d) BOOST_PP_REPEAT_2_44(m, d) m(3, 44, d)
#define BOOST_PP_REPEAT_2_46(m,d) BOOST_PP_REPEAT_2_45(m, d) m(3, 45, d)
#define BOOST_PP_REPEAT_2_47(m,d) BOOST_PP_REPEAT_2_46(m, d) m(3, 46, d)
#define BOOST_PP_REPEAT_2_48(m,d) BOOST_PP_REPEAT_2_47(m, d) m(3, 47, d)
#define BOOST_PP_REPEAT_2_49(m,d) BOOST_PP_REPEAT_2_48(m, d) m(3, 48, d)
#define BOOST_PP_REPEAT_2_50(m,d) BOOST_PP_REPEAT_2_49(m, d) m(3, 49, d)
#define BOOST_PP_REPEAT_2_51(m,d) BOOST_PP_REPEAT_2_50(m, d) m(3, 50, d)
#define BOOST_PP_REPEAT_2_52(m,d) BOOST_PP_REPEAT_2_51(m, d) m(3, 51, d)
#define BOOST_PP_REPEAT_2_53(m,d) BOOST_PP_REPEAT_2_52(m, d) m(3, 52, d)
#define BOOST_PP_REPEAT_2_54(m,d) BOOST_PP_REPEAT_2_53(m, d) m(3, 53, d)
#define BOOST_PP_REPEAT_2_55(m,d) BOOST_PP_REPEAT_2_54(m, d) m(3, 54, d)
#define BOOST_PP_REPEAT_2_56(m,d) BOOST_PP_REPEAT_2_55(m, d) m(3, 55, d)
#define BOOST_PP_REPEAT_2_57(m,d) BOOST_PP_REPEAT_2_56(m, d) m(3, 56, d)
#define BOOST_PP_REPEAT_2_58(m,d) BOOST_PP_REPEAT_2_57(m, d) m(3, 57, d)
#define BOOST_PP_REPEAT_2_59(m,d) BOOST_PP_REPEAT_2_58(m, d) m(3, 58, d)
#define BOOST_PP_REPEAT_2_60(m,d) BOOST_PP_REPEAT_2_59(m, d) m(3, 59, d)
#define BOOST_PP_REPEAT_2_61(m,d) BOOST_PP_REPEAT_2_60(m, d) m(3, 60, d)
#define BOOST_PP_REPEAT_2_62(m,d) BOOST_PP_REPEAT_2_61(m, d) m(3, 61, d)
#define BOOST_PP_REPEAT_2_63(m,d) BOOST_PP_REPEAT_2_62(m, d) m(3, 62, d)
#define BOOST_PP_REPEAT_2_64(m,d) BOOST_PP_REPEAT_2_63(m, d) m(3, 63, d)
#define BOOST_PP_REPEAT_2_65(m,d) BOOST_PP_REPEAT_2_64(m, d) m(3, 64, d)
#define BOOST_PP_REPEAT_2_66(m,d) BOOST_PP_REPEAT_2_65(m, d) m(3, 65, d)
#define BOOST_PP_REPEAT_2_67(m,d) BOOST_PP_REPEAT_2_66(m, d) m(3, 66, d)
#define BOOST_PP_REPEAT_2_68(m,d) BOOST_PP_REPEAT_2_67(m, d) m(3, 67, d)
#define BOOST_PP_REPEAT_2_69(m,d) BOOST_PP_REPEAT_2_68(m, d) m(3, 68, d)
#define BOOST_PP_REPEAT_2_70(m,d) BOOST_PP_REPEAT_2_69(m, d) m(3, 69, d)
#define BOOST_PP_REPEAT_2_71(m,d) BOOST_PP_REPEAT_2_70(m, d) m(3, 70, d)
#define BOOST_PP_REPEAT_2_72(m,d) BOOST_PP_REPEAT_2_71(m, d) m(3, 71, d)
#define BOOST_PP_REPEAT_2_73(m,d) BOOST_PP_REPEAT_2_72(m, d) m(3, 72, d)
#define BOOST_PP_REPEAT_2_74(m,d) BOOST_PP_REPEAT_2_73(m, d) m(3, 73, d)
#define BOOST_PP_REPEAT_2_75(m,d) BOOST_PP_REPEAT_2_74(m, d) m(3, 74, d)
#define BOOST_PP_REPEAT_2_76(m,d) BOOST_PP_REPEAT_2_75(m, d) m(3, 75, d)
#define BOOST_PP_REPEAT_2_77(m,d) BOOST_PP_REPEAT_2_76(m, d) m(3, 76, d)
#define BOOST_PP_REPEAT_2_78(m,d) BOOST_PP_REPEAT_2_77(m, d) m(3, 77, d)
#define BOOST_PP_REPEAT_2_79(m,d) BOOST_PP_REPEAT_2_78(m, d) m(3, 78, d)
#define BOOST_PP_REPEAT_2_80(m,d) BOOST_PP_REPEAT_2_79(m, d) m(3, 79, d)
#define BOOST_PP_REPEAT_2_81(m,d) BOOST_PP_REPEAT_2_80(m, d) m(3, 80, d)
#define BOOST_PP_REPEAT_2_82(m,d) BOOST_PP_REPEAT_2_81(m, d) m(3, 81, d)
#define BOOST_PP_REPEAT_2_83(m,d) BOOST_PP_REPEAT_2_82(m, d) m(3, 82, d)
#define BOOST_PP_REPEAT_2_84(m,d) BOOST_PP_REPEAT_2_83(m, d) m(3, 83, d)
#define BOOST_PP_REPEAT_2_85(m,d) BOOST_PP_REPEAT_2_84(m, d) m(3, 84, d)
#define BOOST_PP_REPEAT_2_86(m,d) BOOST_PP_REPEAT_2_85(m, d) m(3, 85, d)
#define BOOST_PP_REPEAT_2_87(m,d) BOOST_PP_REPEAT_2_86(m, d) m(3, 86, d)
#define BOOST_PP_REPEAT_2_88(m,d) BOOST_PP_REPEAT_2_87(m, d) m(3, 87, d)
#define BOOST_PP_REPEAT_2_89(m,d) BOOST_PP_REPEAT_2_88(m, d) m(3, 88, d)
#define BOOST_PP_REPEAT_2_90(m,d) BOOST_PP_REPEAT_2_89(m, d) m(3, 89, d)
#define BOOST_PP_REPEAT_2_91(m,d) BOOST_PP_REPEAT_2_90(m, d) m(3, 90, d)
#define BOOST_PP_REPEAT_2_92(m,d) BOOST_PP_REPEAT_2_91(m, d) m(3, 91, d)
#define BOOST_PP_REPEAT_2_93(m,d) BOOST_PP_REPEAT_2_92(m, d) m(3, 92, d)
#define BOOST_PP_REPEAT_2_94(m,d) BOOST_PP_REPEAT_2_93(m, d) m(3, 93, d)
#define BOOST_PP_REPEAT_2_95(m,d) BOOST_PP_REPEAT_2_94(m, d) m(3, 94, d)
#define BOOST_PP_REPEAT_2_96(m,d) BOOST_PP_REPEAT_2_95(m, d) m(3, 95, d)
#define BOOST_PP_REPEAT_2_97(m,d) BOOST_PP_REPEAT_2_96(m, d) m(3, 96, d)
#define BOOST_PP_REPEAT_2_98(m,d) BOOST_PP_REPEAT_2_97(m, d) m(3, 97, d)
#define BOOST_PP_REPEAT_2_99(m,d) BOOST_PP_REPEAT_2_98(m, d) m(3, 98, d)
#define BOOST_PP_REPEAT_2_100(m,d) BOOST_PP_REPEAT_2_99(m, d) m(3, 99, d)
#define BOOST_PP_REPEAT_2_101(m,d) BOOST_PP_REPEAT_2_100(m, d) m(3, 100, d)
#define BOOST_PP_REPEAT_2_102(m,d) BOOST_PP_REPEAT_2_101(m, d) m(3, 101, d)
#define BOOST_PP_REPEAT_2_103(m,d) BOOST_PP_REPEAT_2_102(m, d) m(3, 102, d)
#define BOOST_PP_REPEAT_2_104(m,d) BOOST_PP_REPEAT_2_103(m, d) m(3, 103, d)
#define BOOST_PP_REPEAT_2_105(m,d) BOOST_PP_REPEAT_2_104(m, d) m(3, 104, d)
#define BOOST_PP_REPEAT_2_106(m,d) BOOST_PP_REPEAT_2_105(m, d) m(3, 105, d)
#define BOOST_PP_REPEAT_2_107(m,d) BOOST_PP_REPEAT_2_106(m, d) m(3, 106, d)
#define BOOST_PP_REPEAT_2_108(m,d) BOOST_PP_REPEAT_2_107(m, d) m(3, 107, d)
#define BOOST_PP_REPEAT_2_109(m,d) BOOST_PP_REPEAT_2_108(m, d) m(3, 108, d)
#define BOOST_PP_REPEAT_2_110(m,d) BOOST_PP_REPEAT_2_109(m, d) m(3, 109, d)
#define BOOST_PP_REPEAT_2_111(m,d) BOOST_PP_REPEAT_2_110(m, d) m(3, 110, d)
#define BOOST_PP_REPEAT_2_112(m,d) BOOST_PP_REPEAT_2_111(m, d) m(3, 111, d)
#define BOOST_PP_REPEAT_2_113(m,d) BOOST_PP_REPEAT_2_112(m, d) m(3, 112, d)
#define BOOST_PP_REPEAT_2_114(m,d) BOOST_PP_REPEAT_2_113(m, d) m(3, 113, d)
#define BOOST_PP_REPEAT_2_115(m,d) BOOST_PP_REPEAT_2_114(m, d) m(3, 114, d)
#define BOOST_PP_REPEAT_2_116(m,d) BOOST_PP_REPEAT_2_115(m, d) m(3, 115, d)
#define BOOST_PP_REPEAT_2_117(m,d) BOOST_PP_REPEAT_2_116(m, d) m(3, 116, d)
#define BOOST_PP_REPEAT_2_118(m,d) BOOST_PP_REPEAT_2_117(m, d) m(3, 117, d)
#define BOOST_PP_REPEAT_2_119(m,d) BOOST_PP_REPEAT_2_118(m, d) m(3, 118, d)
#define BOOST_PP_REPEAT_2_120(m,d) BOOST_PP_REPEAT_2_119(m, d) m(3, 119, d)
#define BOOST_PP_REPEAT_2_121(m,d) BOOST_PP_REPEAT_2_120(m, d) m(3, 120, d)
#define BOOST_PP_REPEAT_2_122(m,d) BOOST_PP_REPEAT_2_121(m, d) m(3, 121, d)
#define BOOST_PP_REPEAT_2_123(m,d) BOOST_PP_REPEAT_2_122(m, d) m(3, 122, d)
#define BOOST_PP_REPEAT_2_124(m,d) BOOST_PP_REPEAT_2_123(m, d) m(3, 123, d)
#define BOOST_PP_REPEAT_2_125(m,d) BOOST_PP_REPEAT_2_124(m, d) m(3, 124, d)
#define BOOST_PP_REPEAT_2_126(m,d) BOOST_PP_REPEAT_2_125(m, d) m(3, 125, d)
#define BOOST_PP_REPEAT_2_127(m,d) BOOST_PP_REPEAT_2_126(m, d) m(3, 126, d)
#define BOOST_PP_REPEAT_2_128(m,d) BOOST_PP_REPEAT_2_127(m, d) m(3, 127, d)
#define BOOST_PP_REPEAT_2_129(m,d) BOOST_PP_REPEAT_2_128(m, d) m(3, 128, d)
#define BOOST_PP_REPEAT_2_130(m,d) BOOST_PP_REPEAT_2_129(m, d) m(3, 129, d)
#define BOOST_PP_REPEAT_2_131(m,d) BOOST_PP_REPEAT_2_130(m, d) m(3, 130, d)
#define BOOST_PP_REPEAT_2_132(m,d) BOOST_PP_REPEAT_2_131(m, d) m(3, 131, d)
#define BOOST_PP_REPEAT_2_133(m,d) BOOST_PP_REPEAT_2_132(m, d) m(3, 132, d)
#define BOOST_PP_REPEAT_2_134(m,d) BOOST_PP_REPEAT_2_133(m, d) m(3, 133, d)
#define BOOST_PP_REPEAT_2_135(m,d) BOOST_PP_REPEAT_2_134(m, d) m(3, 134, d)
#define BOOST_PP_REPEAT_2_136(m,d) BOOST_PP_REPEAT_2_135(m, d) m(3, 135, d)
#define BOOST_PP_REPEAT_2_137(m,d) BOOST_PP_REPEAT_2_136(m, d) m(3, 136, d)
#define BOOST_PP_REPEAT_2_138(m,d) BOOST_PP_REPEAT_2_137(m, d) m(3, 137, d)
#define BOOST_PP_REPEAT_2_139(m,d) BOOST_PP_REPEAT_2_138(m, d) m(3, 138, d)
#define BOOST_PP_REPEAT_2_140(m,d) BOOST_PP_REPEAT_2_139(m, d) m(3, 139, d)
#define BOOST_PP_REPEAT_2_141(m,d) BOOST_PP_REPEAT_2_140(m, d) m(3, 140, d)
#define BOOST_PP_REPEAT_2_142(m,d) BOOST_PP_REPEAT_2_141(m, d) m(3, 141, d)
#define BOOST_PP_REPEAT_2_143(m,d) BOOST_PP_REPEAT_2_142(m, d) m(3, 142, d)
#define BOOST_PP_REPEAT_2_144(m,d) BOOST_PP_REPEAT_2_143(m, d) m(3, 143, d)
#define BOOST_PP_REPEAT_2_145(m,d) BOOST_PP_REPEAT_2_144(m, d) m(3, 144, d)
#define BOOST_PP_REPEAT_2_146(m,d) BOOST_PP_REPEAT_2_145(m, d) m(3, 145, d)
#define BOOST_PP_REPEAT_2_147(m,d) BOOST_PP_REPEAT_2_146(m, d) m(3, 146, d)
#define BOOST_PP_REPEAT_2_148(m,d) BOOST_PP_REPEAT_2_147(m, d) m(3, 147, d)
#define BOOST_PP_REPEAT_2_149(m,d) BOOST_PP_REPEAT_2_148(m, d) m(3, 148, d)
#define BOOST_PP_REPEAT_2_150(m,d) BOOST_PP_REPEAT_2_149(m, d) m(3, 149, d)
#define BOOST_PP_REPEAT_2_151(m,d) BOOST_PP_REPEAT_2_150(m, d) m(3, 150, d)
#define BOOST_PP_REPEAT_2_152(m,d) BOOST_PP_REPEAT_2_151(m, d) m(3, 151, d)
#define BOOST_PP_REPEAT_2_153(m,d) BOOST_PP_REPEAT_2_152(m, d) m(3, 152, d)
#define BOOST_PP_REPEAT_2_154(m,d) BOOST_PP_REPEAT_2_153(m, d) m(3, 153, d)
#define BOOST_PP_REPEAT_2_155(m,d) BOOST_PP_REPEAT_2_154(m, d) m(3, 154, d)
#define BOOST_PP_REPEAT_2_156(m,d) BOOST_PP_REPEAT_2_155(m, d) m(3, 155, d)
#define BOOST_PP_REPEAT_2_157(m,d) BOOST_PP_REPEAT_2_156(m, d) m(3, 156, d)
#define BOOST_PP_REPEAT_2_158(m,d) BOOST_PP_REPEAT_2_157(m, d) m(3, 157, d)
#define BOOST_PP_REPEAT_2_159(m,d) BOOST_PP_REPEAT_2_158(m, d) m(3, 158, d)
#define BOOST_PP_REPEAT_2_160(m,d) BOOST_PP_REPEAT_2_159(m, d) m(3, 159, d)
#define BOOST_PP_REPEAT_2_161(m,d) BOOST_PP_REPEAT_2_160(m, d) m(3, 160, d)
#define BOOST_PP_REPEAT_2_162(m,d) BOOST_PP_REPEAT_2_161(m, d) m(3, 161, d)
#define BOOST_PP_REPEAT_2_163(m,d) BOOST_PP_REPEAT_2_162(m, d) m(3, 162, d)
#define BOOST_PP_REPEAT_2_164(m,d) BOOST_PP_REPEAT_2_163(m, d) m(3, 163, d)
#define BOOST_PP_REPEAT_2_165(m,d) BOOST_PP_REPEAT_2_164(m, d) m(3, 164, d)
#define BOOST_PP_REPEAT_2_166(m,d) BOOST_PP_REPEAT_2_165(m, d) m(3, 165, d)
#define BOOST_PP_REPEAT_2_167(m,d) BOOST_PP_REPEAT_2_166(m, d) m(3, 166, d)
#define BOOST_PP_REPEAT_2_168(m,d) BOOST_PP_REPEAT_2_167(m, d) m(3, 167, d)
#define BOOST_PP_REPEAT_2_169(m,d) BOOST_PP_REPEAT_2_168(m, d) m(3, 168, d)
#define BOOST_PP_REPEAT_2_170(m,d) BOOST_PP_REPEAT_2_169(m, d) m(3, 169, d)
#define BOOST_PP_REPEAT_2_171(m,d) BOOST_PP_REPEAT_2_170(m, d) m(3, 170, d)
#define BOOST_PP_REPEAT_2_172(m,d) BOOST_PP_REPEAT_2_171(m, d) m(3, 171, d)
#define BOOST_PP_REPEAT_2_173(m,d) BOOST_PP_REPEAT_2_172(m, d) m(3, 172, d)
#define BOOST_PP_REPEAT_2_174(m,d) BOOST_PP_REPEAT_2_173(m, d) m(3, 173, d)
#define BOOST_PP_REPEAT_2_175(m,d) BOOST_PP_REPEAT_2_174(m, d) m(3, 174, d)
#define BOOST_PP_REPEAT_2_176(m,d) BOOST_PP_REPEAT_2_175(m, d) m(3, 175, d)
#define BOOST_PP_REPEAT_2_177(m,d) BOOST_PP_REPEAT_2_176(m, d) m(3, 176, d)
#define BOOST_PP_REPEAT_2_178(m,d) BOOST_PP_REPEAT_2_177(m, d) m(3, 177, d)
#define BOOST_PP_REPEAT_2_179(m,d) BOOST_PP_REPEAT_2_178(m, d) m(3, 178, d)
#define BOOST_PP_REPEAT_2_180(m,d) BOOST_PP_REPEAT_2_179(m, d) m(3, 179, d)
#define BOOST_PP_REPEAT_2_181(m,d) BOOST_PP_REPEAT_2_180(m, d) m(3, 180, d)
#define BOOST_PP_REPEAT_2_182(m,d) BOOST_PP_REPEAT_2_181(m, d) m(3, 181, d)
#define BOOST_PP_REPEAT_2_183(m,d) BOOST_PP_REPEAT_2_182(m, d) m(3, 182, d)
#define BOOST_PP_REPEAT_2_184(m,d) BOOST_PP_REPEAT_2_183(m, d) m(3, 183, d)
#define BOOST_PP_REPEAT_2_185(m,d) BOOST_PP_REPEAT_2_184(m, d) m(3, 184, d)
#define BOOST_PP_REPEAT_2_186(m,d) BOOST_PP_REPEAT_2_185(m, d) m(3, 185, d)
#define BOOST_PP_REPEAT_2_187(m,d) BOOST_PP_REPEAT_2_186(m, d) m(3, 186, d)
#define BOOST_PP_REPEAT_2_188(m,d) BOOST_PP_REPEAT_2_187(m, d) m(3, 187, d)
#define BOOST_PP_REPEAT_2_189(m,d) BOOST_PP_REPEAT_2_188(m, d) m(3, 188, d)
#define BOOST_PP_REPEAT_2_190(m,d) BOOST_PP_REPEAT_2_189(m, d) m(3, 189, d)
#define BOOST_PP_REPEAT_2_191(m,d) BOOST_PP_REPEAT_2_190(m, d) m(3, 190, d)
#define BOOST_PP_REPEAT_2_192(m,d) BOOST_PP_REPEAT_2_191(m, d) m(3, 191, d)
#define BOOST_PP_REPEAT_2_193(m,d) BOOST_PP_REPEAT_2_192(m, d) m(3, 192, d)
#define BOOST_PP_REPEAT_2_194(m,d) BOOST_PP_REPEAT_2_193(m, d) m(3, 193, d)
#define BOOST_PP_REPEAT_2_195(m,d) BOOST_PP_REPEAT_2_194(m, d) m(3, 194, d)
#define BOOST_PP_REPEAT_2_196(m,d) BOOST_PP_REPEAT_2_195(m, d) m(3, 195, d)
#define BOOST_PP_REPEAT_2_197(m,d) BOOST_PP_REPEAT_2_196(m, d) m(3, 196, d)
#define BOOST_PP_REPEAT_2_198(m,d) BOOST_PP_REPEAT_2_197(m, d) m(3, 197, d)
#define BOOST_PP_REPEAT_2_199(m,d) BOOST_PP_REPEAT_2_198(m, d) m(3, 198, d)
#define BOOST_PP_REPEAT_2_200(m,d) BOOST_PP_REPEAT_2_199(m, d) m(3, 199, d)
#define BOOST_PP_REPEAT_2_201(m,d) BOOST_PP_REPEAT_2_200(m, d) m(3, 200, d)
#define BOOST_PP_REPEAT_2_202(m,d) BOOST_PP_REPEAT_2_201(m, d) m(3, 201, d)
#define BOOST_PP_REPEAT_2_203(m,d) BOOST_PP_REPEAT_2_202(m, d) m(3, 202, d)
#define BOOST_PP_REPEAT_2_204(m,d) BOOST_PP_REPEAT_2_203(m, d) m(3, 203, d)
#define BOOST_PP_REPEAT_2_205(m,d) BOOST_PP_REPEAT_2_204(m, d) m(3, 204, d)
#define BOOST_PP_REPEAT_2_206(m,d) BOOST_PP_REPEAT_2_205(m, d) m(3, 205, d)
#define BOOST_PP_REPEAT_2_207(m,d) BOOST_PP_REPEAT_2_206(m, d) m(3, 206, d)
#define BOOST_PP_REPEAT_2_208(m,d) BOOST_PP_REPEAT_2_207(m, d) m(3, 207, d)
#define BOOST_PP_REPEAT_2_209(m,d) BOOST_PP_REPEAT_2_208(m, d) m(3, 208, d)
#define BOOST_PP_REPEAT_2_210(m,d) BOOST_PP_REPEAT_2_209(m, d) m(3, 209, d)
#define BOOST_PP_REPEAT_2_211(m,d) BOOST_PP_REPEAT_2_210(m, d) m(3, 210, d)
#define BOOST_PP_REPEAT_2_212(m,d) BOOST_PP_REPEAT_2_211(m, d) m(3, 211, d)
#define BOOST_PP_REPEAT_2_213(m,d) BOOST_PP_REPEAT_2_212(m, d) m(3, 212, d)
#define BOOST_PP_REPEAT_2_214(m,d) BOOST_PP_REPEAT_2_213(m, d) m(3, 213, d)
#define BOOST_PP_REPEAT_2_215(m,d) BOOST_PP_REPEAT_2_214(m, d) m(3, 214, d)
#define BOOST_PP_REPEAT_2_216(m,d) BOOST_PP_REPEAT_2_215(m, d) m(3, 215, d)
#define BOOST_PP_REPEAT_2_217(m,d) BOOST_PP_REPEAT_2_216(m, d) m(3, 216, d)
#define BOOST_PP_REPEAT_2_218(m,d) BOOST_PP_REPEAT_2_217(m, d) m(3, 217, d)
#define BOOST_PP_REPEAT_2_219(m,d) BOOST_PP_REPEAT_2_218(m, d) m(3, 218, d)
#define BOOST_PP_REPEAT_2_220(m,d) BOOST_PP_REPEAT_2_219(m, d) m(3, 219, d)
#define BOOST_PP_REPEAT_2_221(m,d) BOOST_PP_REPEAT_2_220(m, d) m(3, 220, d)
#define BOOST_PP_REPEAT_2_222(m,d) BOOST_PP_REPEAT_2_221(m, d) m(3, 221, d)
#define BOOST_PP_REPEAT_2_223(m,d) BOOST_PP_REPEAT_2_222(m, d) m(3, 222, d)
#define BOOST_PP_REPEAT_2_224(m,d) BOOST_PP_REPEAT_2_223(m, d) m(3, 223, d)
#define BOOST_PP_REPEAT_2_225(m,d) BOOST_PP_REPEAT_2_224(m, d) m(3, 224, d)
#define BOOST_PP_REPEAT_2_226(m,d) BOOST_PP_REPEAT_2_225(m, d) m(3, 225, d)
#define BOOST_PP_REPEAT_2_227(m,d) BOOST_PP_REPEAT_2_226(m, d) m(3, 226, d)
#define BOOST_PP_REPEAT_2_228(m,d) BOOST_PP_REPEAT_2_227(m, d) m(3, 227, d)
#define BOOST_PP_REPEAT_2_229(m,d) BOOST_PP_REPEAT_2_228(m, d) m(3, 228, d)
#define BOOST_PP_REPEAT_2_230(m,d) BOOST_PP_REPEAT_2_229(m, d) m(3, 229, d)
#define BOOST_PP_REPEAT_2_231(m,d) BOOST_PP_REPEAT_2_230(m, d) m(3, 230, d)
#define BOOST_PP_REPEAT_2_232(m,d) BOOST_PP_REPEAT_2_231(m, d) m(3, 231, d)
#define BOOST_PP_REPEAT_2_233(m,d) BOOST_PP_REPEAT_2_232(m, d) m(3, 232, d)
#define BOOST_PP_REPEAT_2_234(m,d) BOOST_PP_REPEAT_2_233(m, d) m(3, 233, d)
#define BOOST_PP_REPEAT_2_235(m,d) BOOST_PP_REPEAT_2_234(m, d) m(3, 234, d)
#define BOOST_PP_REPEAT_2_236(m,d) BOOST_PP_REPEAT_2_235(m, d) m(3, 235, d)
#define BOOST_PP_REPEAT_2_237(m,d) BOOST_PP_REPEAT_2_236(m, d) m(3, 236, d)
#define BOOST_PP_REPEAT_2_238(m,d) BOOST_PP_REPEAT_2_237(m, d) m(3, 237, d)
#define BOOST_PP_REPEAT_2_239(m,d) BOOST_PP_REPEAT_2_238(m, d) m(3, 238, d)
#define BOOST_PP_REPEAT_2_240(m,d) BOOST_PP_REPEAT_2_239(m, d) m(3, 239, d)
#define BOOST_PP_REPEAT_2_241(m,d) BOOST_PP_REPEAT_2_240(m, d) m(3, 240, d)
#define BOOST_PP_REPEAT_2_242(m,d) BOOST_PP_REPEAT_2_241(m, d) m(3, 241, d)
#define BOOST_PP_REPEAT_2_243(m,d) BOOST_PP_REPEAT_2_242(m, d) m(3, 242, d)
#define BOOST_PP_REPEAT_2_244(m,d) BOOST_PP_REPEAT_2_243(m, d) m(3, 243, d)
#define BOOST_PP_REPEAT_2_245(m,d) BOOST_PP_REPEAT_2_244(m, d) m(3, 244, d)
#define BOOST_PP_REPEAT_2_246(m,d) BOOST_PP_REPEAT_2_245(m, d) m(3, 245, d)
#define BOOST_PP_REPEAT_2_247(m,d) BOOST_PP_REPEAT_2_246(m, d) m(3, 246, d)
#define BOOST_PP_REPEAT_2_248(m,d) BOOST_PP_REPEAT_2_247(m, d) m(3, 247, d)
#define BOOST_PP_REPEAT_2_249(m,d) BOOST_PP_REPEAT_2_248(m, d) m(3, 248, d)
#define BOOST_PP_REPEAT_2_250(m,d) BOOST_PP_REPEAT_2_249(m, d) m(3, 249, d)
#define BOOST_PP_REPEAT_2_251(m,d) BOOST_PP_REPEAT_2_250(m, d) m(3, 250, d)
#define BOOST_PP_REPEAT_2_252(m,d) BOOST_PP_REPEAT_2_251(m, d) m(3, 251, d)
#define BOOST_PP_REPEAT_2_253(m,d) BOOST_PP_REPEAT_2_252(m, d) m(3, 252, d)
#define BOOST_PP_REPEAT_2_254(m,d) BOOST_PP_REPEAT_2_253(m, d) m(3, 253, d)
#define BOOST_PP_REPEAT_2_255(m,d) BOOST_PP_REPEAT_2_254(m, d) m(3, 254, d)
#define BOOST_PP_REPEAT_2_256(m,d) BOOST_PP_REPEAT_2_255(m, d) m(3, 255, d)
#define BOOST_PP_REPEAT_3_0(m,d)
#define BOOST_PP_REPEAT_3_1(m,d) m(4, 0, d)
#define BOOST_PP_REPEAT_3_2(m,d) BOOST_PP_REPEAT_3_1(m, d) m(4, 1, d)
#define BOOST_PP_REPEAT_3_3(m,d) BOOST_PP_REPEAT_3_2(m, d) m(4, 2, d)
#define BOOST_PP_REPEAT_3_4(m,d) BOOST_PP_REPEAT_3_3(m, d) m(4, 3, d)
#define BOOST_PP_REPEAT_3_5(m,d) BOOST_PP_REPEAT_3_4(m, d) m(4, 4, d)
#define BOOST_PP_REPEAT_3_6(m,d) BOOST_PP_REPEAT_3_5(m, d) m(4, 5, d)
#define BOOST_PP_REPEAT_3_7(m,d) BOOST_PP_REPEAT_3_6(m, d) m(4, 6, d)
#define BOOST_PP_REPEAT_3_8(m,d) BOOST_PP_REPEAT_3_7(m, d) m(4, 7, d)
#define BOOST_PP_REPEAT_3_9(m,d) BOOST_PP_REPEAT_3_8(m, d) m(4, 8, d)
#define BOOST_PP_REPEAT_3_10(m,d) BOOST_PP_REPEAT_3_9(m, d) m(4, 9, d)
#define BOOST_PP_REPEAT_3_11(m,d) BOOST_PP_REPEAT_3_10(m, d) m(4, 10, d)
#define BOOST_PP_REPEAT_3_12(m,d) BOOST_PP_REPEAT_3_11(m, d) m(4, 11, d)
#define BOOST_PP_REPEAT_3_13(m,d) BOOST_PP_REPEAT_3_12(m, d) m(4, 12, d)
#define BOOST_PP_REPEAT_3_14(m,d) BOOST_PP_REPEAT_3_13(m, d) m(4, 13, d)
#define BOOST_PP_REPEAT_3_15(m,d) BOOST_PP_REPEAT_3_14(m, d) m(4, 14, d)
#define BOOST_PP_REPEAT_3_16(m,d) BOOST_PP_REPEAT_3_15(m, d) m(4, 15, d)
#define BOOST_PP_REPEAT_3_17(m,d) BOOST_PP_REPEAT_3_16(m, d) m(4, 16, d)
#define BOOST_PP_REPEAT_3_18(m,d) BOOST_PP_REPEAT_3_17(m, d) m(4, 17, d)
#define BOOST_PP_REPEAT_3_19(m,d) BOOST_PP_REPEAT_3_18(m, d) m(4, 18, d)
#define BOOST_PP_REPEAT_3_20(m,d) BOOST_PP_REPEAT_3_19(m, d) m(4, 19, d)
#define BOOST_PP_REPEAT_3_21(m,d) BOOST_PP_REPEAT_3_20(m, d) m(4, 20, d)
#define BOOST_PP_REPEAT_3_22(m,d) BOOST_PP_REPEAT_3_21(m, d) m(4, 21, d)
#define BOOST_PP_REPEAT_3_23(m,d) BOOST_PP_REPEAT_3_22(m, d) m(4, 22, d)
#define BOOST_PP_REPEAT_3_24(m,d) BOOST_PP_REPEAT_3_23(m, d) m(4, 23, d)
#define BOOST_PP_REPEAT_3_25(m,d) BOOST_PP_REPEAT_3_24(m, d) m(4, 24, d)
#define BOOST_PP_REPEAT_3_26(m,d) BOOST_PP_REPEAT_3_25(m, d) m(4, 25, d)
#define BOOST_PP_REPEAT_3_27(m,d) BOOST_PP_REPEAT_3_26(m, d) m(4, 26, d)
#define BOOST_PP_REPEAT_3_28(m,d) BOOST_PP_REPEAT_3_27(m, d) m(4, 27, d)
#define BOOST_PP_REPEAT_3_29(m,d) BOOST_PP_REPEAT_3_28(m, d) m(4, 28, d)
#define BOOST_PP_REPEAT_3_30(m,d) BOOST_PP_REPEAT_3_29(m, d) m(4, 29, d)
#define BOOST_PP_REPEAT_3_31(m,d) BOOST_PP_REPEAT_3_30(m, d) m(4, 30, d)
#define BOOST_PP_REPEAT_3_32(m,d) BOOST_PP_REPEAT_3_31(m, d) m(4, 31, d)
#define BOOST_PP_REPEAT_3_33(m,d) BOOST_PP_REPEAT_3_32(m, d) m(4, 32, d)
#define BOOST_PP_REPEAT_3_34(m,d) BOOST_PP_REPEAT_3_33(m, d) m(4, 33, d)
#define BOOST_PP_REPEAT_3_35(m,d) BOOST_PP_REPEAT_3_34(m, d) m(4, 34, d)
#define BOOST_PP_REPEAT_3_36(m,d) BOOST_PP_REPEAT_3_35(m, d) m(4, 35, d)
#define BOOST_PP_REPEAT_3_37(m,d) BOOST_PP_REPEAT_3_36(m, d) m(4, 36, d)
#define BOOST_PP_REPEAT_3_38(m,d) BOOST_PP_REPEAT_3_37(m, d) m(4, 37, d)
#define BOOST_PP_REPEAT_3_39(m,d) BOOST_PP_REPEAT_3_38(m, d) m(4, 38, d)
#define BOOST_PP_REPEAT_3_40(m,d) BOOST_PP_REPEAT_3_39(m, d) m(4, 39, d)
#define BOOST_PP_REPEAT_3_41(m,d) BOOST_PP_REPEAT_3_40(m, d) m(4, 40, d)
#define BOOST_PP_REPEAT_3_42(m,d) BOOST_PP_REPEAT_3_41(m, d) m(4, 41, d)
#define BOOST_PP_REPEAT_3_43(m,d) BOOST_PP_REPEAT_3_42(m, d) m(4, 42, d)
#define BOOST_PP_REPEAT_3_44(m,d) BOOST_PP_REPEAT_3_43(m, d) m(4, 43, d)
#define BOOST_PP_REPEAT_3_45(m,d) BOOST_PP_REPEAT_3_44(m, d) m(4, 44, d)
#define BOOST_PP_REPEAT_3_46(m,d) BOOST_PP_REPEAT_3_45(m, d) m(4, 45, d)
#define BOOST_PP_REPEAT_3_47(m,d) BOOST_PP_REPEAT_3_46(m, d) m(4, 46, d)
#define BOOST_PP_REPEAT_3_48(m,d) BOOST_PP_REPEAT_3_47(m, d) m(4, 47, d)
#define BOOST_PP_REPEAT_3_49(m,d) BOOST_PP_REPEAT_3_48(m, d) m(4, 48, d)
#define BOOST_PP_REPEAT_3_50(m,d) BOOST_PP_REPEAT_3_49(m, d) m(4, 49, d)
#define BOOST_PP_REPEAT_3_51(m,d) BOOST_PP_REPEAT_3_50(m, d) m(4, 50, d)
#define BOOST_PP_REPEAT_3_52(m,d) BOOST_PP_REPEAT_3_51(m, d) m(4, 51, d)
#define BOOST_PP_REPEAT_3_53(m,d) BOOST_PP_REPEAT_3_52(m, d) m(4, 52, d)
#define BOOST_PP_REPEAT_3_54(m,d) BOOST_PP_REPEAT_3_53(m, d) m(4, 53, d)
#define BOOST_PP_REPEAT_3_55(m,d) BOOST_PP_REPEAT_3_54(m, d) m(4, 54, d)
#define BOOST_PP_REPEAT_3_56(m,d) BOOST_PP_REPEAT_3_55(m, d) m(4, 55, d)
#define BOOST_PP_REPEAT_3_57(m,d) BOOST_PP_REPEAT_3_56(m, d) m(4, 56, d)
#define BOOST_PP_REPEAT_3_58(m,d) BOOST_PP_REPEAT_3_57(m, d) m(4, 57, d)
#define BOOST_PP_REPEAT_3_59(m,d) BOOST_PP_REPEAT_3_58(m, d) m(4, 58, d)
#define BOOST_PP_REPEAT_3_60(m,d) BOOST_PP_REPEAT_3_59(m, d) m(4, 59, d)
#define BOOST_PP_REPEAT_3_61(m,d) BOOST_PP_REPEAT_3_60(m, d) m(4, 60, d)
#define BOOST_PP_REPEAT_3_62(m,d) BOOST_PP_REPEAT_3_61(m, d) m(4, 61, d)
#define BOOST_PP_REPEAT_3_63(m,d) BOOST_PP_REPEAT_3_62(m, d) m(4, 62, d)
#define BOOST_PP_REPEAT_3_64(m,d) BOOST_PP_REPEAT_3_63(m, d) m(4, 63, d)
#define BOOST_PP_REPEAT_3_65(m,d) BOOST_PP_REPEAT_3_64(m, d) m(4, 64, d)
#define BOOST_PP_REPEAT_3_66(m,d) BOOST_PP_REPEAT_3_65(m, d) m(4, 65, d)
#define BOOST_PP_REPEAT_3_67(m,d) BOOST_PP_REPEAT_3_66(m, d) m(4, 66, d)
#define BOOST_PP_REPEAT_3_68(m,d) BOOST_PP_REPEAT_3_67(m, d) m(4, 67, d)
#define BOOST_PP_REPEAT_3_69(m,d) BOOST_PP_REPEAT_3_68(m, d) m(4, 68, d)
#define BOOST_PP_REPEAT_3_70(m,d) BOOST_PP_REPEAT_3_69(m, d) m(4, 69, d)
#define BOOST_PP_REPEAT_3_71(m,d) BOOST_PP_REPEAT_3_70(m, d) m(4, 70, d)
#define BOOST_PP_REPEAT_3_72(m,d) BOOST_PP_REPEAT_3_71(m, d) m(4, 71, d)
#define BOOST_PP_REPEAT_3_73(m,d) BOOST_PP_REPEAT_3_72(m, d) m(4, 72, d)
#define BOOST_PP_REPEAT_3_74(m,d) BOOST_PP_REPEAT_3_73(m, d) m(4, 73, d)
#define BOOST_PP_REPEAT_3_75(m,d) BOOST_PP_REPEAT_3_74(m, d) m(4, 74, d)
#define BOOST_PP_REPEAT_3_76(m,d) BOOST_PP_REPEAT_3_75(m, d) m(4, 75, d)
#define BOOST_PP_REPEAT_3_77(m,d) BOOST_PP_REPEAT_3_76(m, d) m(4, 76, d)
#define BOOST_PP_REPEAT_3_78(m,d) BOOST_PP_REPEAT_3_77(m, d) m(4, 77, d)
#define BOOST_PP_REPEAT_3_79(m,d) BOOST_PP_REPEAT_3_78(m, d) m(4, 78, d)
#define BOOST_PP_REPEAT_3_80(m,d) BOOST_PP_REPEAT_3_79(m, d) m(4, 79, d)
#define BOOST_PP_REPEAT_3_81(m,d) BOOST_PP_REPEAT_3_80(m, d) m(4, 80, d)
#define BOOST_PP_REPEAT_3_82(m,d) BOOST_PP_REPEAT_3_81(m, d) m(4, 81, d)
#define BOOST_PP_REPEAT_3_83(m,d) BOOST_PP_REPEAT_3_82(m, d) m(4, 82, d)
#define BOOST_PP_REPEAT_3_84(m,d) BOOST_PP_REPEAT_3_83(m, d) m(4, 83, d)
#define BOOST_PP_REPEAT_3_85(m,d) BOOST_PP_REPEAT_3_84(m, d) m(4, 84, d)
#define BOOST_PP_REPEAT_3_86(m,d) BOOST_PP_REPEAT_3_85(m, d) m(4, 85, d)
#define BOOST_PP_REPEAT_3_87(m,d) BOOST_PP_REPEAT_3_86(m, d) m(4, 86, d)
#define BOOST_PP_REPEAT_3_88(m,d) BOOST_PP_REPEAT_3_87(m, d) m(4, 87, d)
#define BOOST_PP_REPEAT_3_89(m,d) BOOST_PP_REPEAT_3_88(m, d) m(4, 88, d)
#define BOOST_PP_REPEAT_3_90(m,d) BOOST_PP_REPEAT_3_89(m, d) m(4, 89, d)
#define BOOST_PP_REPEAT_3_91(m,d) BOOST_PP_REPEAT_3_90(m, d) m(4, 90, d)
#define BOOST_PP_REPEAT_3_92(m,d) BOOST_PP_REPEAT_3_91(m, d) m(4, 91, d)
#define BOOST_PP_REPEAT_3_93(m,d) BOOST_PP_REPEAT_3_92(m, d) m(4, 92, d)
#define BOOST_PP_REPEAT_3_94(m,d) BOOST_PP_REPEAT_3_93(m, d) m(4, 93, d)
#define BOOST_PP_REPEAT_3_95(m,d) BOOST_PP_REPEAT_3_94(m, d) m(4, 94, d)
#define BOOST_PP_REPEAT_3_96(m,d) BOOST_PP_REPEAT_3_95(m, d) m(4, 95, d)
#define BOOST_PP_REPEAT_3_97(m,d) BOOST_PP_REPEAT_3_96(m, d) m(4, 96, d)
#define BOOST_PP_REPEAT_3_98(m,d) BOOST_PP_REPEAT_3_97(m, d) m(4, 97, d)
#define BOOST_PP_REPEAT_3_99(m,d) BOOST_PP_REPEAT_3_98(m, d) m(4, 98, d)
#define BOOST_PP_REPEAT_3_100(m,d) BOOST_PP_REPEAT_3_99(m, d) m(4, 99, d)
#define BOOST_PP_REPEAT_3_101(m,d) BOOST_PP_REPEAT_3_100(m, d) m(4, 100, d)
#define BOOST_PP_REPEAT_3_102(m,d) BOOST_PP_REPEAT_3_101(m, d) m(4, 101, d)
#define BOOST_PP_REPEAT_3_103(m,d) BOOST_PP_REPEAT_3_102(m, d) m(4, 102, d)
#define BOOST_PP_REPEAT_3_104(m,d) BOOST_PP_REPEAT_3_103(m, d) m(4, 103, d)
#define BOOST_PP_REPEAT_3_105(m,d) BOOST_PP_REPEAT_3_104(m, d) m(4, 104, d)
#define BOOST_PP_REPEAT_3_106(m,d) BOOST_PP_REPEAT_3_105(m, d) m(4, 105, d)
#define BOOST_PP_REPEAT_3_107(m,d) BOOST_PP_REPEAT_3_106(m, d) m(4, 106, d)
#define BOOST_PP_REPEAT_3_108(m,d) BOOST_PP_REPEAT_3_107(m, d) m(4, 107, d)
#define BOOST_PP_REPEAT_3_109(m,d) BOOST_PP_REPEAT_3_108(m, d) m(4, 108, d)
#define BOOST_PP_REPEAT_3_110(m,d) BOOST_PP_REPEAT_3_109(m, d) m(4, 109, d)
#define BOOST_PP_REPEAT_3_111(m,d) BOOST_PP_REPEAT_3_110(m, d) m(4, 110, d)
#define BOOST_PP_REPEAT_3_112(m,d) BOOST_PP_REPEAT_3_111(m, d) m(4, 111, d)
#define BOOST_PP_REPEAT_3_113(m,d) BOOST_PP_REPEAT_3_112(m, d) m(4, 112, d)
#define BOOST_PP_REPEAT_3_114(m,d) BOOST_PP_REPEAT_3_113(m, d) m(4, 113, d)
#define BOOST_PP_REPEAT_3_115(m,d) BOOST_PP_REPEAT_3_114(m, d) m(4, 114, d)
#define BOOST_PP_REPEAT_3_116(m,d) BOOST_PP_REPEAT_3_115(m, d) m(4, 115, d)
#define BOOST_PP_REPEAT_3_117(m,d) BOOST_PP_REPEAT_3_116(m, d) m(4, 116, d)
#define BOOST_PP_REPEAT_3_118(m,d) BOOST_PP_REPEAT_3_117(m, d) m(4, 117, d)
#define BOOST_PP_REPEAT_3_119(m,d) BOOST_PP_REPEAT_3_118(m, d) m(4, 118, d)
#define BOOST_PP_REPEAT_3_120(m,d) BOOST_PP_REPEAT_3_119(m, d) m(4, 119, d)
#define BOOST_PP_REPEAT_3_121(m,d) BOOST_PP_REPEAT_3_120(m, d) m(4, 120, d)
#define BOOST_PP_REPEAT_3_122(m,d) BOOST_PP_REPEAT_3_121(m, d) m(4, 121, d)
#define BOOST_PP_REPEAT_3_123(m,d) BOOST_PP_REPEAT_3_122(m, d) m(4, 122, d)
#define BOOST_PP_REPEAT_3_124(m,d) BOOST_PP_REPEAT_3_123(m, d) m(4, 123, d)
#define BOOST_PP_REPEAT_3_125(m,d) BOOST_PP_REPEAT_3_124(m, d) m(4, 124, d)
#define BOOST_PP_REPEAT_3_126(m,d) BOOST_PP_REPEAT_3_125(m, d) m(4, 125, d)
#define BOOST_PP_REPEAT_3_127(m,d) BOOST_PP_REPEAT_3_126(m, d) m(4, 126, d)
#define BOOST_PP_REPEAT_3_128(m,d) BOOST_PP_REPEAT_3_127(m, d) m(4, 127, d)
#define BOOST_PP_REPEAT_3_129(m,d) BOOST_PP_REPEAT_3_128(m, d) m(4, 128, d)
#define BOOST_PP_REPEAT_3_130(m,d) BOOST_PP_REPEAT_3_129(m, d) m(4, 129, d)
#define BOOST_PP_REPEAT_3_131(m,d) BOOST_PP_REPEAT_3_130(m, d) m(4, 130, d)
#define BOOST_PP_REPEAT_3_132(m,d) BOOST_PP_REPEAT_3_131(m, d) m(4, 131, d)
#define BOOST_PP_REPEAT_3_133(m,d) BOOST_PP_REPEAT_3_132(m, d) m(4, 132, d)
#define BOOST_PP_REPEAT_3_134(m,d) BOOST_PP_REPEAT_3_133(m, d) m(4, 133, d)
#define BOOST_PP_REPEAT_3_135(m,d) BOOST_PP_REPEAT_3_134(m, d) m(4, 134, d)
#define BOOST_PP_REPEAT_3_136(m,d) BOOST_PP_REPEAT_3_135(m, d) m(4, 135, d)
#define BOOST_PP_REPEAT_3_137(m,d) BOOST_PP_REPEAT_3_136(m, d) m(4, 136, d)
#define BOOST_PP_REPEAT_3_138(m,d) BOOST_PP_REPEAT_3_137(m, d) m(4, 137, d)
#define BOOST_PP_REPEAT_3_139(m,d) BOOST_PP_REPEAT_3_138(m, d) m(4, 138, d)
#define BOOST_PP_REPEAT_3_140(m,d) BOOST_PP_REPEAT_3_139(m, d) m(4, 139, d)
#define BOOST_PP_REPEAT_3_141(m,d) BOOST_PP_REPEAT_3_140(m, d) m(4, 140, d)
#define BOOST_PP_REPEAT_3_142(m,d) BOOST_PP_REPEAT_3_141(m, d) m(4, 141, d)
#define BOOST_PP_REPEAT_3_143(m,d) BOOST_PP_REPEAT_3_142(m, d) m(4, 142, d)
#define BOOST_PP_REPEAT_3_144(m,d) BOOST_PP_REPEAT_3_143(m, d) m(4, 143, d)
#define BOOST_PP_REPEAT_3_145(m,d) BOOST_PP_REPEAT_3_144(m, d) m(4, 144, d)
#define BOOST_PP_REPEAT_3_146(m,d) BOOST_PP_REPEAT_3_145(m, d) m(4, 145, d)
#define BOOST_PP_REPEAT_3_147(m,d) BOOST_PP_REPEAT_3_146(m, d) m(4, 146, d)
#define BOOST_PP_REPEAT_3_148(m,d) BOOST_PP_REPEAT_3_147(m, d) m(4, 147, d)
#define BOOST_PP_REPEAT_3_149(m,d) BOOST_PP_REPEAT_3_148(m, d) m(4, 148, d)
#define BOOST_PP_REPEAT_3_150(m,d) BOOST_PP_REPEAT_3_149(m, d) m(4, 149, d)
#define BOOST_PP_REPEAT_3_151(m,d) BOOST_PP_REPEAT_3_150(m, d) m(4, 150, d)
#define BOOST_PP_REPEAT_3_152(m,d) BOOST_PP_REPEAT_3_151(m, d) m(4, 151, d)
#define BOOST_PP_REPEAT_3_153(m,d) BOOST_PP_REPEAT_3_152(m, d) m(4, 152, d)
#define BOOST_PP_REPEAT_3_154(m,d) BOOST_PP_REPEAT_3_153(m, d) m(4, 153, d)
#define BOOST_PP_REPEAT_3_155(m,d) BOOST_PP_REPEAT_3_154(m, d) m(4, 154, d)
#define BOOST_PP_REPEAT_3_156(m,d) BOOST_PP_REPEAT_3_155(m, d) m(4, 155, d)
#define BOOST_PP_REPEAT_3_157(m,d) BOOST_PP_REPEAT_3_156(m, d) m(4, 156, d)
#define BOOST_PP_REPEAT_3_158(m,d) BOOST_PP_REPEAT_3_157(m, d) m(4, 157, d)
#define BOOST_PP_REPEAT_3_159(m,d) BOOST_PP_REPEAT_3_158(m, d) m(4, 158, d)
#define BOOST_PP_REPEAT_3_160(m,d) BOOST_PP_REPEAT_3_159(m, d) m(4, 159, d)
#define BOOST_PP_REPEAT_3_161(m,d) BOOST_PP_REPEAT_3_160(m, d) m(4, 160, d)
#define BOOST_PP_REPEAT_3_162(m,d) BOOST_PP_REPEAT_3_161(m, d) m(4, 161, d)
#define BOOST_PP_REPEAT_3_163(m,d) BOOST_PP_REPEAT_3_162(m, d) m(4, 162, d)
#define BOOST_PP_REPEAT_3_164(m,d) BOOST_PP_REPEAT_3_163(m, d) m(4, 163, d)
#define BOOST_PP_REPEAT_3_165(m,d) BOOST_PP_REPEAT_3_164(m, d) m(4, 164, d)
#define BOOST_PP_REPEAT_3_166(m,d) BOOST_PP_REPEAT_3_165(m, d) m(4, 165, d)
#define BOOST_PP_REPEAT_3_167(m,d) BOOST_PP_REPEAT_3_166(m, d) m(4, 166, d)
#define BOOST_PP_REPEAT_3_168(m,d) BOOST_PP_REPEAT_3_167(m, d) m(4, 167, d)
#define BOOST_PP_REPEAT_3_169(m,d) BOOST_PP_REPEAT_3_168(m, d) m(4, 168, d)
#define BOOST_PP_REPEAT_3_170(m,d) BOOST_PP_REPEAT_3_169(m, d) m(4, 169, d)
#define BOOST_PP_REPEAT_3_171(m,d) BOOST_PP_REPEAT_3_170(m, d) m(4, 170, d)
#define BOOST_PP_REPEAT_3_172(m,d) BOOST_PP_REPEAT_3_171(m, d) m(4, 171, d)
#define BOOST_PP_REPEAT_3_173(m,d) BOOST_PP_REPEAT_3_172(m, d) m(4, 172, d)
#define BOOST_PP_REPEAT_3_174(m,d) BOOST_PP_REPEAT_3_173(m, d) m(4, 173, d)
#define BOOST_PP_REPEAT_3_175(m,d) BOOST_PP_REPEAT_3_174(m, d) m(4, 174, d)
#define BOOST_PP_REPEAT_3_176(m,d) BOOST_PP_REPEAT_3_175(m, d) m(4, 175, d)
#define BOOST_PP_REPEAT_3_177(m,d) BOOST_PP_REPEAT_3_176(m, d) m(4, 176, d)
#define BOOST_PP_REPEAT_3_178(m,d) BOOST_PP_REPEAT_3_177(m, d) m(4, 177, d)
#define BOOST_PP_REPEAT_3_179(m,d) BOOST_PP_REPEAT_3_178(m, d) m(4, 178, d)
#define BOOST_PP_REPEAT_3_180(m,d) BOOST_PP_REPEAT_3_179(m, d) m(4, 179, d)
#define BOOST_PP_REPEAT_3_181(m,d) BOOST_PP_REPEAT_3_180(m, d) m(4, 180, d)
#define BOOST_PP_REPEAT_3_182(m,d) BOOST_PP_REPEAT_3_181(m, d) m(4, 181, d)
#define BOOST_PP_REPEAT_3_183(m,d) BOOST_PP_REPEAT_3_182(m, d) m(4, 182, d)
#define BOOST_PP_REPEAT_3_184(m,d) BOOST_PP_REPEAT_3_183(m, d) m(4, 183, d)
#define BOOST_PP_REPEAT_3_185(m,d) BOOST_PP_REPEAT_3_184(m, d) m(4, 184, d)
#define BOOST_PP_REPEAT_3_186(m,d) BOOST_PP_REPEAT_3_185(m, d) m(4, 185, d)
#define BOOST_PP_REPEAT_3_187(m,d) BOOST_PP_REPEAT_3_186(m, d) m(4, 186, d)
#define BOOST_PP_REPEAT_3_188(m,d) BOOST_PP_REPEAT_3_187(m, d) m(4, 187, d)
#define BOOST_PP_REPEAT_3_189(m,d) BOOST_PP_REPEAT_3_188(m, d) m(4, 188, d)
#define BOOST_PP_REPEAT_3_190(m,d) BOOST_PP_REPEAT_3_189(m, d) m(4, 189, d)
#define BOOST_PP_REPEAT_3_191(m,d) BOOST_PP_REPEAT_3_190(m, d) m(4, 190, d)
#define BOOST_PP_REPEAT_3_192(m,d) BOOST_PP_REPEAT_3_191(m, d) m(4, 191, d)
#define BOOST_PP_REPEAT_3_193(m,d) BOOST_PP_REPEAT_3_192(m, d) m(4, 192, d)
#define BOOST_PP_REPEAT_3_194(m,d) BOOST_PP_REPEAT_3_193(m, d) m(4, 193, d)
#define BOOST_PP_REPEAT_3_195(m,d) BOOST_PP_REPEAT_3_194(m, d) m(4, 194, d)
#define BOOST_PP_REPEAT_3_196(m,d) BOOST_PP_REPEAT_3_195(m, d) m(4, 195, d)
#define BOOST_PP_REPEAT_3_197(m,d) BOOST_PP_REPEAT_3_196(m, d) m(4, 196, d)
#define BOOST_PP_REPEAT_3_198(m,d) BOOST_PP_REPEAT_3_197(m, d) m(4, 197, d)
#define BOOST_PP_REPEAT_3_199(m,d) BOOST_PP_REPEAT_3_198(m, d) m(4, 198, d)
#define BOOST_PP_REPEAT_3_200(m,d) BOOST_PP_REPEAT_3_199(m, d) m(4, 199, d)
#define BOOST_PP_REPEAT_3_201(m,d) BOOST_PP_REPEAT_3_200(m, d) m(4, 200, d)
#define BOOST_PP_REPEAT_3_202(m,d) BOOST_PP_REPEAT_3_201(m, d) m(4, 201, d)
#define BOOST_PP_REPEAT_3_203(m,d) BOOST_PP_REPEAT_3_202(m, d) m(4, 202, d)
#define BOOST_PP_REPEAT_3_204(m,d) BOOST_PP_REPEAT_3_203(m, d) m(4, 203, d)
#define BOOST_PP_REPEAT_3_205(m,d) BOOST_PP_REPEAT_3_204(m, d) m(4, 204, d)
#define BOOST_PP_REPEAT_3_206(m,d) BOOST_PP_REPEAT_3_205(m, d) m(4, 205, d)
#define BOOST_PP_REPEAT_3_207(m,d) BOOST_PP_REPEAT_3_206(m, d) m(4, 206, d)
#define BOOST_PP_REPEAT_3_208(m,d) BOOST_PP_REPEAT_3_207(m, d) m(4, 207, d)
#define BOOST_PP_REPEAT_3_209(m,d) BOOST_PP_REPEAT_3_208(m, d) m(4, 208, d)
#define BOOST_PP_REPEAT_3_210(m,d) BOOST_PP_REPEAT_3_209(m, d) m(4, 209, d)
#define BOOST_PP_REPEAT_3_211(m,d) BOOST_PP_REPEAT_3_210(m, d) m(4, 210, d)
#define BOOST_PP_REPEAT_3_212(m,d) BOOST_PP_REPEAT_3_211(m, d) m(4, 211, d)
#define BOOST_PP_REPEAT_3_213(m,d) BOOST_PP_REPEAT_3_212(m, d) m(4, 212, d)
#define BOOST_PP_REPEAT_3_214(m,d) BOOST_PP_REPEAT_3_213(m, d) m(4, 213, d)
#define BOOST_PP_REPEAT_3_215(m,d) BOOST_PP_REPEAT_3_214(m, d) m(4, 214, d)
#define BOOST_PP_REPEAT_3_216(m,d) BOOST_PP_REPEAT_3_215(m, d) m(4, 215, d)
#define BOOST_PP_REPEAT_3_217(m,d) BOOST_PP_REPEAT_3_216(m, d) m(4, 216, d)
#define BOOST_PP_REPEAT_3_218(m,d) BOOST_PP_REPEAT_3_217(m, d) m(4, 217, d)
#define BOOST_PP_REPEAT_3_219(m,d) BOOST_PP_REPEAT_3_218(m, d) m(4, 218, d)
#define BOOST_PP_REPEAT_3_220(m,d) BOOST_PP_REPEAT_3_219(m, d) m(4, 219, d)
#define BOOST_PP_REPEAT_3_221(m,d) BOOST_PP_REPEAT_3_220(m, d) m(4, 220, d)
#define BOOST_PP_REPEAT_3_222(m,d) BOOST_PP_REPEAT_3_221(m, d) m(4, 221, d)
#define BOOST_PP_REPEAT_3_223(m,d) BOOST_PP_REPEAT_3_222(m, d) m(4, 222, d)
#define BOOST_PP_REPEAT_3_224(m,d) BOOST_PP_REPEAT_3_223(m, d) m(4, 223, d)
#define BOOST_PP_REPEAT_3_225(m,d) BOOST_PP_REPEAT_3_224(m, d) m(4, 224, d)
#define BOOST_PP_REPEAT_3_226(m,d) BOOST_PP_REPEAT_3_225(m, d) m(4, 225, d)
#define BOOST_PP_REPEAT_3_227(m,d) BOOST_PP_REPEAT_3_226(m, d) m(4, 226, d)
#define BOOST_PP_REPEAT_3_228(m,d) BOOST_PP_REPEAT_3_227(m, d) m(4, 227, d)
#define BOOST_PP_REPEAT_3_229(m,d) BOOST_PP_REPEAT_3_228(m, d) m(4, 228, d)
#define BOOST_PP_REPEAT_3_230(m,d) BOOST_PP_REPEAT_3_229(m, d) m(4, 229, d)
#define BOOST_PP_REPEAT_3_231(m,d) BOOST_PP_REPEAT_3_230(m, d) m(4, 230, d)
#define BOOST_PP_REPEAT_3_232(m,d) BOOST_PP_REPEAT_3_231(m, d) m(4, 231, d)
#define BOOST_PP_REPEAT_3_233(m,d) BOOST_PP_REPEAT_3_232(m, d) m(4, 232, d)
#define BOOST_PP_REPEAT_3_234(m,d) BOOST_PP_REPEAT_3_233(m, d) m(4, 233, d)
#define BOOST_PP_REPEAT_3_235(m,d) BOOST_PP_REPEAT_3_234(m, d) m(4, 234, d)
#define BOOST_PP_REPEAT_3_236(m,d) BOOST_PP_REPEAT_3_235(m, d) m(4, 235, d)
#define BOOST_PP_REPEAT_3_237(m,d) BOOST_PP_REPEAT_3_236(m, d) m(4, 236, d)
#define BOOST_PP_REPEAT_3_238(m,d) BOOST_PP_REPEAT_3_237(m, d) m(4, 237, d)
#define BOOST_PP_REPEAT_3_239(m,d) BOOST_PP_REPEAT_3_238(m, d) m(4, 238, d)
#define BOOST_PP_REPEAT_3_240(m,d) BOOST_PP_REPEAT_3_239(m, d) m(4, 239, d)
#define BOOST_PP_REPEAT_3_241(m,d) BOOST_PP_REPEAT_3_240(m, d) m(4, 240, d)
#define BOOST_PP_REPEAT_3_242(m,d) BOOST_PP_REPEAT_3_241(m, d) m(4, 241, d)
#define BOOST_PP_REPEAT_3_243(m,d) BOOST_PP_REPEAT_3_242(m, d) m(4, 242, d)
#define BOOST_PP_REPEAT_3_244(m,d) BOOST_PP_REPEAT_3_243(m, d) m(4, 243, d)
#define BOOST_PP_REPEAT_3_245(m,d) BOOST_PP_REPEAT_3_244(m, d) m(4, 244, d)
#define BOOST_PP_REPEAT_3_246(m,d) BOOST_PP_REPEAT_3_245(m, d) m(4, 245, d)
#define BOOST_PP_REPEAT_3_247(m,d) BOOST_PP_REPEAT_3_246(m, d) m(4, 246, d)
#define BOOST_PP_REPEAT_3_248(m,d) BOOST_PP_REPEAT_3_247(m, d) m(4, 247, d)
#define BOOST_PP_REPEAT_3_249(m,d) BOOST_PP_REPEAT_3_248(m, d) m(4, 248, d)
#define BOOST_PP_REPEAT_3_250(m,d) BOOST_PP_REPEAT_3_249(m, d) m(4, 249, d)
#define BOOST_PP_REPEAT_3_251(m,d) BOOST_PP_REPEAT_3_250(m, d) m(4, 250, d)
#define BOOST_PP_REPEAT_3_252(m,d) BOOST_PP_REPEAT_3_251(m, d) m(4, 251, d)
#define BOOST_PP_REPEAT_3_253(m,d) BOOST_PP_REPEAT_3_252(m, d) m(4, 252, d)
#define BOOST_PP_REPEAT_3_254(m,d) BOOST_PP_REPEAT_3_253(m, d) m(4, 253, d)
#define BOOST_PP_REPEAT_3_255(m,d) BOOST_PP_REPEAT_3_254(m, d) m(4, 254, d)
#define BOOST_PP_REPEAT_3_256(m,d) BOOST_PP_REPEAT_3_255(m, d) m(4, 255, d)
#define BOOST_PREPROCESSOR_INC_HPP
#define BOOST_PREPROCESSOR_ARITHMETIC_INC_HPP
#define BOOST_PP_INC(x) BOOST_PP_INC_I(x)
#define BOOST_PP_INC_I(x) BOOST_PP_INC_ ## x
#define BOOST_PP_INC_0 1
#define BOOST_PP_INC_1 2
#define BOOST_PP_INC_2 3
#define BOOST_PP_INC_3 4
#define BOOST_PP_INC_4 5
#define BOOST_PP_INC_5 6
#define BOOST_PP_INC_6 7
#define BOOST_PP_INC_7 8
#define BOOST_PP_INC_8 9
#define BOOST_PP_INC_9 10
#define BOOST_PP_INC_10 11
#define BOOST_PP_INC_11 12
#define BOOST_PP_INC_12 13
#define BOOST_PP_INC_13 14
#define BOOST_PP_INC_14 15
#define BOOST_PP_INC_15 16
#define BOOST_PP_INC_16 17
#define BOOST_PP_INC_17 18
#define BOOST_PP_INC_18 19
#define BOOST_PP_INC_19 20
#define BOOST_PP_INC_20 21
#define BOOST_PP_INC_21 22
#define BOOST_PP_INC_22 23
#define BOOST_PP_INC_23 24
#define BOOST_PP_INC_24 25
#define BOOST_PP_INC_25 26
#define BOOST_PP_INC_26 27
#define BOOST_PP_INC_27 28
#define BOOST_PP_INC_28 29
#define BOOST_PP_INC_29 30
#define BOOST_PP_INC_30 31
#define BOOST_PP_INC_31 32
#define BOOST_PP_INC_32 33
#define BOOST_PP_INC_33 34
#define BOOST_PP_INC_34 35
#define BOOST_PP_INC_35 36
#define BOOST_PP_INC_36 37
#define BOOST_PP_INC_37 38
#define BOOST_PP_INC_38 39
#define BOOST_PP_INC_39 40
#define BOOST_PP_INC_40 41
#define BOOST_PP_INC_41 42
#define BOOST_PP_INC_42 43
#define BOOST_PP_INC_43 44
#define BOOST_PP_INC_44 45
#define BOOST_PP_INC_45 46
#define BOOST_PP_INC_46 47
#define BOOST_PP_INC_47 48
#define BOOST_PP_INC_48 49
#define BOOST_PP_INC_49 50
#define BOOST_PP_INC_50 51
#define BOOST_PP_INC_51 52
#define BOOST_PP_INC_52 53
#define BOOST_PP_INC_53 54
#define BOOST_PP_INC_54 55
#define BOOST_PP_INC_55 56
#define BOOST_PP_INC_56 57
#define BOOST_PP_INC_57 58
#define BOOST_PP_INC_58 59
#define BOOST_PP_INC_59 60
#define BOOST_PP_INC_60 61
#define BOOST_PP_INC_61 62
#define BOOST_PP_INC_62 63
#define BOOST_PP_INC_63 64
#define BOOST_PP_INC_64 65
#define BOOST_PP_INC_65 66
#define BOOST_PP_INC_66 67
#define BOOST_PP_INC_67 68
#define BOOST_PP_INC_68 69
#define BOOST_PP_INC_69 70
#define BOOST_PP_INC_70 71
#define BOOST_PP_INC_71 72
#define BOOST_PP_INC_72 73
#define BOOST_PP_INC_73 74
#define BOOST_PP_INC_74 75
#define BOOST_PP_INC_75 76
#define BOOST_PP_INC_76 77
#define BOOST_PP_INC_77 78
#define BOOST_PP_INC_78 79
#define BOOST_PP_INC_79 80
#define BOOST_PP_INC_80 81
#define BOOST_PP_INC_81 82
#define BOOST_PP_INC_82 83
#define BOOST_PP_INC_83 84
#define BOOST_PP_INC_84 85
#define BOOST_PP_INC_85 86
#define BOOST_PP_INC_86 87
#define BOOST_PP_INC_87 88
#define BOOST_PP_INC_88 89
#define BOOST_PP_INC_89 90
#define BOOST_PP_INC_90 91
#define BOOST_PP_INC_91 92
#define BOOST_PP_INC_92 93
#define BOOST_PP_INC_93 94
#define BOOST_PP_INC_94 95
#define BOOST_PP_INC_95 96
#define BOOST_PP_INC_96 97
#define BOOST_PP_INC_97 98
#define BOOST_PP_INC_98 99
#define BOOST_PP_INC_99 100
#define BOOST_PP_INC_100 101
#define BOOST_PP_INC_101 102
#define BOOST_PP_INC_102 103
#define BOOST_PP_INC_103 104
#define BOOST_PP_INC_104 105
#define BOOST_PP_INC_105 106
#define BOOST_PP_INC_106 107
#define BOOST_PP_INC_107 108
#define BOOST_PP_INC_108 109
#define BOOST_PP_INC_109 110
#define BOOST_PP_INC_110 111
#define BOOST_PP_INC_111 112
#define BOOST_PP_INC_112 113
#define BOOST_PP_INC_113 114
#define BOOST_PP_INC_114 115
#define BOOST_PP_INC_115 116
#define BOOST_PP_INC_116 117
#define BOOST_PP_INC_117 118
#define BOOST_PP_INC_118 119
#define BOOST_PP_INC_119 120
#define BOOST_PP_INC_120 121
#define BOOST_PP_INC_121 122
#define BOOST_PP_INC_122 123
#define BOOST_PP_INC_123 124
#define BOOST_PP_INC_124 125
#define BOOST_PP_INC_125 126
#define BOOST_PP_INC_126 127
#define BOOST_PP_INC_127 128
#define BOOST_PP_INC_128 129
#define BOOST_PP_INC_129 130
#define BOOST_PP_INC_130 131
#define BOOST_PP_INC_131 132
#define BOOST_PP_INC_132 133
#define BOOST_PP_INC_133 134
#define BOOST_PP_INC_134 135
#define BOOST_PP_INC_135 136
#define BOOST_PP_INC_136 137
#define BOOST_PP_INC_137 138
#define BOOST_PP_INC_138 139
#define BOOST_PP_INC_139 140
#define BOOST_PP_INC_140 141
#define BOOST_PP_INC_141 142
#define BOOST_PP_INC_142 143
#define BOOST_PP_INC_143 144
#define BOOST_PP_INC_144 145
#define BOOST_PP_INC_145 146
#define BOOST_PP_INC_146 147
#define BOOST_PP_INC_147 148
#define BOOST_PP_INC_148 149
#define BOOST_PP_INC_149 150
#define BOOST_PP_INC_150 151
#define BOOST_PP_INC_151 152
#define BOOST_PP_INC_152 153
#define BOOST_PP_INC_153 154
#define BOOST_PP_INC_154 155
#define BOOST_PP_INC_155 156
#define BOOST_PP_INC_156 157
#define BOOST_PP_INC_157 158
#define BOOST_PP_INC_158 159
#define BOOST_PP_INC_159 160
#define BOOST_PP_INC_160 161
#define BOOST_PP_INC_161 162
#define BOOST_PP_INC_162 163
#define BOOST_PP_INC_163 164
#define BOOST_PP_INC_164 165
#define BOOST_PP_INC_165 166
#define BOOST_PP_INC_166 167
#define BOOST_PP_INC_167 168
#define BOOST_PP_INC_168 169
#define BOOST_PP_INC_169 170
#define BOOST_PP_INC_170 171
#define BOOST_PP_INC_171 172
#define BOOST_PP_INC_172 173
#define BOOST_PP_INC_173 174
#define BOOST_PP_INC_174 175
#define BOOST_PP_INC_175 176
#define BOOST_PP_INC_176 177
#define BOOST_PP_INC_177 178
#define BOOST_PP_INC_178 179
#define BOOST_PP_INC_179 180
#define BOOST_PP_INC_180 181
#define BOOST_PP_INC_181 182
#define BOOST_PP_INC_182 183
#define BOOST_PP_INC_183 184
#define BOOST_PP_INC_184 185
#define BOOST_PP_INC_185 186
#define BOOST_PP_INC_186 187
#define BOOST_PP_INC_187 188
#define BOOST_PP_INC_188 189
#define BOOST_PP_INC_189 190
#define BOOST_PP_INC_190 191
#define BOOST_PP_INC_191 192
#define BOOST_PP_INC_192 193
#define BOOST_PP_INC_193 194
#define BOOST_PP_INC_194 195
#define BOOST_PP_INC_195 196
#define BOOST_PP_INC_196 197
#define BOOST_PP_INC_197 198
#define BOOST_PP_INC_198 199
#define BOOST_PP_INC_199 200
#define BOOST_PP_INC_200 201
#define BOOST_PP_INC_201 202
#define BOOST_PP_INC_202 203
#define BOOST_PP_INC_203 204
#define BOOST_PP_INC_204 205
#define BOOST_PP_INC_205 206
#define BOOST_PP_INC_206 207
#define BOOST_PP_INC_207 208
#define BOOST_PP_INC_208 209
#define BOOST_PP_INC_209 210
#define BOOST_PP_INC_210 211
#define BOOST_PP_INC_211 212
#define BOOST_PP_INC_212 213
#define BOOST_PP_INC_213 214
#define BOOST_PP_INC_214 215
#define BOOST_PP_INC_215 216
#define BOOST_PP_INC_216 217
#define BOOST_PP_INC_217 218
#define BOOST_PP_INC_218 219
#define BOOST_PP_INC_219 220
#define BOOST_PP_INC_220 221
#define BOOST_PP_INC_221 222
#define BOOST_PP_INC_222 223
#define BOOST_PP_INC_223 224
#define BOOST_PP_INC_224 225
#define BOOST_PP_INC_225 226
#define BOOST_PP_INC_226 227
#define BOOST_PP_INC_227 228
#define BOOST_PP_INC_228 229
#define BOOST_PP_INC_229 230
#define BOOST_PP_INC_230 231
#define BOOST_PP_INC_231 232
#define BOOST_PP_INC_232 233
#define BOOST_PP_INC_233 234
#define BOOST_PP_INC_234 235
#define BOOST_PP_INC_235 236
#define BOOST_PP_INC_236 237
#define BOOST_PP_INC_237 238
#define BOOST_PP_INC_238 239
#define BOOST_PP_INC_239 240
#define BOOST_PP_INC_240 241
#define BOOST_PP_INC_241 242
#define BOOST_PP_INC_242 243
#define BOOST_PP_INC_243 244
#define BOOST_PP_INC_244 245
#define BOOST_PP_INC_245 246
#define BOOST_PP_INC_246 247
#define BOOST_PP_INC_247 248
#define BOOST_PP_INC_248 249
#define BOOST_PP_INC_249 250
#define BOOST_PP_INC_250 251
#define BOOST_PP_INC_251 252
#define BOOST_PP_INC_252 253
#define BOOST_PP_INC_253 254
#define BOOST_PP_INC_254 255
#define BOOST_PP_INC_255 256
#define BOOST_PP_INC_256 256
#define BOOST_MPL_PP_AUX_PARAM_FUNC(unused,i,param) BOOST_PP_COMMA_IF(i) BOOST_PP_CAT(param, BOOST_PP_INC(i))
#define BOOST_MPL_PP_PARAMS(n,param) BOOST_PP_REPEAT( n , BOOST_MPL_PP_AUX_PARAM_FUNC , param )
#define BOOST_MPL_AUX_PREPROCESSOR_ENUM_HPP_INCLUDED
#define BOOST_MPL_PP_AUX_ENUM_FUNC(unused,i,param) BOOST_PP_COMMA_IF(i) param
#define BOOST_MPL_PP_ENUM(n,param) BOOST_PP_REPEAT( n , BOOST_MPL_PP_AUX_ENUM_FUNC , param )
#define BOOST_MPL_AUX_PREPROCESSOR_DEF_PARAMS_TAIL_HPP_INCLUDED
#define BOOST_MPL_LIMITS_ARITY_HPP_INCLUDED
#define BOOST_MPL_LIMIT_METAFUNCTION_ARITY 5
#define BOOST_PREPROCESSOR_LOGICAL_AND_HPP
#define BOOST_PREPROCESSOR_LOGICAL_BITAND_HPP
#define BOOST_PP_BITAND(x,y) BOOST_PP_BITAND_I(x, y)
#define BOOST_PP_BITAND_I(x,y) BOOST_PP_BITAND_ ## x ## y
#define BOOST_PP_BITAND_00 0
#define BOOST_PP_BITAND_01 0
#define BOOST_PP_BITAND_10 0
#define BOOST_PP_BITAND_11 1
#define BOOST_PP_AND(p,q) BOOST_PP_BITAND(BOOST_PP_BOOL(p), BOOST_PP_BOOL(q))
#define BOOST_PREPROCESSOR_IDENTITY_HPP
#define BOOST_PREPROCESSOR_FACILITIES_IDENTITY_HPP
#define BOOST_PP_IDENTITY(item) item BOOST_PP_EMPTY
#define BOOST_PREPROCESSOR_EMPTY_HPP
#define BOOST_PREPROCESSOR_ARITHMETIC_ADD_HPP
#define BOOST_PREPROCESSOR_ARITHMETIC_DEC_HPP
#define BOOST_PP_DEC(x) BOOST_PP_DEC_I(x)
#define BOOST_PP_DEC_I(x) BOOST_PP_DEC_ ## x
#define BOOST_PP_DEC_0 0
#define BOOST_PP_DEC_1 0
#define BOOST_PP_DEC_2 1
#define BOOST_PP_DEC_3 2
#define BOOST_PP_DEC_4 3
#define BOOST_PP_DEC_5 4
#define BOOST_PP_DEC_6 5
#define BOOST_PP_DEC_7 6
#define BOOST_PP_DEC_8 7
#define BOOST_PP_DEC_9 8
#define BOOST_PP_DEC_10 9
#define BOOST_PP_DEC_11 10
#define BOOST_PP_DEC_12 11
#define BOOST_PP_DEC_13 12
#define BOOST_PP_DEC_14 13
#define BOOST_PP_DEC_15 14
#define BOOST_PP_DEC_16 15
#define BOOST_PP_DEC_17 16
#define BOOST_PP_DEC_18 17
#define BOOST_PP_DEC_19 18
#define BOOST_PP_DEC_20 19
#define BOOST_PP_DEC_21 20
#define BOOST_PP_DEC_22 21
#define BOOST_PP_DEC_23 22
#define BOOST_PP_DEC_24 23
#define BOOST_PP_DEC_25 24
#define BOOST_PP_DEC_26 25
#define BOOST_PP_DEC_27 26
#define BOOST_PP_DEC_28 27
#define BOOST_PP_DEC_29 28
#define BOOST_PP_DEC_30 29
#define BOOST_PP_DEC_31 30
#define BOOST_PP_DEC_32 31
#define BOOST_PP_DEC_33 32
#define BOOST_PP_DEC_34 33
#define BOOST_PP_DEC_35 34
#define BOOST_PP_DEC_36 35
#define BOOST_PP_DEC_37 36
#define BOOST_PP_DEC_38 37
#define BOOST_PP_DEC_39 38
#define BOOST_PP_DEC_40 39
#define BOOST_PP_DEC_41 40
#define BOOST_PP_DEC_42 41
#define BOOST_PP_DEC_43 42
#define BOOST_PP_DEC_44 43
#define BOOST_PP_DEC_45 44
#define BOOST_PP_DEC_46 45
#define BOOST_PP_DEC_47 46
#define BOOST_PP_DEC_48 47
#define BOOST_PP_DEC_49 48
#define BOOST_PP_DEC_50 49
#define BOOST_PP_DEC_51 50
#define BOOST_PP_DEC_52 51
#define BOOST_PP_DEC_53 52
#define BOOST_PP_DEC_54 53
#define BOOST_PP_DEC_55 54
#define BOOST_PP_DEC_56 55
#define BOOST_PP_DEC_57 56
#define BOOST_PP_DEC_58 57
#define BOOST_PP_DEC_59 58
#define BOOST_PP_DEC_60 59
#define BOOST_PP_DEC_61 60
#define BOOST_PP_DEC_62 61
#define BOOST_PP_DEC_63 62
#define BOOST_PP_DEC_64 63
#define BOOST_PP_DEC_65 64
#define BOOST_PP_DEC_66 65
#define BOOST_PP_DEC_67 66
#define BOOST_PP_DEC_68 67
#define BOOST_PP_DEC_69 68
#define BOOST_PP_DEC_70 69
#define BOOST_PP_DEC_71 70
#define BOOST_PP_DEC_72 71
#define BOOST_PP_DEC_73 72
#define BOOST_PP_DEC_74 73
#define BOOST_PP_DEC_75 74
#define BOOST_PP_DEC_76 75
#define BOOST_PP_DEC_77 76
#define BOOST_PP_DEC_78 77
#define BOOST_PP_DEC_79 78
#define BOOST_PP_DEC_80 79
#define BOOST_PP_DEC_81 80
#define BOOST_PP_DEC_82 81
#define BOOST_PP_DEC_83 82
#define BOOST_PP_DEC_84 83
#define BOOST_PP_DEC_85 84
#define BOOST_PP_DEC_86 85
#define BOOST_PP_DEC_87 86
#define BOOST_PP_DEC_88 87
#define BOOST_PP_DEC_89 88
#define BOOST_PP_DEC_90 89
#define BOOST_PP_DEC_91 90
#define BOOST_PP_DEC_92 91
#define BOOST_PP_DEC_93 92
#define BOOST_PP_DEC_94 93
#define BOOST_PP_DEC_95 94
#define BOOST_PP_DEC_96 95
#define BOOST_PP_DEC_97 96
#define BOOST_PP_DEC_98 97
#define BOOST_PP_DEC_99 98
#define BOOST_PP_DEC_100 99
#define BOOST_PP_DEC_101 100
#define BOOST_PP_DEC_102 101
#define BOOST_PP_DEC_103 102
#define BOOST_PP_DEC_104 103
#define BOOST_PP_DEC_105 104
#define BOOST_PP_DEC_106 105
#define BOOST_PP_DEC_107 106
#define BOOST_PP_DEC_108 107
#define BOOST_PP_DEC_109 108
#define BOOST_PP_DEC_110 109
#define BOOST_PP_DEC_111 110
#define BOOST_PP_DEC_112 111
#define BOOST_PP_DEC_113 112
#define BOOST_PP_DEC_114 113
#define BOOST_PP_DEC_115 114
#define BOOST_PP_DEC_116 115
#define BOOST_PP_DEC_117 116
#define BOOST_PP_DEC_118 117
#define BOOST_PP_DEC_119 118
#define BOOST_PP_DEC_120 119
#define BOOST_PP_DEC_121 120
#define BOOST_PP_DEC_122 121
#define BOOST_PP_DEC_123 122
#define BOOST_PP_DEC_124 123
#define BOOST_PP_DEC_125 124
#define BOOST_PP_DEC_126 125
#define BOOST_PP_DEC_127 126
#define BOOST_PP_DEC_128 127
#define BOOST_PP_DEC_129 128
#define BOOST_PP_DEC_130 129
#define BOOST_PP_DEC_131 130
#define BOOST_PP_DEC_132 131
#define BOOST_PP_DEC_133 132
#define BOOST_PP_DEC_134 133
#define BOOST_PP_DEC_135 134
#define BOOST_PP_DEC_136 135
#define BOOST_PP_DEC_137 136
#define BOOST_PP_DEC_138 137
#define BOOST_PP_DEC_139 138
#define BOOST_PP_DEC_140 139
#define BOOST_PP_DEC_141 140
#define BOOST_PP_DEC_142 141
#define BOOST_PP_DEC_143 142
#define BOOST_PP_DEC_144 143
#define BOOST_PP_DEC_145 144
#define BOOST_PP_DEC_146 145
#define BOOST_PP_DEC_147 146
#define BOOST_PP_DEC_148 147
#define BOOST_PP_DEC_149 148
#define BOOST_PP_DEC_150 149
#define BOOST_PP_DEC_151 150
#define BOOST_PP_DEC_152 151
#define BOOST_PP_DEC_153 152
#define BOOST_PP_DEC_154 153
#define BOOST_PP_DEC_155 154
#define BOOST_PP_DEC_156 155
#define BOOST_PP_DEC_157 156
#define BOOST_PP_DEC_158 157
#define BOOST_PP_DEC_159 158
#define BOOST_PP_DEC_160 159
#define BOOST_PP_DEC_161 160
#define BOOST_PP_DEC_162 161
#define BOOST_PP_DEC_163 162
#define BOOST_PP_DEC_164 163
#define BOOST_PP_DEC_165 164
#define BOOST_PP_DEC_166 165
#define BOOST_PP_DEC_167 166
#define BOOST_PP_DEC_168 167
#define BOOST_PP_DEC_169 168
#define BOOST_PP_DEC_170 169
#define BOOST_PP_DEC_171 170
#define BOOST_PP_DEC_172 171
#define BOOST_PP_DEC_173 172
#define BOOST_PP_DEC_174 173
#define BOOST_PP_DEC_175 174
#define BOOST_PP_DEC_176 175
#define BOOST_PP_DEC_177 176
#define BOOST_PP_DEC_178 177
#define BOOST_PP_DEC_179 178
#define BOOST_PP_DEC_180 179
#define BOOST_PP_DEC_181 180
#define BOOST_PP_DEC_182 181
#define BOOST_PP_DEC_183 182
#define BOOST_PP_DEC_184 183
#define BOOST_PP_DEC_185 184
#define BOOST_PP_DEC_186 185
#define BOOST_PP_DEC_187 186
#define BOOST_PP_DEC_188 187
#define BOOST_PP_DEC_189 188
#define BOOST_PP_DEC_190 189
#define BOOST_PP_DEC_191 190
#define BOOST_PP_DEC_192 191
#define BOOST_PP_DEC_193 192
#define BOOST_PP_DEC_194 193
#define BOOST_PP_DEC_195 194
#define BOOST_PP_DEC_196 195
#define BOOST_PP_DEC_197 196
#define BOOST_PP_DEC_198 197
#define BOOST_PP_DEC_199 198
#define BOOST_PP_DEC_200 199
#define BOOST_PP_DEC_201 200
#define BOOST_PP_DEC_202 201
#define BOOST_PP_DEC_203 202
#define BOOST_PP_DEC_204 203
#define BOOST_PP_DEC_205 204
#define BOOST_PP_DEC_206 205
#define BOOST_PP_DEC_207 206
#define BOOST_PP_DEC_208 207
#define BOOST_PP_DEC_209 208
#define BOOST_PP_DEC_210 209
#define BOOST_PP_DEC_211 210
#define BOOST_PP_DEC_212 211
#define BOOST_PP_DEC_213 212
#define BOOST_PP_DEC_214 213
#define BOOST_PP_DEC_215 214
#define BOOST_PP_DEC_216 215
#define BOOST_PP_DEC_217 216
#define BOOST_PP_DEC_218 217
#define BOOST_PP_DEC_219 218
#define BOOST_PP_DEC_220 219
#define BOOST_PP_DEC_221 220
#define BOOST_PP_DEC_222 221
#define BOOST_PP_DEC_223 222
#define BOOST_PP_DEC_224 223
#define BOOST_PP_DEC_225 224
#define BOOST_PP_DEC_226 225
#define BOOST_PP_DEC_227 226
#define BOOST_PP_DEC_228 227
#define BOOST_PP_DEC_229 228
#define BOOST_PP_DEC_230 229
#define BOOST_PP_DEC_231 230
#define BOOST_PP_DEC_232 231
#define BOOST_PP_DEC_233 232
#define BOOST_PP_DEC_234 233
#define BOOST_PP_DEC_235 234
#define BOOST_PP_DEC_236 235
#define BOOST_PP_DEC_237 236
#define BOOST_PP_DEC_238 237
#define BOOST_PP_DEC_239 238
#define BOOST_PP_DEC_240 239
#define BOOST_PP_DEC_241 240
#define BOOST_PP_DEC_242 241
#define BOOST_PP_DEC_243 242
#define BOOST_PP_DEC_244 243
#define BOOST_PP_DEC_245 244
#define BOOST_PP_DEC_246 245
#define BOOST_PP_DEC_247 246
#define BOOST_PP_DEC_248 247
#define BOOST_PP_DEC_249 248
#define BOOST_PP_DEC_250 249
#define BOOST_PP_DEC_251 250
#define BOOST_PP_DEC_252 251
#define BOOST_PP_DEC_253 252
#define BOOST_PP_DEC_254 253
#define BOOST_PP_DEC_255 254
#define BOOST_PP_DEC_256 255
#define BOOST_PREPROCESSOR_CONTROL_WHILE_HPP
#define BOOST_PREPROCESSOR_LIST_FOLD_LEFT_HPP
#define BOOST_PP_LIST_FOLD_LEFT BOOST_PP_CAT(BOOST_PP_LIST_FOLD_LEFT_, BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256))
#define BOOST_PP_LIST_FOLD_LEFT_257(o,s,l) BOOST_PP_ERROR(0x0004)
#define BOOST_PP_LIST_FOLD_LEFT_D(d,o,s,l) BOOST_PP_LIST_FOLD_LEFT_ ## d(o, s, l)
#define BOOST_PP_LIST_FOLD_LEFT_2ND BOOST_PP_LIST_FOLD_LEFT
#define BOOST_PP_LIST_FOLD_LEFT_2ND_D BOOST_PP_LIST_FOLD_LEFT_D
#define BOOST_PREPROCESSOR_LIST_DETAIL_FOLD_LEFT_HPP
#define BOOST_PREPROCESSOR_CONTROL_EXPR_IIF_HPP
#define BOOST_PP_EXPR_IIF(bit,expr) BOOST_PP_EXPR_IIF_I(bit, expr)
#define BOOST_PP_EXPR_IIF_I(bit,expr) BOOST_PP_EXPR_IIF_ ## bit(expr)
#define BOOST_PP_EXPR_IIF_0(expr)
#define BOOST_PP_EXPR_IIF_1(expr) expr
#define BOOST_PREPROCESSOR_LIST_ADT_HPP
#define BOOST_PREPROCESSOR_DETAIL_IS_BINARY_HPP
#define BOOST_PREPROCESSOR_DETAIL_CHECK_HPP
#define BOOST_PP_CHECK(x,type) BOOST_PP_CHECK_D(x, type)
#define BOOST_PP_CHECK_D(x,type) BOOST_PP_CHECK_1(BOOST_PP_CAT(BOOST_PP_CHECK_RESULT_, type x))
#define BOOST_PP_CHECK_1(chk) BOOST_PP_CHECK_2(chk)
#define BOOST_PP_CHECK_2(res,_) res
#define BOOST_PP_CHECK_RESULT_1 1, BOOST_PP_NIL
#define BOOST_PP_IS_BINARY(x) BOOST_PP_CHECK(x, BOOST_PP_IS_BINARY_CHECK)
#define BOOST_PP_IS_BINARY_CHECK(a,b) 1
#define BOOST_PP_CHECK_RESULT_BOOST_PP_IS_BINARY_CHECK 0, BOOST_PP_NIL
#define BOOST_PREPROCESSOR_LOGICAL_COMPL_HPP
#define BOOST_PP_COMPL(x) BOOST_PP_COMPL_I(x)
#define BOOST_PP_COMPL_I(x) BOOST_PP_COMPL_ ## x
#define BOOST_PP_COMPL_0 1
#define BOOST_PP_COMPL_1 0
#define BOOST_PP_LIST_CONS(head,tail) (head, tail)
#define BOOST_PP_LIST_NIL BOOST_PP_NIL
#define BOOST_PP_LIST_FIRST(list) BOOST_PP_LIST_FIRST_D(list)
#define BOOST_PP_LIST_FIRST_D(list) BOOST_PP_LIST_FIRST_I list
#define BOOST_PP_LIST_FIRST_I(head,tail) head
#define BOOST_PP_LIST_REST(list) BOOST_PP_LIST_REST_D(list)
#define BOOST_PP_LIST_REST_D(list) BOOST_PP_LIST_REST_I list
#define BOOST_PP_LIST_REST_I(head,tail) tail
#define BOOST_PP_LIST_IS_CONS(list) BOOST_PP_IS_BINARY(list)
#define BOOST_PP_LIST_IS_NIL(list) BOOST_PP_COMPL(BOOST_PP_IS_BINARY(list))
#define BOOST_PP_LIST_FOLD_LEFT_1(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_2, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(2, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_2(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_3, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(3, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_3(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_4, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(4, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_4(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_5, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(5, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_5(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_6, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(6, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_6(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_7, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(7, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_7(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_8, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(8, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_8(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_9, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(9, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_9(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_10, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(10, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_10(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_11, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(11, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_11(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_12, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(12, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_12(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_13, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(13, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_13(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_14, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(14, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_14(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_15, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(15, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_15(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_16, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(16, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_16(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_17, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(17, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_17(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_18, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(18, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_18(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_19, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(19, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_19(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_20, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(20, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_20(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_21, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(21, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_21(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_22, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(22, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_22(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_23, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(23, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_23(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_24, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(24, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_24(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_25, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(25, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_25(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_26, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(26, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_26(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_27, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(27, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_27(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_28, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(28, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_28(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_29, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(29, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_29(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_30, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(30, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_30(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_31, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(31, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_31(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_32, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(32, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_32(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_33, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(33, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_33(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_34, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(34, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_34(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_35, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(35, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_35(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_36, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(36, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_36(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_37, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(37, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_37(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_38, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(38, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_38(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_39, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(39, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_39(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_40, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(40, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_40(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_41, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(41, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_41(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_42, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(42, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_42(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_43, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(43, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_43(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_44, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(44, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_44(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_45, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(45, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_45(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_46, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(46, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_46(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_47, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(47, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_47(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_48, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(48, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_48(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_49, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(49, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_49(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_50, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(50, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_50(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_51, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(51, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_51(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_52, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(52, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_52(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_53, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(53, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_53(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_54, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(54, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_54(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_55, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(55, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_55(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_56, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(56, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_56(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_57, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(57, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_57(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_58, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(58, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_58(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_59, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(59, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_59(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_60, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(60, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_60(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_61, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(61, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_61(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_62, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(62, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_62(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_63, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(63, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_63(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_64, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(64, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_64(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_65, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(65, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_65(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_66, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(66, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_66(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_67, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(67, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_67(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_68, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(68, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_68(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_69, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(69, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_69(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_70, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(70, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_70(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_71, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(71, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_71(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_72, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(72, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_72(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_73, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(73, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_73(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_74, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(74, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_74(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_75, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(75, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_75(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_76, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(76, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_76(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_77, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(77, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_77(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_78, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(78, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_78(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_79, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(79, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_79(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_80, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(80, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_80(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_81, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(81, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_81(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_82, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(82, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_82(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_83, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(83, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_83(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_84, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(84, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_84(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_85, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(85, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_85(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_86, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(86, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_86(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_87, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(87, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_87(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_88, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(88, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_88(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_89, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(89, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_89(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_90, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(90, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_90(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_91, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(91, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_91(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_92, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(92, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_92(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_93, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(93, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_93(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_94, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(94, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_94(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_95, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(95, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_95(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_96, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(96, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_96(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_97, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(97, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_97(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_98, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(98, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_98(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_99, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(99, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_99(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_100, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(100, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_100(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_101, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(101, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_101(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_102, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(102, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_102(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_103, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(103, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_103(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_104, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(104, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_104(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_105, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(105, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_105(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_106, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(106, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_106(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_107, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(107, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_107(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_108, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(108, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_108(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_109, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(109, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_109(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_110, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(110, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_110(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_111, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(111, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_111(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_112, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(112, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_112(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_113, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(113, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_113(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_114, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(114, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_114(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_115, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(115, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_115(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_116, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(116, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_116(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_117, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(117, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_117(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_118, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(118, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_118(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_119, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(119, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_119(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_120, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(120, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_120(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_121, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(121, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_121(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_122, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(122, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_122(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_123, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(123, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_123(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_124, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(124, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_124(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_125, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(125, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_125(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_126, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(126, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_126(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_127, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(127, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_127(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_128, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(128, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_128(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_129, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(129, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_129(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_130, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(130, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_130(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_131, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(131, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_131(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_132, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(132, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_132(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_133, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(133, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_133(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_134, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(134, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_134(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_135, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(135, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_135(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_136, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(136, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_136(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_137, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(137, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_137(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_138, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(138, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_138(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_139, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(139, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_139(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_140, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(140, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_140(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_141, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(141, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_141(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_142, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(142, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_142(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_143, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(143, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_143(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_144, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(144, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_144(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_145, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(145, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_145(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_146, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(146, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_146(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_147, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(147, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_147(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_148, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(148, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_148(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_149, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(149, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_149(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_150, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(150, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_150(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_151, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(151, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_151(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_152, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(152, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_152(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_153, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(153, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_153(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_154, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(154, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_154(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_155, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(155, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_155(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_156, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(156, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_156(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_157, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(157, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_157(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_158, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(158, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_158(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_159, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(159, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_159(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_160, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(160, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_160(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_161, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(161, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_161(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_162, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(162, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_162(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_163, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(163, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_163(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_164, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(164, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_164(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_165, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(165, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_165(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_166, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(166, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_166(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_167, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(167, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_167(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_168, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(168, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_168(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_169, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(169, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_169(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_170, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(170, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_170(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_171, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(171, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_171(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_172, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(172, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_172(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_173, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(173, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_173(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_174, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(174, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_174(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_175, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(175, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_175(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_176, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(176, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_176(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_177, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(177, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_177(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_178, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(178, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_178(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_179, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(179, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_179(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_180, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(180, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_180(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_181, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(181, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_181(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_182, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(182, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_182(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_183, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(183, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_183(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_184, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(184, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_184(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_185, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(185, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_185(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_186, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(186, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_186(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_187, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(187, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_187(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_188, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(188, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_188(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_189, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(189, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_189(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_190, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(190, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_190(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_191, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(191, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_191(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_192, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(192, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_192(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_193, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(193, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_193(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_194, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(194, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_194(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_195, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(195, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_195(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_196, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(196, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_196(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_197, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(197, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_197(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_198, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(198, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_198(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_199, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(199, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_199(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_200, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(200, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_200(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_201, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(201, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_201(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_202, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(202, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_202(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_203, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(203, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_203(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_204, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(204, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_204(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_205, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(205, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_205(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_206, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(206, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_206(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_207, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(207, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_207(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_208, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(208, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_208(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_209, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(209, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_209(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_210, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(210, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_210(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_211, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(211, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_211(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_212, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(212, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_212(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_213, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(213, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_213(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_214, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(214, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_214(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_215, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(215, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_215(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_216, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(216, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_216(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_217, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(217, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_217(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_218, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(218, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_218(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_219, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(219, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_219(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_220, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(220, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_220(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_221, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(221, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_221(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_222, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(222, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_222(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_223, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(223, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_223(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_224, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(224, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_224(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_225, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(225, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_225(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_226, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(226, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_226(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_227, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(227, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_227(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_228, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(228, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_228(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_229, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(229, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_229(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_230, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(230, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_230(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_231, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(231, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_231(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_232, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(232, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_232(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_233, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(233, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_233(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_234, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(234, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_234(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_235, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(235, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_235(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_236, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(236, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_236(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_237, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(237, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_237(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_238, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(238, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_238(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_239, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(239, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_239(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_240, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(240, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_240(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_241, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(241, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_241(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_242, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(242, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_242(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_243, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(243, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_243(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_244, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(244, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_244(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_245, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(245, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_245(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_246, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(246, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_246(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_247, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(247, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_247(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_248, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(248, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_248(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_249, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(249, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_249(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_250, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(250, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_250(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_251, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(251, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_251(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_252, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(252, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_252(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_253, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(253, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_253(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_254, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(254, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_254(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_255, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(255, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_255(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_256, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(256, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_256(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_257, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(257, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_NIL 1
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_1(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_2(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_3(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_4(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_5(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_6(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_7(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_8(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_9(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_10(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_11(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_12(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_13(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_14(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_15(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_16(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_17(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_18(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_19(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_20(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_21(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_22(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_23(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_24(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_25(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_26(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_27(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_28(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_29(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_30(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_31(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_32(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_33(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_34(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_35(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_36(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_37(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_38(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_39(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_40(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_41(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_42(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_43(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_44(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_45(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_46(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_47(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_48(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_49(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_50(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_51(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_52(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_53(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_54(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_55(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_56(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_57(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_58(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_59(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_60(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_61(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_62(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_63(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_64(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_65(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_66(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_67(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_68(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_69(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_70(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_71(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_72(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_73(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_74(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_75(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_76(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_77(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_78(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_79(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_80(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_81(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_82(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_83(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_84(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_85(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_86(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_87(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_88(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_89(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_90(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_91(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_92(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_93(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_94(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_95(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_96(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_97(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_98(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_99(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_100(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_101(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_102(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_103(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_104(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_105(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_106(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_107(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_108(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_109(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_110(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_111(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_112(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_113(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_114(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_115(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_116(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_117(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_118(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_119(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_120(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_121(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_122(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_123(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_124(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_125(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_126(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_127(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_128(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_129(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_130(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_131(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_132(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_133(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_134(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_135(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_136(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_137(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_138(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_139(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_140(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_141(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_142(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_143(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_144(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_145(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_146(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_147(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_148(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_149(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_150(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_151(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_152(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_153(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_154(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_155(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_156(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_157(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_158(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_159(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_160(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_161(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_162(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_163(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_164(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_165(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_166(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_167(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_168(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_169(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_170(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_171(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_172(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_173(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_174(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_175(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_176(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_177(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_178(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_179(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_180(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_181(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_182(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_183(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_184(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_185(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_186(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_187(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_188(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_189(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_190(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_191(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_192(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_193(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_194(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_195(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_196(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_197(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_198(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_199(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_200(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_201(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_202(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_203(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_204(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_205(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_206(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_207(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_208(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_209(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_210(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_211(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_212(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_213(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_214(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_215(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_216(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_217(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_218(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_219(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_220(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_221(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_222(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_223(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_224(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_225(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_226(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_227(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_228(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_229(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_230(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_231(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_232(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_233(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_234(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_235(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_236(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_237(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_238(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_239(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_240(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_241(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_242(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_243(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_244(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_245(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_246(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_247(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_248(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_249(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_250(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_251(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_252(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_253(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_254(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_255(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_256(o,s,l) 0
#define BOOST_PREPROCESSOR_LIST_FOLD_RIGHT_HPP
#define BOOST_PP_LIST_FOLD_RIGHT BOOST_PP_CAT(BOOST_PP_LIST_FOLD_RIGHT_, BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256))
#define BOOST_PP_LIST_FOLD_RIGHT_257(o,s,l) BOOST_PP_ERROR(0x0004)
#define BOOST_PP_LIST_FOLD_RIGHT_D(d,o,s,l) BOOST_PP_LIST_FOLD_RIGHT_ ## d(o, s, l)
#define BOOST_PP_LIST_FOLD_RIGHT_2ND BOOST_PP_LIST_FOLD_RIGHT
#define BOOST_PP_LIST_FOLD_RIGHT_2ND_D BOOST_PP_LIST_FOLD_RIGHT_D
#define BOOST_PREPROCESSOR_LIST_DETAIL_FOLD_RIGHT_HPP
#define BOOST_PREPROCESSOR_LIST_REVERSE_HPP
#define BOOST_PP_LIST_REVERSE(list) BOOST_PP_LIST_FOLD_LEFT(BOOST_PP_LIST_REVERSE_O, BOOST_PP_NIL, list)
#define BOOST_PP_LIST_REVERSE_O(d,s,x) (x, s)
#define BOOST_PP_LIST_REVERSE_D(d,list) BOOST_PP_LIST_FOLD_LEFT_ ## d(BOOST_PP_LIST_REVERSE_O, BOOST_PP_NIL, list)
#define BOOST_PP_LIST_FOLD_RIGHT_1(o,s,l) BOOST_PP_LIST_FOLD_LEFT_1(o, s, BOOST_PP_LIST_REVERSE_D(1, l))
#define BOOST_PP_LIST_FOLD_RIGHT_2(o,s,l) BOOST_PP_LIST_FOLD_LEFT_2(o, s, BOOST_PP_LIST_REVERSE_D(2, l))
#define BOOST_PP_LIST_FOLD_RIGHT_3(o,s,l) BOOST_PP_LIST_FOLD_LEFT_3(o, s, BOOST_PP_LIST_REVERSE_D(3, l))
#define BOOST_PP_LIST_FOLD_RIGHT_4(o,s,l) BOOST_PP_LIST_FOLD_LEFT_4(o, s, BOOST_PP_LIST_REVERSE_D(4, l))
#define BOOST_PP_LIST_FOLD_RIGHT_5(o,s,l) BOOST_PP_LIST_FOLD_LEFT_5(o, s, BOOST_PP_LIST_REVERSE_D(5, l))
#define BOOST_PP_LIST_FOLD_RIGHT_6(o,s,l) BOOST_PP_LIST_FOLD_LEFT_6(o, s, BOOST_PP_LIST_REVERSE_D(6, l))
#define BOOST_PP_LIST_FOLD_RIGHT_7(o,s,l) BOOST_PP_LIST_FOLD_LEFT_7(o, s, BOOST_PP_LIST_REVERSE_D(7, l))
#define BOOST_PP_LIST_FOLD_RIGHT_8(o,s,l) BOOST_PP_LIST_FOLD_LEFT_8(o, s, BOOST_PP_LIST_REVERSE_D(8, l))
#define BOOST_PP_LIST_FOLD_RIGHT_9(o,s,l) BOOST_PP_LIST_FOLD_LEFT_9(o, s, BOOST_PP_LIST_REVERSE_D(9, l))
#define BOOST_PP_LIST_FOLD_RIGHT_10(o,s,l) BOOST_PP_LIST_FOLD_LEFT_10(o, s, BOOST_PP_LIST_REVERSE_D(10, l))
#define BOOST_PP_LIST_FOLD_RIGHT_11(o,s,l) BOOST_PP_LIST_FOLD_LEFT_11(o, s, BOOST_PP_LIST_REVERSE_D(11, l))
#define BOOST_PP_LIST_FOLD_RIGHT_12(o,s,l) BOOST_PP_LIST_FOLD_LEFT_12(o, s, BOOST_PP_LIST_REVERSE_D(12, l))
#define BOOST_PP_LIST_FOLD_RIGHT_13(o,s,l) BOOST_PP_LIST_FOLD_LEFT_13(o, s, BOOST_PP_LIST_REVERSE_D(13, l))
#define BOOST_PP_LIST_FOLD_RIGHT_14(o,s,l) BOOST_PP_LIST_FOLD_LEFT_14(o, s, BOOST_PP_LIST_REVERSE_D(14, l))
#define BOOST_PP_LIST_FOLD_RIGHT_15(o,s,l) BOOST_PP_LIST_FOLD_LEFT_15(o, s, BOOST_PP_LIST_REVERSE_D(15, l))
#define BOOST_PP_LIST_FOLD_RIGHT_16(o,s,l) BOOST_PP_LIST_FOLD_LEFT_16(o, s, BOOST_PP_LIST_REVERSE_D(16, l))
#define BOOST_PP_LIST_FOLD_RIGHT_17(o,s,l) BOOST_PP_LIST_FOLD_LEFT_17(o, s, BOOST_PP_LIST_REVERSE_D(17, l))
#define BOOST_PP_LIST_FOLD_RIGHT_18(o,s,l) BOOST_PP_LIST_FOLD_LEFT_18(o, s, BOOST_PP_LIST_REVERSE_D(18, l))
#define BOOST_PP_LIST_FOLD_RIGHT_19(o,s,l) BOOST_PP_LIST_FOLD_LEFT_19(o, s, BOOST_PP_LIST_REVERSE_D(19, l))
#define BOOST_PP_LIST_FOLD_RIGHT_20(o,s,l) BOOST_PP_LIST_FOLD_LEFT_20(o, s, BOOST_PP_LIST_REVERSE_D(20, l))
#define BOOST_PP_LIST_FOLD_RIGHT_21(o,s,l) BOOST_PP_LIST_FOLD_LEFT_21(o, s, BOOST_PP_LIST_REVERSE_D(21, l))
#define BOOST_PP_LIST_FOLD_RIGHT_22(o,s,l) BOOST_PP_LIST_FOLD_LEFT_22(o, s, BOOST_PP_LIST_REVERSE_D(22, l))
#define BOOST_PP_LIST_FOLD_RIGHT_23(o,s,l) BOOST_PP_LIST_FOLD_LEFT_23(o, s, BOOST_PP_LIST_REVERSE_D(23, l))
#define BOOST_PP_LIST_FOLD_RIGHT_24(o,s,l) BOOST_PP_LIST_FOLD_LEFT_24(o, s, BOOST_PP_LIST_REVERSE_D(24, l))
#define BOOST_PP_LIST_FOLD_RIGHT_25(o,s,l) BOOST_PP_LIST_FOLD_LEFT_25(o, s, BOOST_PP_LIST_REVERSE_D(25, l))
#define BOOST_PP_LIST_FOLD_RIGHT_26(o,s,l) BOOST_PP_LIST_FOLD_LEFT_26(o, s, BOOST_PP_LIST_REVERSE_D(26, l))
#define BOOST_PP_LIST_FOLD_RIGHT_27(o,s,l) BOOST_PP_LIST_FOLD_LEFT_27(o, s, BOOST_PP_LIST_REVERSE_D(27, l))
#define BOOST_PP_LIST_FOLD_RIGHT_28(o,s,l) BOOST_PP_LIST_FOLD_LEFT_28(o, s, BOOST_PP_LIST_REVERSE_D(28, l))
#define BOOST_PP_LIST_FOLD_RIGHT_29(o,s,l) BOOST_PP_LIST_FOLD_LEFT_29(o, s, BOOST_PP_LIST_REVERSE_D(29, l))
#define BOOST_PP_LIST_FOLD_RIGHT_30(o,s,l) BOOST_PP_LIST_FOLD_LEFT_30(o, s, BOOST_PP_LIST_REVERSE_D(30, l))
#define BOOST_PP_LIST_FOLD_RIGHT_31(o,s,l) BOOST_PP_LIST_FOLD_LEFT_31(o, s, BOOST_PP_LIST_REVERSE_D(31, l))
#define BOOST_PP_LIST_FOLD_RIGHT_32(o,s,l) BOOST_PP_LIST_FOLD_LEFT_32(o, s, BOOST_PP_LIST_REVERSE_D(32, l))
#define BOOST_PP_LIST_FOLD_RIGHT_33(o,s,l) BOOST_PP_LIST_FOLD_LEFT_33(o, s, BOOST_PP_LIST_REVERSE_D(33, l))
#define BOOST_PP_LIST_FOLD_RIGHT_34(o,s,l) BOOST_PP_LIST_FOLD_LEFT_34(o, s, BOOST_PP_LIST_REVERSE_D(34, l))
#define BOOST_PP_LIST_FOLD_RIGHT_35(o,s,l) BOOST_PP_LIST_FOLD_LEFT_35(o, s, BOOST_PP_LIST_REVERSE_D(35, l))
#define BOOST_PP_LIST_FOLD_RIGHT_36(o,s,l) BOOST_PP_LIST_FOLD_LEFT_36(o, s, BOOST_PP_LIST_REVERSE_D(36, l))
#define BOOST_PP_LIST_FOLD_RIGHT_37(o,s,l) BOOST_PP_LIST_FOLD_LEFT_37(o, s, BOOST_PP_LIST_REVERSE_D(37, l))
#define BOOST_PP_LIST_FOLD_RIGHT_38(o,s,l) BOOST_PP_LIST_FOLD_LEFT_38(o, s, BOOST_PP_LIST_REVERSE_D(38, l))
#define BOOST_PP_LIST_FOLD_RIGHT_39(o,s,l) BOOST_PP_LIST_FOLD_LEFT_39(o, s, BOOST_PP_LIST_REVERSE_D(39, l))
#define BOOST_PP_LIST_FOLD_RIGHT_40(o,s,l) BOOST_PP_LIST_FOLD_LEFT_40(o, s, BOOST_PP_LIST_REVERSE_D(40, l))
#define BOOST_PP_LIST_FOLD_RIGHT_41(o,s,l) BOOST_PP_LIST_FOLD_LEFT_41(o, s, BOOST_PP_LIST_REVERSE_D(41, l))
#define BOOST_PP_LIST_FOLD_RIGHT_42(o,s,l) BOOST_PP_LIST_FOLD_LEFT_42(o, s, BOOST_PP_LIST_REVERSE_D(42, l))
#define BOOST_PP_LIST_FOLD_RIGHT_43(o,s,l) BOOST_PP_LIST_FOLD_LEFT_43(o, s, BOOST_PP_LIST_REVERSE_D(43, l))
#define BOOST_PP_LIST_FOLD_RIGHT_44(o,s,l) BOOST_PP_LIST_FOLD_LEFT_44(o, s, BOOST_PP_LIST_REVERSE_D(44, l))
#define BOOST_PP_LIST_FOLD_RIGHT_45(o,s,l) BOOST_PP_LIST_FOLD_LEFT_45(o, s, BOOST_PP_LIST_REVERSE_D(45, l))
#define BOOST_PP_LIST_FOLD_RIGHT_46(o,s,l) BOOST_PP_LIST_FOLD_LEFT_46(o, s, BOOST_PP_LIST_REVERSE_D(46, l))
#define BOOST_PP_LIST_FOLD_RIGHT_47(o,s,l) BOOST_PP_LIST_FOLD_LEFT_47(o, s, BOOST_PP_LIST_REVERSE_D(47, l))
#define BOOST_PP_LIST_FOLD_RIGHT_48(o,s,l) BOOST_PP_LIST_FOLD_LEFT_48(o, s, BOOST_PP_LIST_REVERSE_D(48, l))
#define BOOST_PP_LIST_FOLD_RIGHT_49(o,s,l) BOOST_PP_LIST_FOLD_LEFT_49(o, s, BOOST_PP_LIST_REVERSE_D(49, l))
#define BOOST_PP_LIST_FOLD_RIGHT_50(o,s,l) BOOST_PP_LIST_FOLD_LEFT_50(o, s, BOOST_PP_LIST_REVERSE_D(50, l))
#define BOOST_PP_LIST_FOLD_RIGHT_51(o,s,l) BOOST_PP_LIST_FOLD_LEFT_51(o, s, BOOST_PP_LIST_REVERSE_D(51, l))
#define BOOST_PP_LIST_FOLD_RIGHT_52(o,s,l) BOOST_PP_LIST_FOLD_LEFT_52(o, s, BOOST_PP_LIST_REVERSE_D(52, l))
#define BOOST_PP_LIST_FOLD_RIGHT_53(o,s,l) BOOST_PP_LIST_FOLD_LEFT_53(o, s, BOOST_PP_LIST_REVERSE_D(53, l))
#define BOOST_PP_LIST_FOLD_RIGHT_54(o,s,l) BOOST_PP_LIST_FOLD_LEFT_54(o, s, BOOST_PP_LIST_REVERSE_D(54, l))
#define BOOST_PP_LIST_FOLD_RIGHT_55(o,s,l) BOOST_PP_LIST_FOLD_LEFT_55(o, s, BOOST_PP_LIST_REVERSE_D(55, l))
#define BOOST_PP_LIST_FOLD_RIGHT_56(o,s,l) BOOST_PP_LIST_FOLD_LEFT_56(o, s, BOOST_PP_LIST_REVERSE_D(56, l))
#define BOOST_PP_LIST_FOLD_RIGHT_57(o,s,l) BOOST_PP_LIST_FOLD_LEFT_57(o, s, BOOST_PP_LIST_REVERSE_D(57, l))
#define BOOST_PP_LIST_FOLD_RIGHT_58(o,s,l) BOOST_PP_LIST_FOLD_LEFT_58(o, s, BOOST_PP_LIST_REVERSE_D(58, l))
#define BOOST_PP_LIST_FOLD_RIGHT_59(o,s,l) BOOST_PP_LIST_FOLD_LEFT_59(o, s, BOOST_PP_LIST_REVERSE_D(59, l))
#define BOOST_PP_LIST_FOLD_RIGHT_60(o,s,l) BOOST_PP_LIST_FOLD_LEFT_60(o, s, BOOST_PP_LIST_REVERSE_D(60, l))
#define BOOST_PP_LIST_FOLD_RIGHT_61(o,s,l) BOOST_PP_LIST_FOLD_LEFT_61(o, s, BOOST_PP_LIST_REVERSE_D(61, l))
#define BOOST_PP_LIST_FOLD_RIGHT_62(o,s,l) BOOST_PP_LIST_FOLD_LEFT_62(o, s, BOOST_PP_LIST_REVERSE_D(62, l))
#define BOOST_PP_LIST_FOLD_RIGHT_63(o,s,l) BOOST_PP_LIST_FOLD_LEFT_63(o, s, BOOST_PP_LIST_REVERSE_D(63, l))
#define BOOST_PP_LIST_FOLD_RIGHT_64(o,s,l) BOOST_PP_LIST_FOLD_LEFT_64(o, s, BOOST_PP_LIST_REVERSE_D(64, l))
#define BOOST_PP_LIST_FOLD_RIGHT_65(o,s,l) BOOST_PP_LIST_FOLD_LEFT_65(o, s, BOOST_PP_LIST_REVERSE_D(65, l))
#define BOOST_PP_LIST_FOLD_RIGHT_66(o,s,l) BOOST_PP_LIST_FOLD_LEFT_66(o, s, BOOST_PP_LIST_REVERSE_D(66, l))
#define BOOST_PP_LIST_FOLD_RIGHT_67(o,s,l) BOOST_PP_LIST_FOLD_LEFT_67(o, s, BOOST_PP_LIST_REVERSE_D(67, l))
#define BOOST_PP_LIST_FOLD_RIGHT_68(o,s,l) BOOST_PP_LIST_FOLD_LEFT_68(o, s, BOOST_PP_LIST_REVERSE_D(68, l))
#define BOOST_PP_LIST_FOLD_RIGHT_69(o,s,l) BOOST_PP_LIST_FOLD_LEFT_69(o, s, BOOST_PP_LIST_REVERSE_D(69, l))
#define BOOST_PP_LIST_FOLD_RIGHT_70(o,s,l) BOOST_PP_LIST_FOLD_LEFT_70(o, s, BOOST_PP_LIST_REVERSE_D(70, l))
#define BOOST_PP_LIST_FOLD_RIGHT_71(o,s,l) BOOST_PP_LIST_FOLD_LEFT_71(o, s, BOOST_PP_LIST_REVERSE_D(71, l))
#define BOOST_PP_LIST_FOLD_RIGHT_72(o,s,l) BOOST_PP_LIST_FOLD_LEFT_72(o, s, BOOST_PP_LIST_REVERSE_D(72, l))
#define BOOST_PP_LIST_FOLD_RIGHT_73(o,s,l) BOOST_PP_LIST_FOLD_LEFT_73(o, s, BOOST_PP_LIST_REVERSE_D(73, l))
#define BOOST_PP_LIST_FOLD_RIGHT_74(o,s,l) BOOST_PP_LIST_FOLD_LEFT_74(o, s, BOOST_PP_LIST_REVERSE_D(74, l))
#define BOOST_PP_LIST_FOLD_RIGHT_75(o,s,l) BOOST_PP_LIST_FOLD_LEFT_75(o, s, BOOST_PP_LIST_REVERSE_D(75, l))
#define BOOST_PP_LIST_FOLD_RIGHT_76(o,s,l) BOOST_PP_LIST_FOLD_LEFT_76(o, s, BOOST_PP_LIST_REVERSE_D(76, l))
#define BOOST_PP_LIST_FOLD_RIGHT_77(o,s,l) BOOST_PP_LIST_FOLD_LEFT_77(o, s, BOOST_PP_LIST_REVERSE_D(77, l))
#define BOOST_PP_LIST_FOLD_RIGHT_78(o,s,l) BOOST_PP_LIST_FOLD_LEFT_78(o, s, BOOST_PP_LIST_REVERSE_D(78, l))
#define BOOST_PP_LIST_FOLD_RIGHT_79(o,s,l) BOOST_PP_LIST_FOLD_LEFT_79(o, s, BOOST_PP_LIST_REVERSE_D(79, l))
#define BOOST_PP_LIST_FOLD_RIGHT_80(o,s,l) BOOST_PP_LIST_FOLD_LEFT_80(o, s, BOOST_PP_LIST_REVERSE_D(80, l))
#define BOOST_PP_LIST_FOLD_RIGHT_81(o,s,l) BOOST_PP_LIST_FOLD_LEFT_81(o, s, BOOST_PP_LIST_REVERSE_D(81, l))
#define BOOST_PP_LIST_FOLD_RIGHT_82(o,s,l) BOOST_PP_LIST_FOLD_LEFT_82(o, s, BOOST_PP_LIST_REVERSE_D(82, l))
#define BOOST_PP_LIST_FOLD_RIGHT_83(o,s,l) BOOST_PP_LIST_FOLD_LEFT_83(o, s, BOOST_PP_LIST_REVERSE_D(83, l))
#define BOOST_PP_LIST_FOLD_RIGHT_84(o,s,l) BOOST_PP_LIST_FOLD_LEFT_84(o, s, BOOST_PP_LIST_REVERSE_D(84, l))
#define BOOST_PP_LIST_FOLD_RIGHT_85(o,s,l) BOOST_PP_LIST_FOLD_LEFT_85(o, s, BOOST_PP_LIST_REVERSE_D(85, l))
#define BOOST_PP_LIST_FOLD_RIGHT_86(o,s,l) BOOST_PP_LIST_FOLD_LEFT_86(o, s, BOOST_PP_LIST_REVERSE_D(86, l))
#define BOOST_PP_LIST_FOLD_RIGHT_87(o,s,l) BOOST_PP_LIST_FOLD_LEFT_87(o, s, BOOST_PP_LIST_REVERSE_D(87, l))
#define BOOST_PP_LIST_FOLD_RIGHT_88(o,s,l) BOOST_PP_LIST_FOLD_LEFT_88(o, s, BOOST_PP_LIST_REVERSE_D(88, l))
#define BOOST_PP_LIST_FOLD_RIGHT_89(o,s,l) BOOST_PP_LIST_FOLD_LEFT_89(o, s, BOOST_PP_LIST_REVERSE_D(89, l))
#define BOOST_PP_LIST_FOLD_RIGHT_90(o,s,l) BOOST_PP_LIST_FOLD_LEFT_90(o, s, BOOST_PP_LIST_REVERSE_D(90, l))
#define BOOST_PP_LIST_FOLD_RIGHT_91(o,s,l) BOOST_PP_LIST_FOLD_LEFT_91(o, s, BOOST_PP_LIST_REVERSE_D(91, l))
#define BOOST_PP_LIST_FOLD_RIGHT_92(o,s,l) BOOST_PP_LIST_FOLD_LEFT_92(o, s, BOOST_PP_LIST_REVERSE_D(92, l))
#define BOOST_PP_LIST_FOLD_RIGHT_93(o,s,l) BOOST_PP_LIST_FOLD_LEFT_93(o, s, BOOST_PP_LIST_REVERSE_D(93, l))
#define BOOST_PP_LIST_FOLD_RIGHT_94(o,s,l) BOOST_PP_LIST_FOLD_LEFT_94(o, s, BOOST_PP_LIST_REVERSE_D(94, l))
#define BOOST_PP_LIST_FOLD_RIGHT_95(o,s,l) BOOST_PP_LIST_FOLD_LEFT_95(o, s, BOOST_PP_LIST_REVERSE_D(95, l))
#define BOOST_PP_LIST_FOLD_RIGHT_96(o,s,l) BOOST_PP_LIST_FOLD_LEFT_96(o, s, BOOST_PP_LIST_REVERSE_D(96, l))
#define BOOST_PP_LIST_FOLD_RIGHT_97(o,s,l) BOOST_PP_LIST_FOLD_LEFT_97(o, s, BOOST_PP_LIST_REVERSE_D(97, l))
#define BOOST_PP_LIST_FOLD_RIGHT_98(o,s,l) BOOST_PP_LIST_FOLD_LEFT_98(o, s, BOOST_PP_LIST_REVERSE_D(98, l))
#define BOOST_PP_LIST_FOLD_RIGHT_99(o,s,l) BOOST_PP_LIST_FOLD_LEFT_99(o, s, BOOST_PP_LIST_REVERSE_D(99, l))
#define BOOST_PP_LIST_FOLD_RIGHT_100(o,s,l) BOOST_PP_LIST_FOLD_LEFT_100(o, s, BOOST_PP_LIST_REVERSE_D(100, l))
#define BOOST_PP_LIST_FOLD_RIGHT_101(o,s,l) BOOST_PP_LIST_FOLD_LEFT_101(o, s, BOOST_PP_LIST_REVERSE_D(101, l))
#define BOOST_PP_LIST_FOLD_RIGHT_102(o,s,l) BOOST_PP_LIST_FOLD_LEFT_102(o, s, BOOST_PP_LIST_REVERSE_D(102, l))
#define BOOST_PP_LIST_FOLD_RIGHT_103(o,s,l) BOOST_PP_LIST_FOLD_LEFT_103(o, s, BOOST_PP_LIST_REVERSE_D(103, l))
#define BOOST_PP_LIST_FOLD_RIGHT_104(o,s,l) BOOST_PP_LIST_FOLD_LEFT_104(o, s, BOOST_PP_LIST_REVERSE_D(104, l))
#define BOOST_PP_LIST_FOLD_RIGHT_105(o,s,l) BOOST_PP_LIST_FOLD_LEFT_105(o, s, BOOST_PP_LIST_REVERSE_D(105, l))
#define BOOST_PP_LIST_FOLD_RIGHT_106(o,s,l) BOOST_PP_LIST_FOLD_LEFT_106(o, s, BOOST_PP_LIST_REVERSE_D(106, l))
#define BOOST_PP_LIST_FOLD_RIGHT_107(o,s,l) BOOST_PP_LIST_FOLD_LEFT_107(o, s, BOOST_PP_LIST_REVERSE_D(107, l))
#define BOOST_PP_LIST_FOLD_RIGHT_108(o,s,l) BOOST_PP_LIST_FOLD_LEFT_108(o, s, BOOST_PP_LIST_REVERSE_D(108, l))
#define BOOST_PP_LIST_FOLD_RIGHT_109(o,s,l) BOOST_PP_LIST_FOLD_LEFT_109(o, s, BOOST_PP_LIST_REVERSE_D(109, l))
#define BOOST_PP_LIST_FOLD_RIGHT_110(o,s,l) BOOST_PP_LIST_FOLD_LEFT_110(o, s, BOOST_PP_LIST_REVERSE_D(110, l))
#define BOOST_PP_LIST_FOLD_RIGHT_111(o,s,l) BOOST_PP_LIST_FOLD_LEFT_111(o, s, BOOST_PP_LIST_REVERSE_D(111, l))
#define BOOST_PP_LIST_FOLD_RIGHT_112(o,s,l) BOOST_PP_LIST_FOLD_LEFT_112(o, s, BOOST_PP_LIST_REVERSE_D(112, l))
#define BOOST_PP_LIST_FOLD_RIGHT_113(o,s,l) BOOST_PP_LIST_FOLD_LEFT_113(o, s, BOOST_PP_LIST_REVERSE_D(113, l))
#define BOOST_PP_LIST_FOLD_RIGHT_114(o,s,l) BOOST_PP_LIST_FOLD_LEFT_114(o, s, BOOST_PP_LIST_REVERSE_D(114, l))
#define BOOST_PP_LIST_FOLD_RIGHT_115(o,s,l) BOOST_PP_LIST_FOLD_LEFT_115(o, s, BOOST_PP_LIST_REVERSE_D(115, l))
#define BOOST_PP_LIST_FOLD_RIGHT_116(o,s,l) BOOST_PP_LIST_FOLD_LEFT_116(o, s, BOOST_PP_LIST_REVERSE_D(116, l))
#define BOOST_PP_LIST_FOLD_RIGHT_117(o,s,l) BOOST_PP_LIST_FOLD_LEFT_117(o, s, BOOST_PP_LIST_REVERSE_D(117, l))
#define BOOST_PP_LIST_FOLD_RIGHT_118(o,s,l) BOOST_PP_LIST_FOLD_LEFT_118(o, s, BOOST_PP_LIST_REVERSE_D(118, l))
#define BOOST_PP_LIST_FOLD_RIGHT_119(o,s,l) BOOST_PP_LIST_FOLD_LEFT_119(o, s, BOOST_PP_LIST_REVERSE_D(119, l))
#define BOOST_PP_LIST_FOLD_RIGHT_120(o,s,l) BOOST_PP_LIST_FOLD_LEFT_120(o, s, BOOST_PP_LIST_REVERSE_D(120, l))
#define BOOST_PP_LIST_FOLD_RIGHT_121(o,s,l) BOOST_PP_LIST_FOLD_LEFT_121(o, s, BOOST_PP_LIST_REVERSE_D(121, l))
#define BOOST_PP_LIST_FOLD_RIGHT_122(o,s,l) BOOST_PP_LIST_FOLD_LEFT_122(o, s, BOOST_PP_LIST_REVERSE_D(122, l))
#define BOOST_PP_LIST_FOLD_RIGHT_123(o,s,l) BOOST_PP_LIST_FOLD_LEFT_123(o, s, BOOST_PP_LIST_REVERSE_D(123, l))
#define BOOST_PP_LIST_FOLD_RIGHT_124(o,s,l) BOOST_PP_LIST_FOLD_LEFT_124(o, s, BOOST_PP_LIST_REVERSE_D(124, l))
#define BOOST_PP_LIST_FOLD_RIGHT_125(o,s,l) BOOST_PP_LIST_FOLD_LEFT_125(o, s, BOOST_PP_LIST_REVERSE_D(125, l))
#define BOOST_PP_LIST_FOLD_RIGHT_126(o,s,l) BOOST_PP_LIST_FOLD_LEFT_126(o, s, BOOST_PP_LIST_REVERSE_D(126, l))
#define BOOST_PP_LIST_FOLD_RIGHT_127(o,s,l) BOOST_PP_LIST_FOLD_LEFT_127(o, s, BOOST_PP_LIST_REVERSE_D(127, l))
#define BOOST_PP_LIST_FOLD_RIGHT_128(o,s,l) BOOST_PP_LIST_FOLD_LEFT_128(o, s, BOOST_PP_LIST_REVERSE_D(128, l))
#define BOOST_PP_LIST_FOLD_RIGHT_129(o,s,l) BOOST_PP_LIST_FOLD_LEFT_129(o, s, BOOST_PP_LIST_REVERSE_D(129, l))
#define BOOST_PP_LIST_FOLD_RIGHT_130(o,s,l) BOOST_PP_LIST_FOLD_LEFT_130(o, s, BOOST_PP_LIST_REVERSE_D(130, l))
#define BOOST_PP_LIST_FOLD_RIGHT_131(o,s,l) BOOST_PP_LIST_FOLD_LEFT_131(o, s, BOOST_PP_LIST_REVERSE_D(131, l))
#define BOOST_PP_LIST_FOLD_RIGHT_132(o,s,l) BOOST_PP_LIST_FOLD_LEFT_132(o, s, BOOST_PP_LIST_REVERSE_D(132, l))
#define BOOST_PP_LIST_FOLD_RIGHT_133(o,s,l) BOOST_PP_LIST_FOLD_LEFT_133(o, s, BOOST_PP_LIST_REVERSE_D(133, l))
#define BOOST_PP_LIST_FOLD_RIGHT_134(o,s,l) BOOST_PP_LIST_FOLD_LEFT_134(o, s, BOOST_PP_LIST_REVERSE_D(134, l))
#define BOOST_PP_LIST_FOLD_RIGHT_135(o,s,l) BOOST_PP_LIST_FOLD_LEFT_135(o, s, BOOST_PP_LIST_REVERSE_D(135, l))
#define BOOST_PP_LIST_FOLD_RIGHT_136(o,s,l) BOOST_PP_LIST_FOLD_LEFT_136(o, s, BOOST_PP_LIST_REVERSE_D(136, l))
#define BOOST_PP_LIST_FOLD_RIGHT_137(o,s,l) BOOST_PP_LIST_FOLD_LEFT_137(o, s, BOOST_PP_LIST_REVERSE_D(137, l))
#define BOOST_PP_LIST_FOLD_RIGHT_138(o,s,l) BOOST_PP_LIST_FOLD_LEFT_138(o, s, BOOST_PP_LIST_REVERSE_D(138, l))
#define BOOST_PP_LIST_FOLD_RIGHT_139(o,s,l) BOOST_PP_LIST_FOLD_LEFT_139(o, s, BOOST_PP_LIST_REVERSE_D(139, l))
#define BOOST_PP_LIST_FOLD_RIGHT_140(o,s,l) BOOST_PP_LIST_FOLD_LEFT_140(o, s, BOOST_PP_LIST_REVERSE_D(140, l))
#define BOOST_PP_LIST_FOLD_RIGHT_141(o,s,l) BOOST_PP_LIST_FOLD_LEFT_141(o, s, BOOST_PP_LIST_REVERSE_D(141, l))
#define BOOST_PP_LIST_FOLD_RIGHT_142(o,s,l) BOOST_PP_LIST_FOLD_LEFT_142(o, s, BOOST_PP_LIST_REVERSE_D(142, l))
#define BOOST_PP_LIST_FOLD_RIGHT_143(o,s,l) BOOST_PP_LIST_FOLD_LEFT_143(o, s, BOOST_PP_LIST_REVERSE_D(143, l))
#define BOOST_PP_LIST_FOLD_RIGHT_144(o,s,l) BOOST_PP_LIST_FOLD_LEFT_144(o, s, BOOST_PP_LIST_REVERSE_D(144, l))
#define BOOST_PP_LIST_FOLD_RIGHT_145(o,s,l) BOOST_PP_LIST_FOLD_LEFT_145(o, s, BOOST_PP_LIST_REVERSE_D(145, l))
#define BOOST_PP_LIST_FOLD_RIGHT_146(o,s,l) BOOST_PP_LIST_FOLD_LEFT_146(o, s, BOOST_PP_LIST_REVERSE_D(146, l))
#define BOOST_PP_LIST_FOLD_RIGHT_147(o,s,l) BOOST_PP_LIST_FOLD_LEFT_147(o, s, BOOST_PP_LIST_REVERSE_D(147, l))
#define BOOST_PP_LIST_FOLD_RIGHT_148(o,s,l) BOOST_PP_LIST_FOLD_LEFT_148(o, s, BOOST_PP_LIST_REVERSE_D(148, l))
#define BOOST_PP_LIST_FOLD_RIGHT_149(o,s,l) BOOST_PP_LIST_FOLD_LEFT_149(o, s, BOOST_PP_LIST_REVERSE_D(149, l))
#define BOOST_PP_LIST_FOLD_RIGHT_150(o,s,l) BOOST_PP_LIST_FOLD_LEFT_150(o, s, BOOST_PP_LIST_REVERSE_D(150, l))
#define BOOST_PP_LIST_FOLD_RIGHT_151(o,s,l) BOOST_PP_LIST_FOLD_LEFT_151(o, s, BOOST_PP_LIST_REVERSE_D(151, l))
#define BOOST_PP_LIST_FOLD_RIGHT_152(o,s,l) BOOST_PP_LIST_FOLD_LEFT_152(o, s, BOOST_PP_LIST_REVERSE_D(152, l))
#define BOOST_PP_LIST_FOLD_RIGHT_153(o,s,l) BOOST_PP_LIST_FOLD_LEFT_153(o, s, BOOST_PP_LIST_REVERSE_D(153, l))
#define BOOST_PP_LIST_FOLD_RIGHT_154(o,s,l) BOOST_PP_LIST_FOLD_LEFT_154(o, s, BOOST_PP_LIST_REVERSE_D(154, l))
#define BOOST_PP_LIST_FOLD_RIGHT_155(o,s,l) BOOST_PP_LIST_FOLD_LEFT_155(o, s, BOOST_PP_LIST_REVERSE_D(155, l))
#define BOOST_PP_LIST_FOLD_RIGHT_156(o,s,l) BOOST_PP_LIST_FOLD_LEFT_156(o, s, BOOST_PP_LIST_REVERSE_D(156, l))
#define BOOST_PP_LIST_FOLD_RIGHT_157(o,s,l) BOOST_PP_LIST_FOLD_LEFT_157(o, s, BOOST_PP_LIST_REVERSE_D(157, l))
#define BOOST_PP_LIST_FOLD_RIGHT_158(o,s,l) BOOST_PP_LIST_FOLD_LEFT_158(o, s, BOOST_PP_LIST_REVERSE_D(158, l))
#define BOOST_PP_LIST_FOLD_RIGHT_159(o,s,l) BOOST_PP_LIST_FOLD_LEFT_159(o, s, BOOST_PP_LIST_REVERSE_D(159, l))
#define BOOST_PP_LIST_FOLD_RIGHT_160(o,s,l) BOOST_PP_LIST_FOLD_LEFT_160(o, s, BOOST_PP_LIST_REVERSE_D(160, l))
#define BOOST_PP_LIST_FOLD_RIGHT_161(o,s,l) BOOST_PP_LIST_FOLD_LEFT_161(o, s, BOOST_PP_LIST_REVERSE_D(161, l))
#define BOOST_PP_LIST_FOLD_RIGHT_162(o,s,l) BOOST_PP_LIST_FOLD_LEFT_162(o, s, BOOST_PP_LIST_REVERSE_D(162, l))
#define BOOST_PP_LIST_FOLD_RIGHT_163(o,s,l) BOOST_PP_LIST_FOLD_LEFT_163(o, s, BOOST_PP_LIST_REVERSE_D(163, l))
#define BOOST_PP_LIST_FOLD_RIGHT_164(o,s,l) BOOST_PP_LIST_FOLD_LEFT_164(o, s, BOOST_PP_LIST_REVERSE_D(164, l))
#define BOOST_PP_LIST_FOLD_RIGHT_165(o,s,l) BOOST_PP_LIST_FOLD_LEFT_165(o, s, BOOST_PP_LIST_REVERSE_D(165, l))
#define BOOST_PP_LIST_FOLD_RIGHT_166(o,s,l) BOOST_PP_LIST_FOLD_LEFT_166(o, s, BOOST_PP_LIST_REVERSE_D(166, l))
#define BOOST_PP_LIST_FOLD_RIGHT_167(o,s,l) BOOST_PP_LIST_FOLD_LEFT_167(o, s, BOOST_PP_LIST_REVERSE_D(167, l))
#define BOOST_PP_LIST_FOLD_RIGHT_168(o,s,l) BOOST_PP_LIST_FOLD_LEFT_168(o, s, BOOST_PP_LIST_REVERSE_D(168, l))
#define BOOST_PP_LIST_FOLD_RIGHT_169(o,s,l) BOOST_PP_LIST_FOLD_LEFT_169(o, s, BOOST_PP_LIST_REVERSE_D(169, l))
#define BOOST_PP_LIST_FOLD_RIGHT_170(o,s,l) BOOST_PP_LIST_FOLD_LEFT_170(o, s, BOOST_PP_LIST_REVERSE_D(170, l))
#define BOOST_PP_LIST_FOLD_RIGHT_171(o,s,l) BOOST_PP_LIST_FOLD_LEFT_171(o, s, BOOST_PP_LIST_REVERSE_D(171, l))
#define BOOST_PP_LIST_FOLD_RIGHT_172(o,s,l) BOOST_PP_LIST_FOLD_LEFT_172(o, s, BOOST_PP_LIST_REVERSE_D(172, l))
#define BOOST_PP_LIST_FOLD_RIGHT_173(o,s,l) BOOST_PP_LIST_FOLD_LEFT_173(o, s, BOOST_PP_LIST_REVERSE_D(173, l))
#define BOOST_PP_LIST_FOLD_RIGHT_174(o,s,l) BOOST_PP_LIST_FOLD_LEFT_174(o, s, BOOST_PP_LIST_REVERSE_D(174, l))
#define BOOST_PP_LIST_FOLD_RIGHT_175(o,s,l) BOOST_PP_LIST_FOLD_LEFT_175(o, s, BOOST_PP_LIST_REVERSE_D(175, l))
#define BOOST_PP_LIST_FOLD_RIGHT_176(o,s,l) BOOST_PP_LIST_FOLD_LEFT_176(o, s, BOOST_PP_LIST_REVERSE_D(176, l))
#define BOOST_PP_LIST_FOLD_RIGHT_177(o,s,l) BOOST_PP_LIST_FOLD_LEFT_177(o, s, BOOST_PP_LIST_REVERSE_D(177, l))
#define BOOST_PP_LIST_FOLD_RIGHT_178(o,s,l) BOOST_PP_LIST_FOLD_LEFT_178(o, s, BOOST_PP_LIST_REVERSE_D(178, l))
#define BOOST_PP_LIST_FOLD_RIGHT_179(o,s,l) BOOST_PP_LIST_FOLD_LEFT_179(o, s, BOOST_PP_LIST_REVERSE_D(179, l))
#define BOOST_PP_LIST_FOLD_RIGHT_180(o,s,l) BOOST_PP_LIST_FOLD_LEFT_180(o, s, BOOST_PP_LIST_REVERSE_D(180, l))
#define BOOST_PP_LIST_FOLD_RIGHT_181(o,s,l) BOOST_PP_LIST_FOLD_LEFT_181(o, s, BOOST_PP_LIST_REVERSE_D(181, l))
#define BOOST_PP_LIST_FOLD_RIGHT_182(o,s,l) BOOST_PP_LIST_FOLD_LEFT_182(o, s, BOOST_PP_LIST_REVERSE_D(182, l))
#define BOOST_PP_LIST_FOLD_RIGHT_183(o,s,l) BOOST_PP_LIST_FOLD_LEFT_183(o, s, BOOST_PP_LIST_REVERSE_D(183, l))
#define BOOST_PP_LIST_FOLD_RIGHT_184(o,s,l) BOOST_PP_LIST_FOLD_LEFT_184(o, s, BOOST_PP_LIST_REVERSE_D(184, l))
#define BOOST_PP_LIST_FOLD_RIGHT_185(o,s,l) BOOST_PP_LIST_FOLD_LEFT_185(o, s, BOOST_PP_LIST_REVERSE_D(185, l))
#define BOOST_PP_LIST_FOLD_RIGHT_186(o,s,l) BOOST_PP_LIST_FOLD_LEFT_186(o, s, BOOST_PP_LIST_REVERSE_D(186, l))
#define BOOST_PP_LIST_FOLD_RIGHT_187(o,s,l) BOOST_PP_LIST_FOLD_LEFT_187(o, s, BOOST_PP_LIST_REVERSE_D(187, l))
#define BOOST_PP_LIST_FOLD_RIGHT_188(o,s,l) BOOST_PP_LIST_FOLD_LEFT_188(o, s, BOOST_PP_LIST_REVERSE_D(188, l))
#define BOOST_PP_LIST_FOLD_RIGHT_189(o,s,l) BOOST_PP_LIST_FOLD_LEFT_189(o, s, BOOST_PP_LIST_REVERSE_D(189, l))
#define BOOST_PP_LIST_FOLD_RIGHT_190(o,s,l) BOOST_PP_LIST_FOLD_LEFT_190(o, s, BOOST_PP_LIST_REVERSE_D(190, l))
#define BOOST_PP_LIST_FOLD_RIGHT_191(o,s,l) BOOST_PP_LIST_FOLD_LEFT_191(o, s, BOOST_PP_LIST_REVERSE_D(191, l))
#define BOOST_PP_LIST_FOLD_RIGHT_192(o,s,l) BOOST_PP_LIST_FOLD_LEFT_192(o, s, BOOST_PP_LIST_REVERSE_D(192, l))
#define BOOST_PP_LIST_FOLD_RIGHT_193(o,s,l) BOOST_PP_LIST_FOLD_LEFT_193(o, s, BOOST_PP_LIST_REVERSE_D(193, l))
#define BOOST_PP_LIST_FOLD_RIGHT_194(o,s,l) BOOST_PP_LIST_FOLD_LEFT_194(o, s, BOOST_PP_LIST_REVERSE_D(194, l))
#define BOOST_PP_LIST_FOLD_RIGHT_195(o,s,l) BOOST_PP_LIST_FOLD_LEFT_195(o, s, BOOST_PP_LIST_REVERSE_D(195, l))
#define BOOST_PP_LIST_FOLD_RIGHT_196(o,s,l) BOOST_PP_LIST_FOLD_LEFT_196(o, s, BOOST_PP_LIST_REVERSE_D(196, l))
#define BOOST_PP_LIST_FOLD_RIGHT_197(o,s,l) BOOST_PP_LIST_FOLD_LEFT_197(o, s, BOOST_PP_LIST_REVERSE_D(197, l))
#define BOOST_PP_LIST_FOLD_RIGHT_198(o,s,l) BOOST_PP_LIST_FOLD_LEFT_198(o, s, BOOST_PP_LIST_REVERSE_D(198, l))
#define BOOST_PP_LIST_FOLD_RIGHT_199(o,s,l) BOOST_PP_LIST_FOLD_LEFT_199(o, s, BOOST_PP_LIST_REVERSE_D(199, l))
#define BOOST_PP_LIST_FOLD_RIGHT_200(o,s,l) BOOST_PP_LIST_FOLD_LEFT_200(o, s, BOOST_PP_LIST_REVERSE_D(200, l))
#define BOOST_PP_LIST_FOLD_RIGHT_201(o,s,l) BOOST_PP_LIST_FOLD_LEFT_201(o, s, BOOST_PP_LIST_REVERSE_D(201, l))
#define BOOST_PP_LIST_FOLD_RIGHT_202(o,s,l) BOOST_PP_LIST_FOLD_LEFT_202(o, s, BOOST_PP_LIST_REVERSE_D(202, l))
#define BOOST_PP_LIST_FOLD_RIGHT_203(o,s,l) BOOST_PP_LIST_FOLD_LEFT_203(o, s, BOOST_PP_LIST_REVERSE_D(203, l))
#define BOOST_PP_LIST_FOLD_RIGHT_204(o,s,l) BOOST_PP_LIST_FOLD_LEFT_204(o, s, BOOST_PP_LIST_REVERSE_D(204, l))
#define BOOST_PP_LIST_FOLD_RIGHT_205(o,s,l) BOOST_PP_LIST_FOLD_LEFT_205(o, s, BOOST_PP_LIST_REVERSE_D(205, l))
#define BOOST_PP_LIST_FOLD_RIGHT_206(o,s,l) BOOST_PP_LIST_FOLD_LEFT_206(o, s, BOOST_PP_LIST_REVERSE_D(206, l))
#define BOOST_PP_LIST_FOLD_RIGHT_207(o,s,l) BOOST_PP_LIST_FOLD_LEFT_207(o, s, BOOST_PP_LIST_REVERSE_D(207, l))
#define BOOST_PP_LIST_FOLD_RIGHT_208(o,s,l) BOOST_PP_LIST_FOLD_LEFT_208(o, s, BOOST_PP_LIST_REVERSE_D(208, l))
#define BOOST_PP_LIST_FOLD_RIGHT_209(o,s,l) BOOST_PP_LIST_FOLD_LEFT_209(o, s, BOOST_PP_LIST_REVERSE_D(209, l))
#define BOOST_PP_LIST_FOLD_RIGHT_210(o,s,l) BOOST_PP_LIST_FOLD_LEFT_210(o, s, BOOST_PP_LIST_REVERSE_D(210, l))
#define BOOST_PP_LIST_FOLD_RIGHT_211(o,s,l) BOOST_PP_LIST_FOLD_LEFT_211(o, s, BOOST_PP_LIST_REVERSE_D(211, l))
#define BOOST_PP_LIST_FOLD_RIGHT_212(o,s,l) BOOST_PP_LIST_FOLD_LEFT_212(o, s, BOOST_PP_LIST_REVERSE_D(212, l))
#define BOOST_PP_LIST_FOLD_RIGHT_213(o,s,l) BOOST_PP_LIST_FOLD_LEFT_213(o, s, BOOST_PP_LIST_REVERSE_D(213, l))
#define BOOST_PP_LIST_FOLD_RIGHT_214(o,s,l) BOOST_PP_LIST_FOLD_LEFT_214(o, s, BOOST_PP_LIST_REVERSE_D(214, l))
#define BOOST_PP_LIST_FOLD_RIGHT_215(o,s,l) BOOST_PP_LIST_FOLD_LEFT_215(o, s, BOOST_PP_LIST_REVERSE_D(215, l))
#define BOOST_PP_LIST_FOLD_RIGHT_216(o,s,l) BOOST_PP_LIST_FOLD_LEFT_216(o, s, BOOST_PP_LIST_REVERSE_D(216, l))
#define BOOST_PP_LIST_FOLD_RIGHT_217(o,s,l) BOOST_PP_LIST_FOLD_LEFT_217(o, s, BOOST_PP_LIST_REVERSE_D(217, l))
#define BOOST_PP_LIST_FOLD_RIGHT_218(o,s,l) BOOST_PP_LIST_FOLD_LEFT_218(o, s, BOOST_PP_LIST_REVERSE_D(218, l))
#define BOOST_PP_LIST_FOLD_RIGHT_219(o,s,l) BOOST_PP_LIST_FOLD_LEFT_219(o, s, BOOST_PP_LIST_REVERSE_D(219, l))
#define BOOST_PP_LIST_FOLD_RIGHT_220(o,s,l) BOOST_PP_LIST_FOLD_LEFT_220(o, s, BOOST_PP_LIST_REVERSE_D(220, l))
#define BOOST_PP_LIST_FOLD_RIGHT_221(o,s,l) BOOST_PP_LIST_FOLD_LEFT_221(o, s, BOOST_PP_LIST_REVERSE_D(221, l))
#define BOOST_PP_LIST_FOLD_RIGHT_222(o,s,l) BOOST_PP_LIST_FOLD_LEFT_222(o, s, BOOST_PP_LIST_REVERSE_D(222, l))
#define BOOST_PP_LIST_FOLD_RIGHT_223(o,s,l) BOOST_PP_LIST_FOLD_LEFT_223(o, s, BOOST_PP_LIST_REVERSE_D(223, l))
#define BOOST_PP_LIST_FOLD_RIGHT_224(o,s,l) BOOST_PP_LIST_FOLD_LEFT_224(o, s, BOOST_PP_LIST_REVERSE_D(224, l))
#define BOOST_PP_LIST_FOLD_RIGHT_225(o,s,l) BOOST_PP_LIST_FOLD_LEFT_225(o, s, BOOST_PP_LIST_REVERSE_D(225, l))
#define BOOST_PP_LIST_FOLD_RIGHT_226(o,s,l) BOOST_PP_LIST_FOLD_LEFT_226(o, s, BOOST_PP_LIST_REVERSE_D(226, l))
#define BOOST_PP_LIST_FOLD_RIGHT_227(o,s,l) BOOST_PP_LIST_FOLD_LEFT_227(o, s, BOOST_PP_LIST_REVERSE_D(227, l))
#define BOOST_PP_LIST_FOLD_RIGHT_228(o,s,l) BOOST_PP_LIST_FOLD_LEFT_228(o, s, BOOST_PP_LIST_REVERSE_D(228, l))
#define BOOST_PP_LIST_FOLD_RIGHT_229(o,s,l) BOOST_PP_LIST_FOLD_LEFT_229(o, s, BOOST_PP_LIST_REVERSE_D(229, l))
#define BOOST_PP_LIST_FOLD_RIGHT_230(o,s,l) BOOST_PP_LIST_FOLD_LEFT_230(o, s, BOOST_PP_LIST_REVERSE_D(230, l))
#define BOOST_PP_LIST_FOLD_RIGHT_231(o,s,l) BOOST_PP_LIST_FOLD_LEFT_231(o, s, BOOST_PP_LIST_REVERSE_D(231, l))
#define BOOST_PP_LIST_FOLD_RIGHT_232(o,s,l) BOOST_PP_LIST_FOLD_LEFT_232(o, s, BOOST_PP_LIST_REVERSE_D(232, l))
#define BOOST_PP_LIST_FOLD_RIGHT_233(o,s,l) BOOST_PP_LIST_FOLD_LEFT_233(o, s, BOOST_PP_LIST_REVERSE_D(233, l))
#define BOOST_PP_LIST_FOLD_RIGHT_234(o,s,l) BOOST_PP_LIST_FOLD_LEFT_234(o, s, BOOST_PP_LIST_REVERSE_D(234, l))
#define BOOST_PP_LIST_FOLD_RIGHT_235(o,s,l) BOOST_PP_LIST_FOLD_LEFT_235(o, s, BOOST_PP_LIST_REVERSE_D(235, l))
#define BOOST_PP_LIST_FOLD_RIGHT_236(o,s,l) BOOST_PP_LIST_FOLD_LEFT_236(o, s, BOOST_PP_LIST_REVERSE_D(236, l))
#define BOOST_PP_LIST_FOLD_RIGHT_237(o,s,l) BOOST_PP_LIST_FOLD_LEFT_237(o, s, BOOST_PP_LIST_REVERSE_D(237, l))
#define BOOST_PP_LIST_FOLD_RIGHT_238(o,s,l) BOOST_PP_LIST_FOLD_LEFT_238(o, s, BOOST_PP_LIST_REVERSE_D(238, l))
#define BOOST_PP_LIST_FOLD_RIGHT_239(o,s,l) BOOST_PP_LIST_FOLD_LEFT_239(o, s, BOOST_PP_LIST_REVERSE_D(239, l))
#define BOOST_PP_LIST_FOLD_RIGHT_240(o,s,l) BOOST_PP_LIST_FOLD_LEFT_240(o, s, BOOST_PP_LIST_REVERSE_D(240, l))
#define BOOST_PP_LIST_FOLD_RIGHT_241(o,s,l) BOOST_PP_LIST_FOLD_LEFT_241(o, s, BOOST_PP_LIST_REVERSE_D(241, l))
#define BOOST_PP_LIST_FOLD_RIGHT_242(o,s,l) BOOST_PP_LIST_FOLD_LEFT_242(o, s, BOOST_PP_LIST_REVERSE_D(242, l))
#define BOOST_PP_LIST_FOLD_RIGHT_243(o,s,l) BOOST_PP_LIST_FOLD_LEFT_243(o, s, BOOST_PP_LIST_REVERSE_D(243, l))
#define BOOST_PP_LIST_FOLD_RIGHT_244(o,s,l) BOOST_PP_LIST_FOLD_LEFT_244(o, s, BOOST_PP_LIST_REVERSE_D(244, l))
#define BOOST_PP_LIST_FOLD_RIGHT_245(o,s,l) BOOST_PP_LIST_FOLD_LEFT_245(o, s, BOOST_PP_LIST_REVERSE_D(245, l))
#define BOOST_PP_LIST_FOLD_RIGHT_246(o,s,l) BOOST_PP_LIST_FOLD_LEFT_246(o, s, BOOST_PP_LIST_REVERSE_D(246, l))
#define BOOST_PP_LIST_FOLD_RIGHT_247(o,s,l) BOOST_PP_LIST_FOLD_LEFT_247(o, s, BOOST_PP_LIST_REVERSE_D(247, l))
#define BOOST_PP_LIST_FOLD_RIGHT_248(o,s,l) BOOST_PP_LIST_FOLD_LEFT_248(o, s, BOOST_PP_LIST_REVERSE_D(248, l))
#define BOOST_PP_LIST_FOLD_RIGHT_249(o,s,l) BOOST_PP_LIST_FOLD_LEFT_249(o, s, BOOST_PP_LIST_REVERSE_D(249, l))
#define BOOST_PP_LIST_FOLD_RIGHT_250(o,s,l) BOOST_PP_LIST_FOLD_LEFT_250(o, s, BOOST_PP_LIST_REVERSE_D(250, l))
#define BOOST_PP_LIST_FOLD_RIGHT_251(o,s,l) BOOST_PP_LIST_FOLD_LEFT_251(o, s, BOOST_PP_LIST_REVERSE_D(251, l))
#define BOOST_PP_LIST_FOLD_RIGHT_252(o,s,l) BOOST_PP_LIST_FOLD_LEFT_252(o, s, BOOST_PP_LIST_REVERSE_D(252, l))
#define BOOST_PP_LIST_FOLD_RIGHT_253(o,s,l) BOOST_PP_LIST_FOLD_LEFT_253(o, s, BOOST_PP_LIST_REVERSE_D(253, l))
#define BOOST_PP_LIST_FOLD_RIGHT_254(o,s,l) BOOST_PP_LIST_FOLD_LEFT_254(o, s, BOOST_PP_LIST_REVERSE_D(254, l))
#define BOOST_PP_LIST_FOLD_RIGHT_255(o,s,l) BOOST_PP_LIST_FOLD_LEFT_255(o, s, BOOST_PP_LIST_REVERSE_D(255, l))
#define BOOST_PP_LIST_FOLD_RIGHT_256(o,s,l) BOOST_PP_LIST_FOLD_LEFT_256(o, s, BOOST_PP_LIST_REVERSE_D(256, l))
#define BOOST_PP_WHILE BOOST_PP_CAT(BOOST_PP_WHILE_, BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256))
#define BOOST_PP_WHILE_P(n) BOOST_PP_BITAND(BOOST_PP_CAT(BOOST_PP_WHILE_CHECK_, BOOST_PP_WHILE_ ## n(BOOST_PP_WHILE_F, BOOST_PP_NIL, BOOST_PP_NIL)), BOOST_PP_CAT(BOOST_PP_LIST_FOLD_LEFT_CHECK_, BOOST_PP_LIST_FOLD_LEFT_ ## n(BOOST_PP_NIL, BOOST_PP_NIL, BOOST_PP_NIL)))
#define BOOST_PP_WHILE_F(d,_) 0
#define BOOST_PREPROCESSOR_CONTROL_DETAIL_WHILE_HPP
#define BOOST_PP_WHILE_1(p,o,s) BOOST_PP_WHILE_1_C(BOOST_PP_BOOL(p(2, s)), p, o, s)
#define BOOST_PP_WHILE_2(p,o,s) BOOST_PP_WHILE_2_C(BOOST_PP_BOOL(p(3, s)), p, o, s)
#define BOOST_PP_WHILE_3(p,o,s) BOOST_PP_WHILE_3_C(BOOST_PP_BOOL(p(4, s)), p, o, s)
#define BOOST_PP_WHILE_4(p,o,s) BOOST_PP_WHILE_4_C(BOOST_PP_BOOL(p(5, s)), p, o, s)
#define BOOST_PP_WHILE_5(p,o,s) BOOST_PP_WHILE_5_C(BOOST_PP_BOOL(p(6, s)), p, o, s)
#define BOOST_PP_WHILE_6(p,o,s) BOOST_PP_WHILE_6_C(BOOST_PP_BOOL(p(7, s)), p, o, s)
#define BOOST_PP_WHILE_7(p,o,s) BOOST_PP_WHILE_7_C(BOOST_PP_BOOL(p(8, s)), p, o, s)
#define BOOST_PP_WHILE_8(p,o,s) BOOST_PP_WHILE_8_C(BOOST_PP_BOOL(p(9, s)), p, o, s)
#define BOOST_PP_WHILE_9(p,o,s) BOOST_PP_WHILE_9_C(BOOST_PP_BOOL(p(10, s)), p, o, s)
#define BOOST_PP_WHILE_10(p,o,s) BOOST_PP_WHILE_10_C(BOOST_PP_BOOL(p(11, s)), p, o, s)
#define BOOST_PP_WHILE_11(p,o,s) BOOST_PP_WHILE_11_C(BOOST_PP_BOOL(p(12, s)), p, o, s)
#define BOOST_PP_WHILE_12(p,o,s) BOOST_PP_WHILE_12_C(BOOST_PP_BOOL(p(13, s)), p, o, s)
#define BOOST_PP_WHILE_13(p,o,s) BOOST_PP_WHILE_13_C(BOOST_PP_BOOL(p(14, s)), p, o, s)
#define BOOST_PP_WHILE_14(p,o,s) BOOST_PP_WHILE_14_C(BOOST_PP_BOOL(p(15, s)), p, o, s)
#define BOOST_PP_WHILE_15(p,o,s) BOOST_PP_WHILE_15_C(BOOST_PP_BOOL(p(16, s)), p, o, s)
#define BOOST_PP_WHILE_16(p,o,s) BOOST_PP_WHILE_16_C(BOOST_PP_BOOL(p(17, s)), p, o, s)
#define BOOST_PP_WHILE_17(p,o,s) BOOST_PP_WHILE_17_C(BOOST_PP_BOOL(p(18, s)), p, o, s)
#define BOOST_PP_WHILE_18(p,o,s) BOOST_PP_WHILE_18_C(BOOST_PP_BOOL(p(19, s)), p, o, s)
#define BOOST_PP_WHILE_19(p,o,s) BOOST_PP_WHILE_19_C(BOOST_PP_BOOL(p(20, s)), p, o, s)
#define BOOST_PP_WHILE_20(p,o,s) BOOST_PP_WHILE_20_C(BOOST_PP_BOOL(p(21, s)), p, o, s)
#define BOOST_PP_WHILE_21(p,o,s) BOOST_PP_WHILE_21_C(BOOST_PP_BOOL(p(22, s)), p, o, s)
#define BOOST_PP_WHILE_22(p,o,s) BOOST_PP_WHILE_22_C(BOOST_PP_BOOL(p(23, s)), p, o, s)
#define BOOST_PP_WHILE_23(p,o,s) BOOST_PP_WHILE_23_C(BOOST_PP_BOOL(p(24, s)), p, o, s)
#define BOOST_PP_WHILE_24(p,o,s) BOOST_PP_WHILE_24_C(BOOST_PP_BOOL(p(25, s)), p, o, s)
#define BOOST_PP_WHILE_25(p,o,s) BOOST_PP_WHILE_25_C(BOOST_PP_BOOL(p(26, s)), p, o, s)
#define BOOST_PP_WHILE_26(p,o,s) BOOST_PP_WHILE_26_C(BOOST_PP_BOOL(p(27, s)), p, o, s)
#define BOOST_PP_WHILE_27(p,o,s) BOOST_PP_WHILE_27_C(BOOST_PP_BOOL(p(28, s)), p, o, s)
#define BOOST_PP_WHILE_28(p,o,s) BOOST_PP_WHILE_28_C(BOOST_PP_BOOL(p(29, s)), p, o, s)
#define BOOST_PP_WHILE_29(p,o,s) BOOST_PP_WHILE_29_C(BOOST_PP_BOOL(p(30, s)), p, o, s)
#define BOOST_PP_WHILE_30(p,o,s) BOOST_PP_WHILE_30_C(BOOST_PP_BOOL(p(31, s)), p, o, s)
#define BOOST_PP_WHILE_31(p,o,s) BOOST_PP_WHILE_31_C(BOOST_PP_BOOL(p(32, s)), p, o, s)
#define BOOST_PP_WHILE_32(p,o,s) BOOST_PP_WHILE_32_C(BOOST_PP_BOOL(p(33, s)), p, o, s)
#define BOOST_PP_WHILE_33(p,o,s) BOOST_PP_WHILE_33_C(BOOST_PP_BOOL(p(34, s)), p, o, s)
#define BOOST_PP_WHILE_34(p,o,s) BOOST_PP_WHILE_34_C(BOOST_PP_BOOL(p(35, s)), p, o, s)
#define BOOST_PP_WHILE_35(p,o,s) BOOST_PP_WHILE_35_C(BOOST_PP_BOOL(p(36, s)), p, o, s)
#define BOOST_PP_WHILE_36(p,o,s) BOOST_PP_WHILE_36_C(BOOST_PP_BOOL(p(37, s)), p, o, s)
#define BOOST_PP_WHILE_37(p,o,s) BOOST_PP_WHILE_37_C(BOOST_PP_BOOL(p(38, s)), p, o, s)
#define BOOST_PP_WHILE_38(p,o,s) BOOST_PP_WHILE_38_C(BOOST_PP_BOOL(p(39, s)), p, o, s)
#define BOOST_PP_WHILE_39(p,o,s) BOOST_PP_WHILE_39_C(BOOST_PP_BOOL(p(40, s)), p, o, s)
#define BOOST_PP_WHILE_40(p,o,s) BOOST_PP_WHILE_40_C(BOOST_PP_BOOL(p(41, s)), p, o, s)
#define BOOST_PP_WHILE_41(p,o,s) BOOST_PP_WHILE_41_C(BOOST_PP_BOOL(p(42, s)), p, o, s)
#define BOOST_PP_WHILE_42(p,o,s) BOOST_PP_WHILE_42_C(BOOST_PP_BOOL(p(43, s)), p, o, s)
#define BOOST_PP_WHILE_43(p,o,s) BOOST_PP_WHILE_43_C(BOOST_PP_BOOL(p(44, s)), p, o, s)
#define BOOST_PP_WHILE_44(p,o,s) BOOST_PP_WHILE_44_C(BOOST_PP_BOOL(p(45, s)), p, o, s)
#define BOOST_PP_WHILE_45(p,o,s) BOOST_PP_WHILE_45_C(BOOST_PP_BOOL(p(46, s)), p, o, s)
#define BOOST_PP_WHILE_46(p,o,s) BOOST_PP_WHILE_46_C(BOOST_PP_BOOL(p(47, s)), p, o, s)
#define BOOST_PP_WHILE_47(p,o,s) BOOST_PP_WHILE_47_C(BOOST_PP_BOOL(p(48, s)), p, o, s)
#define BOOST_PP_WHILE_48(p,o,s) BOOST_PP_WHILE_48_C(BOOST_PP_BOOL(p(49, s)), p, o, s)
#define BOOST_PP_WHILE_49(p,o,s) BOOST_PP_WHILE_49_C(BOOST_PP_BOOL(p(50, s)), p, o, s)
#define BOOST_PP_WHILE_50(p,o,s) BOOST_PP_WHILE_50_C(BOOST_PP_BOOL(p(51, s)), p, o, s)
#define BOOST_PP_WHILE_51(p,o,s) BOOST_PP_WHILE_51_C(BOOST_PP_BOOL(p(52, s)), p, o, s)
#define BOOST_PP_WHILE_52(p,o,s) BOOST_PP_WHILE_52_C(BOOST_PP_BOOL(p(53, s)), p, o, s)
#define BOOST_PP_WHILE_53(p,o,s) BOOST_PP_WHILE_53_C(BOOST_PP_BOOL(p(54, s)), p, o, s)
#define BOOST_PP_WHILE_54(p,o,s) BOOST_PP_WHILE_54_C(BOOST_PP_BOOL(p(55, s)), p, o, s)
#define BOOST_PP_WHILE_55(p,o,s) BOOST_PP_WHILE_55_C(BOOST_PP_BOOL(p(56, s)), p, o, s)
#define BOOST_PP_WHILE_56(p,o,s) BOOST_PP_WHILE_56_C(BOOST_PP_BOOL(p(57, s)), p, o, s)
#define BOOST_PP_WHILE_57(p,o,s) BOOST_PP_WHILE_57_C(BOOST_PP_BOOL(p(58, s)), p, o, s)
#define BOOST_PP_WHILE_58(p,o,s) BOOST_PP_WHILE_58_C(BOOST_PP_BOOL(p(59, s)), p, o, s)
#define BOOST_PP_WHILE_59(p,o,s) BOOST_PP_WHILE_59_C(BOOST_PP_BOOL(p(60, s)), p, o, s)
#define BOOST_PP_WHILE_60(p,o,s) BOOST_PP_WHILE_60_C(BOOST_PP_BOOL(p(61, s)), p, o, s)
#define BOOST_PP_WHILE_61(p,o,s) BOOST_PP_WHILE_61_C(BOOST_PP_BOOL(p(62, s)), p, o, s)
#define BOOST_PP_WHILE_62(p,o,s) BOOST_PP_WHILE_62_C(BOOST_PP_BOOL(p(63, s)), p, o, s)
#define BOOST_PP_WHILE_63(p,o,s) BOOST_PP_WHILE_63_C(BOOST_PP_BOOL(p(64, s)), p, o, s)
#define BOOST_PP_WHILE_64(p,o,s) BOOST_PP_WHILE_64_C(BOOST_PP_BOOL(p(65, s)), p, o, s)
#define BOOST_PP_WHILE_65(p,o,s) BOOST_PP_WHILE_65_C(BOOST_PP_BOOL(p(66, s)), p, o, s)
#define BOOST_PP_WHILE_66(p,o,s) BOOST_PP_WHILE_66_C(BOOST_PP_BOOL(p(67, s)), p, o, s)
#define BOOST_PP_WHILE_67(p,o,s) BOOST_PP_WHILE_67_C(BOOST_PP_BOOL(p(68, s)), p, o, s)
#define BOOST_PP_WHILE_68(p,o,s) BOOST_PP_WHILE_68_C(BOOST_PP_BOOL(p(69, s)), p, o, s)
#define BOOST_PP_WHILE_69(p,o,s) BOOST_PP_WHILE_69_C(BOOST_PP_BOOL(p(70, s)), p, o, s)
#define BOOST_PP_WHILE_70(p,o,s) BOOST_PP_WHILE_70_C(BOOST_PP_BOOL(p(71, s)), p, o, s)
#define BOOST_PP_WHILE_71(p,o,s) BOOST_PP_WHILE_71_C(BOOST_PP_BOOL(p(72, s)), p, o, s)
#define BOOST_PP_WHILE_72(p,o,s) BOOST_PP_WHILE_72_C(BOOST_PP_BOOL(p(73, s)), p, o, s)
#define BOOST_PP_WHILE_73(p,o,s) BOOST_PP_WHILE_73_C(BOOST_PP_BOOL(p(74, s)), p, o, s)
#define BOOST_PP_WHILE_74(p,o,s) BOOST_PP_WHILE_74_C(BOOST_PP_BOOL(p(75, s)), p, o, s)
#define BOOST_PP_WHILE_75(p,o,s) BOOST_PP_WHILE_75_C(BOOST_PP_BOOL(p(76, s)), p, o, s)
#define BOOST_PP_WHILE_76(p,o,s) BOOST_PP_WHILE_76_C(BOOST_PP_BOOL(p(77, s)), p, o, s)
#define BOOST_PP_WHILE_77(p,o,s) BOOST_PP_WHILE_77_C(BOOST_PP_BOOL(p(78, s)), p, o, s)
#define BOOST_PP_WHILE_78(p,o,s) BOOST_PP_WHILE_78_C(BOOST_PP_BOOL(p(79, s)), p, o, s)
#define BOOST_PP_WHILE_79(p,o,s) BOOST_PP_WHILE_79_C(BOOST_PP_BOOL(p(80, s)), p, o, s)
#define BOOST_PP_WHILE_80(p,o,s) BOOST_PP_WHILE_80_C(BOOST_PP_BOOL(p(81, s)), p, o, s)
#define BOOST_PP_WHILE_81(p,o,s) BOOST_PP_WHILE_81_C(BOOST_PP_BOOL(p(82, s)), p, o, s)
#define BOOST_PP_WHILE_82(p,o,s) BOOST_PP_WHILE_82_C(BOOST_PP_BOOL(p(83, s)), p, o, s)
#define BOOST_PP_WHILE_83(p,o,s) BOOST_PP_WHILE_83_C(BOOST_PP_BOOL(p(84, s)), p, o, s)
#define BOOST_PP_WHILE_84(p,o,s) BOOST_PP_WHILE_84_C(BOOST_PP_BOOL(p(85, s)), p, o, s)
#define BOOST_PP_WHILE_85(p,o,s) BOOST_PP_WHILE_85_C(BOOST_PP_BOOL(p(86, s)), p, o, s)
#define BOOST_PP_WHILE_86(p,o,s) BOOST_PP_WHILE_86_C(BOOST_PP_BOOL(p(87, s)), p, o, s)
#define BOOST_PP_WHILE_87(p,o,s) BOOST_PP_WHILE_87_C(BOOST_PP_BOOL(p(88, s)), p, o, s)
#define BOOST_PP_WHILE_88(p,o,s) BOOST_PP_WHILE_88_C(BOOST_PP_BOOL(p(89, s)), p, o, s)
#define BOOST_PP_WHILE_89(p,o,s) BOOST_PP_WHILE_89_C(BOOST_PP_BOOL(p(90, s)), p, o, s)
#define BOOST_PP_WHILE_90(p,o,s) BOOST_PP_WHILE_90_C(BOOST_PP_BOOL(p(91, s)), p, o, s)
#define BOOST_PP_WHILE_91(p,o,s) BOOST_PP_WHILE_91_C(BOOST_PP_BOOL(p(92, s)), p, o, s)
#define BOOST_PP_WHILE_92(p,o,s) BOOST_PP_WHILE_92_C(BOOST_PP_BOOL(p(93, s)), p, o, s)
#define BOOST_PP_WHILE_93(p,o,s) BOOST_PP_WHILE_93_C(BOOST_PP_BOOL(p(94, s)), p, o, s)
#define BOOST_PP_WHILE_94(p,o,s) BOOST_PP_WHILE_94_C(BOOST_PP_BOOL(p(95, s)), p, o, s)
#define BOOST_PP_WHILE_95(p,o,s) BOOST_PP_WHILE_95_C(BOOST_PP_BOOL(p(96, s)), p, o, s)
#define BOOST_PP_WHILE_96(p,o,s) BOOST_PP_WHILE_96_C(BOOST_PP_BOOL(p(97, s)), p, o, s)
#define BOOST_PP_WHILE_97(p,o,s) BOOST_PP_WHILE_97_C(BOOST_PP_BOOL(p(98, s)), p, o, s)
#define BOOST_PP_WHILE_98(p,o,s) BOOST_PP_WHILE_98_C(BOOST_PP_BOOL(p(99, s)), p, o, s)
#define BOOST_PP_WHILE_99(p,o,s) BOOST_PP_WHILE_99_C(BOOST_PP_BOOL(p(100, s)), p, o, s)
#define BOOST_PP_WHILE_100(p,o,s) BOOST_PP_WHILE_100_C(BOOST_PP_BOOL(p(101, s)), p, o, s)
#define BOOST_PP_WHILE_101(p,o,s) BOOST_PP_WHILE_101_C(BOOST_PP_BOOL(p(102, s)), p, o, s)
#define BOOST_PP_WHILE_102(p,o,s) BOOST_PP_WHILE_102_C(BOOST_PP_BOOL(p(103, s)), p, o, s)
#define BOOST_PP_WHILE_103(p,o,s) BOOST_PP_WHILE_103_C(BOOST_PP_BOOL(p(104, s)), p, o, s)
#define BOOST_PP_WHILE_104(p,o,s) BOOST_PP_WHILE_104_C(BOOST_PP_BOOL(p(105, s)), p, o, s)
#define BOOST_PP_WHILE_105(p,o,s) BOOST_PP_WHILE_105_C(BOOST_PP_BOOL(p(106, s)), p, o, s)
#define BOOST_PP_WHILE_106(p,o,s) BOOST_PP_WHILE_106_C(BOOST_PP_BOOL(p(107, s)), p, o, s)
#define BOOST_PP_WHILE_107(p,o,s) BOOST_PP_WHILE_107_C(BOOST_PP_BOOL(p(108, s)), p, o, s)
#define BOOST_PP_WHILE_108(p,o,s) BOOST_PP_WHILE_108_C(BOOST_PP_BOOL(p(109, s)), p, o, s)
#define BOOST_PP_WHILE_109(p,o,s) BOOST_PP_WHILE_109_C(BOOST_PP_BOOL(p(110, s)), p, o, s)
#define BOOST_PP_WHILE_110(p,o,s) BOOST_PP_WHILE_110_C(BOOST_PP_BOOL(p(111, s)), p, o, s)
#define BOOST_PP_WHILE_111(p,o,s) BOOST_PP_WHILE_111_C(BOOST_PP_BOOL(p(112, s)), p, o, s)
#define BOOST_PP_WHILE_112(p,o,s) BOOST_PP_WHILE_112_C(BOOST_PP_BOOL(p(113, s)), p, o, s)
#define BOOST_PP_WHILE_113(p,o,s) BOOST_PP_WHILE_113_C(BOOST_PP_BOOL(p(114, s)), p, o, s)
#define BOOST_PP_WHILE_114(p,o,s) BOOST_PP_WHILE_114_C(BOOST_PP_BOOL(p(115, s)), p, o, s)
#define BOOST_PP_WHILE_115(p,o,s) BOOST_PP_WHILE_115_C(BOOST_PP_BOOL(p(116, s)), p, o, s)
#define BOOST_PP_WHILE_116(p,o,s) BOOST_PP_WHILE_116_C(BOOST_PP_BOOL(p(117, s)), p, o, s)
#define BOOST_PP_WHILE_117(p,o,s) BOOST_PP_WHILE_117_C(BOOST_PP_BOOL(p(118, s)), p, o, s)
#define BOOST_PP_WHILE_118(p,o,s) BOOST_PP_WHILE_118_C(BOOST_PP_BOOL(p(119, s)), p, o, s)
#define BOOST_PP_WHILE_119(p,o,s) BOOST_PP_WHILE_119_C(BOOST_PP_BOOL(p(120, s)), p, o, s)
#define BOOST_PP_WHILE_120(p,o,s) BOOST_PP_WHILE_120_C(BOOST_PP_BOOL(p(121, s)), p, o, s)
#define BOOST_PP_WHILE_121(p,o,s) BOOST_PP_WHILE_121_C(BOOST_PP_BOOL(p(122, s)), p, o, s)
#define BOOST_PP_WHILE_122(p,o,s) BOOST_PP_WHILE_122_C(BOOST_PP_BOOL(p(123, s)), p, o, s)
#define BOOST_PP_WHILE_123(p,o,s) BOOST_PP_WHILE_123_C(BOOST_PP_BOOL(p(124, s)), p, o, s)
#define BOOST_PP_WHILE_124(p,o,s) BOOST_PP_WHILE_124_C(BOOST_PP_BOOL(p(125, s)), p, o, s)
#define BOOST_PP_WHILE_125(p,o,s) BOOST_PP_WHILE_125_C(BOOST_PP_BOOL(p(126, s)), p, o, s)
#define BOOST_PP_WHILE_126(p,o,s) BOOST_PP_WHILE_126_C(BOOST_PP_BOOL(p(127, s)), p, o, s)
#define BOOST_PP_WHILE_127(p,o,s) BOOST_PP_WHILE_127_C(BOOST_PP_BOOL(p(128, s)), p, o, s)
#define BOOST_PP_WHILE_128(p,o,s) BOOST_PP_WHILE_128_C(BOOST_PP_BOOL(p(129, s)), p, o, s)
#define BOOST_PP_WHILE_129(p,o,s) BOOST_PP_WHILE_129_C(BOOST_PP_BOOL(p(130, s)), p, o, s)
#define BOOST_PP_WHILE_130(p,o,s) BOOST_PP_WHILE_130_C(BOOST_PP_BOOL(p(131, s)), p, o, s)
#define BOOST_PP_WHILE_131(p,o,s) BOOST_PP_WHILE_131_C(BOOST_PP_BOOL(p(132, s)), p, o, s)
#define BOOST_PP_WHILE_132(p,o,s) BOOST_PP_WHILE_132_C(BOOST_PP_BOOL(p(133, s)), p, o, s)
#define BOOST_PP_WHILE_133(p,o,s) BOOST_PP_WHILE_133_C(BOOST_PP_BOOL(p(134, s)), p, o, s)
#define BOOST_PP_WHILE_134(p,o,s) BOOST_PP_WHILE_134_C(BOOST_PP_BOOL(p(135, s)), p, o, s)
#define BOOST_PP_WHILE_135(p,o,s) BOOST_PP_WHILE_135_C(BOOST_PP_BOOL(p(136, s)), p, o, s)
#define BOOST_PP_WHILE_136(p,o,s) BOOST_PP_WHILE_136_C(BOOST_PP_BOOL(p(137, s)), p, o, s)
#define BOOST_PP_WHILE_137(p,o,s) BOOST_PP_WHILE_137_C(BOOST_PP_BOOL(p(138, s)), p, o, s)
#define BOOST_PP_WHILE_138(p,o,s) BOOST_PP_WHILE_138_C(BOOST_PP_BOOL(p(139, s)), p, o, s)
#define BOOST_PP_WHILE_139(p,o,s) BOOST_PP_WHILE_139_C(BOOST_PP_BOOL(p(140, s)), p, o, s)
#define BOOST_PP_WHILE_140(p,o,s) BOOST_PP_WHILE_140_C(BOOST_PP_BOOL(p(141, s)), p, o, s)
#define BOOST_PP_WHILE_141(p,o,s) BOOST_PP_WHILE_141_C(BOOST_PP_BOOL(p(142, s)), p, o, s)
#define BOOST_PP_WHILE_142(p,o,s) BOOST_PP_WHILE_142_C(BOOST_PP_BOOL(p(143, s)), p, o, s)
#define BOOST_PP_WHILE_143(p,o,s) BOOST_PP_WHILE_143_C(BOOST_PP_BOOL(p(144, s)), p, o, s)
#define BOOST_PP_WHILE_144(p,o,s) BOOST_PP_WHILE_144_C(BOOST_PP_BOOL(p(145, s)), p, o, s)
#define BOOST_PP_WHILE_145(p,o,s) BOOST_PP_WHILE_145_C(BOOST_PP_BOOL(p(146, s)), p, o, s)
#define BOOST_PP_WHILE_146(p,o,s) BOOST_PP_WHILE_146_C(BOOST_PP_BOOL(p(147, s)), p, o, s)
#define BOOST_PP_WHILE_147(p,o,s) BOOST_PP_WHILE_147_C(BOOST_PP_BOOL(p(148, s)), p, o, s)
#define BOOST_PP_WHILE_148(p,o,s) BOOST_PP_WHILE_148_C(BOOST_PP_BOOL(p(149, s)), p, o, s)
#define BOOST_PP_WHILE_149(p,o,s) BOOST_PP_WHILE_149_C(BOOST_PP_BOOL(p(150, s)), p, o, s)
#define BOOST_PP_WHILE_150(p,o,s) BOOST_PP_WHILE_150_C(BOOST_PP_BOOL(p(151, s)), p, o, s)
#define BOOST_PP_WHILE_151(p,o,s) BOOST_PP_WHILE_151_C(BOOST_PP_BOOL(p(152, s)), p, o, s)
#define BOOST_PP_WHILE_152(p,o,s) BOOST_PP_WHILE_152_C(BOOST_PP_BOOL(p(153, s)), p, o, s)
#define BOOST_PP_WHILE_153(p,o,s) BOOST_PP_WHILE_153_C(BOOST_PP_BOOL(p(154, s)), p, o, s)
#define BOOST_PP_WHILE_154(p,o,s) BOOST_PP_WHILE_154_C(BOOST_PP_BOOL(p(155, s)), p, o, s)
#define BOOST_PP_WHILE_155(p,o,s) BOOST_PP_WHILE_155_C(BOOST_PP_BOOL(p(156, s)), p, o, s)
#define BOOST_PP_WHILE_156(p,o,s) BOOST_PP_WHILE_156_C(BOOST_PP_BOOL(p(157, s)), p, o, s)
#define BOOST_PP_WHILE_157(p,o,s) BOOST_PP_WHILE_157_C(BOOST_PP_BOOL(p(158, s)), p, o, s)
#define BOOST_PP_WHILE_158(p,o,s) BOOST_PP_WHILE_158_C(BOOST_PP_BOOL(p(159, s)), p, o, s)
#define BOOST_PP_WHILE_159(p,o,s) BOOST_PP_WHILE_159_C(BOOST_PP_BOOL(p(160, s)), p, o, s)
#define BOOST_PP_WHILE_160(p,o,s) BOOST_PP_WHILE_160_C(BOOST_PP_BOOL(p(161, s)), p, o, s)
#define BOOST_PP_WHILE_161(p,o,s) BOOST_PP_WHILE_161_C(BOOST_PP_BOOL(p(162, s)), p, o, s)
#define BOOST_PP_WHILE_162(p,o,s) BOOST_PP_WHILE_162_C(BOOST_PP_BOOL(p(163, s)), p, o, s)
#define BOOST_PP_WHILE_163(p,o,s) BOOST_PP_WHILE_163_C(BOOST_PP_BOOL(p(164, s)), p, o, s)
#define BOOST_PP_WHILE_164(p,o,s) BOOST_PP_WHILE_164_C(BOOST_PP_BOOL(p(165, s)), p, o, s)
#define BOOST_PP_WHILE_165(p,o,s) BOOST_PP_WHILE_165_C(BOOST_PP_BOOL(p(166, s)), p, o, s)
#define BOOST_PP_WHILE_166(p,o,s) BOOST_PP_WHILE_166_C(BOOST_PP_BOOL(p(167, s)), p, o, s)
#define BOOST_PP_WHILE_167(p,o,s) BOOST_PP_WHILE_167_C(BOOST_PP_BOOL(p(168, s)), p, o, s)
#define BOOST_PP_WHILE_168(p,o,s) BOOST_PP_WHILE_168_C(BOOST_PP_BOOL(p(169, s)), p, o, s)
#define BOOST_PP_WHILE_169(p,o,s) BOOST_PP_WHILE_169_C(BOOST_PP_BOOL(p(170, s)), p, o, s)
#define BOOST_PP_WHILE_170(p,o,s) BOOST_PP_WHILE_170_C(BOOST_PP_BOOL(p(171, s)), p, o, s)
#define BOOST_PP_WHILE_171(p,o,s) BOOST_PP_WHILE_171_C(BOOST_PP_BOOL(p(172, s)), p, o, s)
#define BOOST_PP_WHILE_172(p,o,s) BOOST_PP_WHILE_172_C(BOOST_PP_BOOL(p(173, s)), p, o, s)
#define BOOST_PP_WHILE_173(p,o,s) BOOST_PP_WHILE_173_C(BOOST_PP_BOOL(p(174, s)), p, o, s)
#define BOOST_PP_WHILE_174(p,o,s) BOOST_PP_WHILE_174_C(BOOST_PP_BOOL(p(175, s)), p, o, s)
#define BOOST_PP_WHILE_175(p,o,s) BOOST_PP_WHILE_175_C(BOOST_PP_BOOL(p(176, s)), p, o, s)
#define BOOST_PP_WHILE_176(p,o,s) BOOST_PP_WHILE_176_C(BOOST_PP_BOOL(p(177, s)), p, o, s)
#define BOOST_PP_WHILE_177(p,o,s) BOOST_PP_WHILE_177_C(BOOST_PP_BOOL(p(178, s)), p, o, s)
#define BOOST_PP_WHILE_178(p,o,s) BOOST_PP_WHILE_178_C(BOOST_PP_BOOL(p(179, s)), p, o, s)
#define BOOST_PP_WHILE_179(p,o,s) BOOST_PP_WHILE_179_C(BOOST_PP_BOOL(p(180, s)), p, o, s)
#define BOOST_PP_WHILE_180(p,o,s) BOOST_PP_WHILE_180_C(BOOST_PP_BOOL(p(181, s)), p, o, s)
#define BOOST_PP_WHILE_181(p,o,s) BOOST_PP_WHILE_181_C(BOOST_PP_BOOL(p(182, s)), p, o, s)
#define BOOST_PP_WHILE_182(p,o,s) BOOST_PP_WHILE_182_C(BOOST_PP_BOOL(p(183, s)), p, o, s)
#define BOOST_PP_WHILE_183(p,o,s) BOOST_PP_WHILE_183_C(BOOST_PP_BOOL(p(184, s)), p, o, s)
#define BOOST_PP_WHILE_184(p,o,s) BOOST_PP_WHILE_184_C(BOOST_PP_BOOL(p(185, s)), p, o, s)
#define BOOST_PP_WHILE_185(p,o,s) BOOST_PP_WHILE_185_C(BOOST_PP_BOOL(p(186, s)), p, o, s)
#define BOOST_PP_WHILE_186(p,o,s) BOOST_PP_WHILE_186_C(BOOST_PP_BOOL(p(187, s)), p, o, s)
#define BOOST_PP_WHILE_187(p,o,s) BOOST_PP_WHILE_187_C(BOOST_PP_BOOL(p(188, s)), p, o, s)
#define BOOST_PP_WHILE_188(p,o,s) BOOST_PP_WHILE_188_C(BOOST_PP_BOOL(p(189, s)), p, o, s)
#define BOOST_PP_WHILE_189(p,o,s) BOOST_PP_WHILE_189_C(BOOST_PP_BOOL(p(190, s)), p, o, s)
#define BOOST_PP_WHILE_190(p,o,s) BOOST_PP_WHILE_190_C(BOOST_PP_BOOL(p(191, s)), p, o, s)
#define BOOST_PP_WHILE_191(p,o,s) BOOST_PP_WHILE_191_C(BOOST_PP_BOOL(p(192, s)), p, o, s)
#define BOOST_PP_WHILE_192(p,o,s) BOOST_PP_WHILE_192_C(BOOST_PP_BOOL(p(193, s)), p, o, s)
#define BOOST_PP_WHILE_193(p,o,s) BOOST_PP_WHILE_193_C(BOOST_PP_BOOL(p(194, s)), p, o, s)
#define BOOST_PP_WHILE_194(p,o,s) BOOST_PP_WHILE_194_C(BOOST_PP_BOOL(p(195, s)), p, o, s)
#define BOOST_PP_WHILE_195(p,o,s) BOOST_PP_WHILE_195_C(BOOST_PP_BOOL(p(196, s)), p, o, s)
#define BOOST_PP_WHILE_196(p,o,s) BOOST_PP_WHILE_196_C(BOOST_PP_BOOL(p(197, s)), p, o, s)
#define BOOST_PP_WHILE_197(p,o,s) BOOST_PP_WHILE_197_C(BOOST_PP_BOOL(p(198, s)), p, o, s)
#define BOOST_PP_WHILE_198(p,o,s) BOOST_PP_WHILE_198_C(BOOST_PP_BOOL(p(199, s)), p, o, s)
#define BOOST_PP_WHILE_199(p,o,s) BOOST_PP_WHILE_199_C(BOOST_PP_BOOL(p(200, s)), p, o, s)
#define BOOST_PP_WHILE_200(p,o,s) BOOST_PP_WHILE_200_C(BOOST_PP_BOOL(p(201, s)), p, o, s)
#define BOOST_PP_WHILE_201(p,o,s) BOOST_PP_WHILE_201_C(BOOST_PP_BOOL(p(202, s)), p, o, s)
#define BOOST_PP_WHILE_202(p,o,s) BOOST_PP_WHILE_202_C(BOOST_PP_BOOL(p(203, s)), p, o, s)
#define BOOST_PP_WHILE_203(p,o,s) BOOST_PP_WHILE_203_C(BOOST_PP_BOOL(p(204, s)), p, o, s)
#define BOOST_PP_WHILE_204(p,o,s) BOOST_PP_WHILE_204_C(BOOST_PP_BOOL(p(205, s)), p, o, s)
#define BOOST_PP_WHILE_205(p,o,s) BOOST_PP_WHILE_205_C(BOOST_PP_BOOL(p(206, s)), p, o, s)
#define BOOST_PP_WHILE_206(p,o,s) BOOST_PP_WHILE_206_C(BOOST_PP_BOOL(p(207, s)), p, o, s)
#define BOOST_PP_WHILE_207(p,o,s) BOOST_PP_WHILE_207_C(BOOST_PP_BOOL(p(208, s)), p, o, s)
#define BOOST_PP_WHILE_208(p,o,s) BOOST_PP_WHILE_208_C(BOOST_PP_BOOL(p(209, s)), p, o, s)
#define BOOST_PP_WHILE_209(p,o,s) BOOST_PP_WHILE_209_C(BOOST_PP_BOOL(p(210, s)), p, o, s)
#define BOOST_PP_WHILE_210(p,o,s) BOOST_PP_WHILE_210_C(BOOST_PP_BOOL(p(211, s)), p, o, s)
#define BOOST_PP_WHILE_211(p,o,s) BOOST_PP_WHILE_211_C(BOOST_PP_BOOL(p(212, s)), p, o, s)
#define BOOST_PP_WHILE_212(p,o,s) BOOST_PP_WHILE_212_C(BOOST_PP_BOOL(p(213, s)), p, o, s)
#define BOOST_PP_WHILE_213(p,o,s) BOOST_PP_WHILE_213_C(BOOST_PP_BOOL(p(214, s)), p, o, s)
#define BOOST_PP_WHILE_214(p,o,s) BOOST_PP_WHILE_214_C(BOOST_PP_BOOL(p(215, s)), p, o, s)
#define BOOST_PP_WHILE_215(p,o,s) BOOST_PP_WHILE_215_C(BOOST_PP_BOOL(p(216, s)), p, o, s)
#define BOOST_PP_WHILE_216(p,o,s) BOOST_PP_WHILE_216_C(BOOST_PP_BOOL(p(217, s)), p, o, s)
#define BOOST_PP_WHILE_217(p,o,s) BOOST_PP_WHILE_217_C(BOOST_PP_BOOL(p(218, s)), p, o, s)
#define BOOST_PP_WHILE_218(p,o,s) BOOST_PP_WHILE_218_C(BOOST_PP_BOOL(p(219, s)), p, o, s)
#define BOOST_PP_WHILE_219(p,o,s) BOOST_PP_WHILE_219_C(BOOST_PP_BOOL(p(220, s)), p, o, s)
#define BOOST_PP_WHILE_220(p,o,s) BOOST_PP_WHILE_220_C(BOOST_PP_BOOL(p(221, s)), p, o, s)
#define BOOST_PP_WHILE_221(p,o,s) BOOST_PP_WHILE_221_C(BOOST_PP_BOOL(p(222, s)), p, o, s)
#define BOOST_PP_WHILE_222(p,o,s) BOOST_PP_WHILE_222_C(BOOST_PP_BOOL(p(223, s)), p, o, s)
#define BOOST_PP_WHILE_223(p,o,s) BOOST_PP_WHILE_223_C(BOOST_PP_BOOL(p(224, s)), p, o, s)
#define BOOST_PP_WHILE_224(p,o,s) BOOST_PP_WHILE_224_C(BOOST_PP_BOOL(p(225, s)), p, o, s)
#define BOOST_PP_WHILE_225(p,o,s) BOOST_PP_WHILE_225_C(BOOST_PP_BOOL(p(226, s)), p, o, s)
#define BOOST_PP_WHILE_226(p,o,s) BOOST_PP_WHILE_226_C(BOOST_PP_BOOL(p(227, s)), p, o, s)
#define BOOST_PP_WHILE_227(p,o,s) BOOST_PP_WHILE_227_C(BOOST_PP_BOOL(p(228, s)), p, o, s)
#define BOOST_PP_WHILE_228(p,o,s) BOOST_PP_WHILE_228_C(BOOST_PP_BOOL(p(229, s)), p, o, s)
#define BOOST_PP_WHILE_229(p,o,s) BOOST_PP_WHILE_229_C(BOOST_PP_BOOL(p(230, s)), p, o, s)
#define BOOST_PP_WHILE_230(p,o,s) BOOST_PP_WHILE_230_C(BOOST_PP_BOOL(p(231, s)), p, o, s)
#define BOOST_PP_WHILE_231(p,o,s) BOOST_PP_WHILE_231_C(BOOST_PP_BOOL(p(232, s)), p, o, s)
#define BOOST_PP_WHILE_232(p,o,s) BOOST_PP_WHILE_232_C(BOOST_PP_BOOL(p(233, s)), p, o, s)
#define BOOST_PP_WHILE_233(p,o,s) BOOST_PP_WHILE_233_C(BOOST_PP_BOOL(p(234, s)), p, o, s)
#define BOOST_PP_WHILE_234(p,o,s) BOOST_PP_WHILE_234_C(BOOST_PP_BOOL(p(235, s)), p, o, s)
#define BOOST_PP_WHILE_235(p,o,s) BOOST_PP_WHILE_235_C(BOOST_PP_BOOL(p(236, s)), p, o, s)
#define BOOST_PP_WHILE_236(p,o,s) BOOST_PP_WHILE_236_C(BOOST_PP_BOOL(p(237, s)), p, o, s)
#define BOOST_PP_WHILE_237(p,o,s) BOOST_PP_WHILE_237_C(BOOST_PP_BOOL(p(238, s)), p, o, s)
#define BOOST_PP_WHILE_238(p,o,s) BOOST_PP_WHILE_238_C(BOOST_PP_BOOL(p(239, s)), p, o, s)
#define BOOST_PP_WHILE_239(p,o,s) BOOST_PP_WHILE_239_C(BOOST_PP_BOOL(p(240, s)), p, o, s)
#define BOOST_PP_WHILE_240(p,o,s) BOOST_PP_WHILE_240_C(BOOST_PP_BOOL(p(241, s)), p, o, s)
#define BOOST_PP_WHILE_241(p,o,s) BOOST_PP_WHILE_241_C(BOOST_PP_BOOL(p(242, s)), p, o, s)
#define BOOST_PP_WHILE_242(p,o,s) BOOST_PP_WHILE_242_C(BOOST_PP_BOOL(p(243, s)), p, o, s)
#define BOOST_PP_WHILE_243(p,o,s) BOOST_PP_WHILE_243_C(BOOST_PP_BOOL(p(244, s)), p, o, s)
#define BOOST_PP_WHILE_244(p,o,s) BOOST_PP_WHILE_244_C(BOOST_PP_BOOL(p(245, s)), p, o, s)
#define BOOST_PP_WHILE_245(p,o,s) BOOST_PP_WHILE_245_C(BOOST_PP_BOOL(p(246, s)), p, o, s)
#define BOOST_PP_WHILE_246(p,o,s) BOOST_PP_WHILE_246_C(BOOST_PP_BOOL(p(247, s)), p, o, s)
#define BOOST_PP_WHILE_247(p,o,s) BOOST_PP_WHILE_247_C(BOOST_PP_BOOL(p(248, s)), p, o, s)
#define BOOST_PP_WHILE_248(p,o,s) BOOST_PP_WHILE_248_C(BOOST_PP_BOOL(p(249, s)), p, o, s)
#define BOOST_PP_WHILE_249(p,o,s) BOOST_PP_WHILE_249_C(BOOST_PP_BOOL(p(250, s)), p, o, s)
#define BOOST_PP_WHILE_250(p,o,s) BOOST_PP_WHILE_250_C(BOOST_PP_BOOL(p(251, s)), p, o, s)
#define BOOST_PP_WHILE_251(p,o,s) BOOST_PP_WHILE_251_C(BOOST_PP_BOOL(p(252, s)), p, o, s)
#define BOOST_PP_WHILE_252(p,o,s) BOOST_PP_WHILE_252_C(BOOST_PP_BOOL(p(253, s)), p, o, s)
#define BOOST_PP_WHILE_253(p,o,s) BOOST_PP_WHILE_253_C(BOOST_PP_BOOL(p(254, s)), p, o, s)
#define BOOST_PP_WHILE_254(p,o,s) BOOST_PP_WHILE_254_C(BOOST_PP_BOOL(p(255, s)), p, o, s)
#define BOOST_PP_WHILE_255(p,o,s) BOOST_PP_WHILE_255_C(BOOST_PP_BOOL(p(256, s)), p, o, s)
#define BOOST_PP_WHILE_256(p,o,s) BOOST_PP_WHILE_256_C(BOOST_PP_BOOL(p(257, s)), p, o, s)
#define BOOST_PP_WHILE_1_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_2, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(2, s))
#define BOOST_PP_WHILE_2_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_3, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(3, s))
#define BOOST_PP_WHILE_3_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_4, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(4, s))
#define BOOST_PP_WHILE_4_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_5, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(5, s))
#define BOOST_PP_WHILE_5_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_6, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(6, s))
#define BOOST_PP_WHILE_6_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_7, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(7, s))
#define BOOST_PP_WHILE_7_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_8, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(8, s))
#define BOOST_PP_WHILE_8_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_9, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(9, s))
#define BOOST_PP_WHILE_9_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_10, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(10, s))
#define BOOST_PP_WHILE_10_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_11, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(11, s))
#define BOOST_PP_WHILE_11_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_12, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(12, s))
#define BOOST_PP_WHILE_12_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_13, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(13, s))
#define BOOST_PP_WHILE_13_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_14, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(14, s))
#define BOOST_PP_WHILE_14_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_15, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(15, s))
#define BOOST_PP_WHILE_15_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_16, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(16, s))
#define BOOST_PP_WHILE_16_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_17, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(17, s))
#define BOOST_PP_WHILE_17_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_18, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(18, s))
#define BOOST_PP_WHILE_18_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_19, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(19, s))
#define BOOST_PP_WHILE_19_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_20, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(20, s))
#define BOOST_PP_WHILE_20_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_21, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(21, s))
#define BOOST_PP_WHILE_21_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_22, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(22, s))
#define BOOST_PP_WHILE_22_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_23, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(23, s))
#define BOOST_PP_WHILE_23_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_24, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(24, s))
#define BOOST_PP_WHILE_24_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_25, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(25, s))
#define BOOST_PP_WHILE_25_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_26, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(26, s))
#define BOOST_PP_WHILE_26_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_27, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(27, s))
#define BOOST_PP_WHILE_27_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_28, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(28, s))
#define BOOST_PP_WHILE_28_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_29, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(29, s))
#define BOOST_PP_WHILE_29_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_30, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(30, s))
#define BOOST_PP_WHILE_30_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_31, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(31, s))
#define BOOST_PP_WHILE_31_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_32, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(32, s))
#define BOOST_PP_WHILE_32_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_33, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(33, s))
#define BOOST_PP_WHILE_33_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_34, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(34, s))
#define BOOST_PP_WHILE_34_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_35, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(35, s))
#define BOOST_PP_WHILE_35_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_36, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(36, s))
#define BOOST_PP_WHILE_36_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_37, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(37, s))
#define BOOST_PP_WHILE_37_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_38, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(38, s))
#define BOOST_PP_WHILE_38_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_39, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(39, s))
#define BOOST_PP_WHILE_39_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_40, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(40, s))
#define BOOST_PP_WHILE_40_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_41, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(41, s))
#define BOOST_PP_WHILE_41_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_42, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(42, s))
#define BOOST_PP_WHILE_42_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_43, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(43, s))
#define BOOST_PP_WHILE_43_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_44, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(44, s))
#define BOOST_PP_WHILE_44_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_45, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(45, s))
#define BOOST_PP_WHILE_45_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_46, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(46, s))
#define BOOST_PP_WHILE_46_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_47, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(47, s))
#define BOOST_PP_WHILE_47_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_48, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(48, s))
#define BOOST_PP_WHILE_48_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_49, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(49, s))
#define BOOST_PP_WHILE_49_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_50, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(50, s))
#define BOOST_PP_WHILE_50_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_51, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(51, s))
#define BOOST_PP_WHILE_51_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_52, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(52, s))
#define BOOST_PP_WHILE_52_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_53, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(53, s))
#define BOOST_PP_WHILE_53_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_54, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(54, s))
#define BOOST_PP_WHILE_54_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_55, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(55, s))
#define BOOST_PP_WHILE_55_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_56, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(56, s))
#define BOOST_PP_WHILE_56_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_57, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(57, s))
#define BOOST_PP_WHILE_57_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_58, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(58, s))
#define BOOST_PP_WHILE_58_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_59, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(59, s))
#define BOOST_PP_WHILE_59_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_60, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(60, s))
#define BOOST_PP_WHILE_60_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_61, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(61, s))
#define BOOST_PP_WHILE_61_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_62, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(62, s))
#define BOOST_PP_WHILE_62_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_63, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(63, s))
#define BOOST_PP_WHILE_63_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_64, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(64, s))
#define BOOST_PP_WHILE_64_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_65, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(65, s))
#define BOOST_PP_WHILE_65_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_66, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(66, s))
#define BOOST_PP_WHILE_66_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_67, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(67, s))
#define BOOST_PP_WHILE_67_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_68, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(68, s))
#define BOOST_PP_WHILE_68_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_69, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(69, s))
#define BOOST_PP_WHILE_69_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_70, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(70, s))
#define BOOST_PP_WHILE_70_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_71, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(71, s))
#define BOOST_PP_WHILE_71_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_72, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(72, s))
#define BOOST_PP_WHILE_72_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_73, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(73, s))
#define BOOST_PP_WHILE_73_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_74, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(74, s))
#define BOOST_PP_WHILE_74_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_75, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(75, s))
#define BOOST_PP_WHILE_75_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_76, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(76, s))
#define BOOST_PP_WHILE_76_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_77, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(77, s))
#define BOOST_PP_WHILE_77_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_78, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(78, s))
#define BOOST_PP_WHILE_78_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_79, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(79, s))
#define BOOST_PP_WHILE_79_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_80, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(80, s))
#define BOOST_PP_WHILE_80_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_81, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(81, s))
#define BOOST_PP_WHILE_81_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_82, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(82, s))
#define BOOST_PP_WHILE_82_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_83, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(83, s))
#define BOOST_PP_WHILE_83_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_84, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(84, s))
#define BOOST_PP_WHILE_84_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_85, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(85, s))
#define BOOST_PP_WHILE_85_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_86, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(86, s))
#define BOOST_PP_WHILE_86_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_87, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(87, s))
#define BOOST_PP_WHILE_87_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_88, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(88, s))
#define BOOST_PP_WHILE_88_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_89, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(89, s))
#define BOOST_PP_WHILE_89_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_90, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(90, s))
#define BOOST_PP_WHILE_90_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_91, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(91, s))
#define BOOST_PP_WHILE_91_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_92, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(92, s))
#define BOOST_PP_WHILE_92_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_93, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(93, s))
#define BOOST_PP_WHILE_93_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_94, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(94, s))
#define BOOST_PP_WHILE_94_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_95, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(95, s))
#define BOOST_PP_WHILE_95_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_96, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(96, s))
#define BOOST_PP_WHILE_96_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_97, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(97, s))
#define BOOST_PP_WHILE_97_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_98, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(98, s))
#define BOOST_PP_WHILE_98_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_99, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(99, s))
#define BOOST_PP_WHILE_99_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_100, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(100, s))
#define BOOST_PP_WHILE_100_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_101, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(101, s))
#define BOOST_PP_WHILE_101_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_102, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(102, s))
#define BOOST_PP_WHILE_102_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_103, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(103, s))
#define BOOST_PP_WHILE_103_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_104, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(104, s))
#define BOOST_PP_WHILE_104_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_105, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(105, s))
#define BOOST_PP_WHILE_105_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_106, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(106, s))
#define BOOST_PP_WHILE_106_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_107, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(107, s))
#define BOOST_PP_WHILE_107_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_108, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(108, s))
#define BOOST_PP_WHILE_108_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_109, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(109, s))
#define BOOST_PP_WHILE_109_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_110, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(110, s))
#define BOOST_PP_WHILE_110_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_111, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(111, s))
#define BOOST_PP_WHILE_111_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_112, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(112, s))
#define BOOST_PP_WHILE_112_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_113, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(113, s))
#define BOOST_PP_WHILE_113_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_114, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(114, s))
#define BOOST_PP_WHILE_114_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_115, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(115, s))
#define BOOST_PP_WHILE_115_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_116, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(116, s))
#define BOOST_PP_WHILE_116_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_117, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(117, s))
#define BOOST_PP_WHILE_117_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_118, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(118, s))
#define BOOST_PP_WHILE_118_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_119, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(119, s))
#define BOOST_PP_WHILE_119_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_120, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(120, s))
#define BOOST_PP_WHILE_120_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_121, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(121, s))
#define BOOST_PP_WHILE_121_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_122, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(122, s))
#define BOOST_PP_WHILE_122_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_123, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(123, s))
#define BOOST_PP_WHILE_123_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_124, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(124, s))
#define BOOST_PP_WHILE_124_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_125, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(125, s))
#define BOOST_PP_WHILE_125_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_126, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(126, s))
#define BOOST_PP_WHILE_126_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_127, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(127, s))
#define BOOST_PP_WHILE_127_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_128, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(128, s))
#define BOOST_PP_WHILE_128_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_129, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(129, s))
#define BOOST_PP_WHILE_129_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_130, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(130, s))
#define BOOST_PP_WHILE_130_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_131, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(131, s))
#define BOOST_PP_WHILE_131_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_132, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(132, s))
#define BOOST_PP_WHILE_132_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_133, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(133, s))
#define BOOST_PP_WHILE_133_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_134, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(134, s))
#define BOOST_PP_WHILE_134_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_135, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(135, s))
#define BOOST_PP_WHILE_135_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_136, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(136, s))
#define BOOST_PP_WHILE_136_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_137, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(137, s))
#define BOOST_PP_WHILE_137_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_138, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(138, s))
#define BOOST_PP_WHILE_138_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_139, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(139, s))
#define BOOST_PP_WHILE_139_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_140, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(140, s))
#define BOOST_PP_WHILE_140_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_141, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(141, s))
#define BOOST_PP_WHILE_141_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_142, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(142, s))
#define BOOST_PP_WHILE_142_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_143, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(143, s))
#define BOOST_PP_WHILE_143_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_144, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(144, s))
#define BOOST_PP_WHILE_144_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_145, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(145, s))
#define BOOST_PP_WHILE_145_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_146, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(146, s))
#define BOOST_PP_WHILE_146_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_147, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(147, s))
#define BOOST_PP_WHILE_147_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_148, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(148, s))
#define BOOST_PP_WHILE_148_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_149, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(149, s))
#define BOOST_PP_WHILE_149_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_150, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(150, s))
#define BOOST_PP_WHILE_150_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_151, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(151, s))
#define BOOST_PP_WHILE_151_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_152, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(152, s))
#define BOOST_PP_WHILE_152_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_153, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(153, s))
#define BOOST_PP_WHILE_153_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_154, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(154, s))
#define BOOST_PP_WHILE_154_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_155, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(155, s))
#define BOOST_PP_WHILE_155_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_156, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(156, s))
#define BOOST_PP_WHILE_156_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_157, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(157, s))
#define BOOST_PP_WHILE_157_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_158, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(158, s))
#define BOOST_PP_WHILE_158_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_159, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(159, s))
#define BOOST_PP_WHILE_159_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_160, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(160, s))
#define BOOST_PP_WHILE_160_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_161, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(161, s))
#define BOOST_PP_WHILE_161_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_162, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(162, s))
#define BOOST_PP_WHILE_162_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_163, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(163, s))
#define BOOST_PP_WHILE_163_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_164, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(164, s))
#define BOOST_PP_WHILE_164_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_165, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(165, s))
#define BOOST_PP_WHILE_165_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_166, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(166, s))
#define BOOST_PP_WHILE_166_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_167, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(167, s))
#define BOOST_PP_WHILE_167_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_168, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(168, s))
#define BOOST_PP_WHILE_168_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_169, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(169, s))
#define BOOST_PP_WHILE_169_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_170, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(170, s))
#define BOOST_PP_WHILE_170_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_171, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(171, s))
#define BOOST_PP_WHILE_171_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_172, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(172, s))
#define BOOST_PP_WHILE_172_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_173, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(173, s))
#define BOOST_PP_WHILE_173_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_174, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(174, s))
#define BOOST_PP_WHILE_174_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_175, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(175, s))
#define BOOST_PP_WHILE_175_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_176, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(176, s))
#define BOOST_PP_WHILE_176_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_177, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(177, s))
#define BOOST_PP_WHILE_177_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_178, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(178, s))
#define BOOST_PP_WHILE_178_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_179, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(179, s))
#define BOOST_PP_WHILE_179_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_180, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(180, s))
#define BOOST_PP_WHILE_180_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_181, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(181, s))
#define BOOST_PP_WHILE_181_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_182, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(182, s))
#define BOOST_PP_WHILE_182_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_183, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(183, s))
#define BOOST_PP_WHILE_183_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_184, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(184, s))
#define BOOST_PP_WHILE_184_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_185, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(185, s))
#define BOOST_PP_WHILE_185_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_186, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(186, s))
#define BOOST_PP_WHILE_186_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_187, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(187, s))
#define BOOST_PP_WHILE_187_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_188, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(188, s))
#define BOOST_PP_WHILE_188_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_189, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(189, s))
#define BOOST_PP_WHILE_189_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_190, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(190, s))
#define BOOST_PP_WHILE_190_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_191, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(191, s))
#define BOOST_PP_WHILE_191_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_192, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(192, s))
#define BOOST_PP_WHILE_192_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_193, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(193, s))
#define BOOST_PP_WHILE_193_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_194, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(194, s))
#define BOOST_PP_WHILE_194_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_195, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(195, s))
#define BOOST_PP_WHILE_195_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_196, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(196, s))
#define BOOST_PP_WHILE_196_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_197, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(197, s))
#define BOOST_PP_WHILE_197_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_198, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(198, s))
#define BOOST_PP_WHILE_198_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_199, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(199, s))
#define BOOST_PP_WHILE_199_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_200, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(200, s))
#define BOOST_PP_WHILE_200_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_201, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(201, s))
#define BOOST_PP_WHILE_201_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_202, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(202, s))
#define BOOST_PP_WHILE_202_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_203, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(203, s))
#define BOOST_PP_WHILE_203_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_204, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(204, s))
#define BOOST_PP_WHILE_204_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_205, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(205, s))
#define BOOST_PP_WHILE_205_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_206, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(206, s))
#define BOOST_PP_WHILE_206_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_207, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(207, s))
#define BOOST_PP_WHILE_207_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_208, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(208, s))
#define BOOST_PP_WHILE_208_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_209, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(209, s))
#define BOOST_PP_WHILE_209_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_210, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(210, s))
#define BOOST_PP_WHILE_210_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_211, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(211, s))
#define BOOST_PP_WHILE_211_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_212, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(212, s))
#define BOOST_PP_WHILE_212_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_213, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(213, s))
#define BOOST_PP_WHILE_213_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_214, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(214, s))
#define BOOST_PP_WHILE_214_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_215, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(215, s))
#define BOOST_PP_WHILE_215_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_216, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(216, s))
#define BOOST_PP_WHILE_216_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_217, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(217, s))
#define BOOST_PP_WHILE_217_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_218, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(218, s))
#define BOOST_PP_WHILE_218_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_219, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(219, s))
#define BOOST_PP_WHILE_219_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_220, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(220, s))
#define BOOST_PP_WHILE_220_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_221, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(221, s))
#define BOOST_PP_WHILE_221_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_222, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(222, s))
#define BOOST_PP_WHILE_222_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_223, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(223, s))
#define BOOST_PP_WHILE_223_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_224, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(224, s))
#define BOOST_PP_WHILE_224_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_225, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(225, s))
#define BOOST_PP_WHILE_225_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_226, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(226, s))
#define BOOST_PP_WHILE_226_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_227, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(227, s))
#define BOOST_PP_WHILE_227_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_228, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(228, s))
#define BOOST_PP_WHILE_228_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_229, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(229, s))
#define BOOST_PP_WHILE_229_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_230, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(230, s))
#define BOOST_PP_WHILE_230_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_231, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(231, s))
#define BOOST_PP_WHILE_231_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_232, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(232, s))
#define BOOST_PP_WHILE_232_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_233, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(233, s))
#define BOOST_PP_WHILE_233_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_234, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(234, s))
#define BOOST_PP_WHILE_234_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_235, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(235, s))
#define BOOST_PP_WHILE_235_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_236, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(236, s))
#define BOOST_PP_WHILE_236_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_237, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(237, s))
#define BOOST_PP_WHILE_237_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_238, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(238, s))
#define BOOST_PP_WHILE_238_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_239, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(239, s))
#define BOOST_PP_WHILE_239_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_240, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(240, s))
#define BOOST_PP_WHILE_240_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_241, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(241, s))
#define BOOST_PP_WHILE_241_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_242, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(242, s))
#define BOOST_PP_WHILE_242_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_243, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(243, s))
#define BOOST_PP_WHILE_243_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_244, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(244, s))
#define BOOST_PP_WHILE_244_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_245, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(245, s))
#define BOOST_PP_WHILE_245_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_246, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(246, s))
#define BOOST_PP_WHILE_246_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_247, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(247, s))
#define BOOST_PP_WHILE_247_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_248, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(248, s))
#define BOOST_PP_WHILE_248_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_249, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(249, s))
#define BOOST_PP_WHILE_249_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_250, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(250, s))
#define BOOST_PP_WHILE_250_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_251, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(251, s))
#define BOOST_PP_WHILE_251_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_252, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(252, s))
#define BOOST_PP_WHILE_252_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_253, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(253, s))
#define BOOST_PP_WHILE_253_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_254, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(254, s))
#define BOOST_PP_WHILE_254_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_255, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(255, s))
#define BOOST_PP_WHILE_255_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_256, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(256, s))
#define BOOST_PP_WHILE_256_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_257, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(257, s))
#define BOOST_PP_WHILE_257(p,o,s) BOOST_PP_ERROR(0x0001)
#define BOOST_PP_WHILE_CHECK_BOOST_PP_NIL 1
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_1(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_2(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_3(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_4(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_5(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_6(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_7(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_8(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_9(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_10(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_11(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_12(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_13(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_14(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_15(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_16(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_17(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_18(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_19(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_20(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_21(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_22(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_23(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_24(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_25(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_26(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_27(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_28(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_29(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_30(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_31(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_32(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_33(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_34(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_35(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_36(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_37(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_38(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_39(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_40(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_41(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_42(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_43(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_44(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_45(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_46(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_47(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_48(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_49(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_50(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_51(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_52(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_53(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_54(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_55(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_56(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_57(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_58(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_59(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_60(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_61(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_62(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_63(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_64(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_65(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_66(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_67(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_68(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_69(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_70(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_71(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_72(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_73(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_74(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_75(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_76(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_77(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_78(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_79(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_80(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_81(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_82(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_83(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_84(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_85(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_86(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_87(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_88(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_89(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_90(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_91(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_92(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_93(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_94(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_95(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_96(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_97(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_98(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_99(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_100(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_101(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_102(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_103(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_104(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_105(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_106(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_107(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_108(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_109(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_110(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_111(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_112(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_113(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_114(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_115(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_116(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_117(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_118(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_119(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_120(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_121(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_122(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_123(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_124(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_125(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_126(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_127(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_128(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_129(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_130(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_131(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_132(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_133(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_134(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_135(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_136(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_137(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_138(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_139(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_140(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_141(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_142(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_143(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_144(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_145(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_146(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_147(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_148(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_149(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_150(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_151(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_152(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_153(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_154(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_155(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_156(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_157(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_158(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_159(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_160(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_161(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_162(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_163(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_164(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_165(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_166(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_167(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_168(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_169(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_170(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_171(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_172(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_173(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_174(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_175(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_176(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_177(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_178(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_179(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_180(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_181(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_182(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_183(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_184(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_185(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_186(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_187(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_188(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_189(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_190(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_191(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_192(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_193(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_194(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_195(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_196(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_197(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_198(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_199(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_200(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_201(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_202(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_203(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_204(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_205(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_206(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_207(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_208(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_209(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_210(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_211(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_212(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_213(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_214(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_215(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_216(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_217(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_218(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_219(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_220(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_221(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_222(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_223(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_224(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_225(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_226(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_227(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_228(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_229(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_230(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_231(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_232(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_233(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_234(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_235(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_236(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_237(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_238(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_239(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_240(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_241(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_242(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_243(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_244(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_245(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_246(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_247(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_248(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_249(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_250(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_251(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_252(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_253(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_254(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_255(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_256(p,o,s) 0
#define BOOST_PREPROCESSOR_TUPLE_ELEM_HPP
#define BOOST_PREPROCESSOR_FACILITIES_OVERLOAD_HPP
#define BOOST_PREPROCESSOR_VARIADIC_SIZE_HPP
#define BOOST_PP_VARIADIC_SIZE(...) BOOST_PP_VARIADIC_SIZE_I(__VA_ARGS__, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,)
#define BOOST_PP_VARIADIC_SIZE_I(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62,e63,size,...) size
#define BOOST_PP_OVERLOAD(prefix,...) BOOST_PP_CAT(prefix, BOOST_PP_VARIADIC_SIZE(__VA_ARGS__))
#define BOOST_PREPROCESSOR_TUPLE_REM_HPP
#define BOOST_PP_REM(...) __VA_ARGS__
#define BOOST_PP_TUPLE_REM(size) BOOST_PP_REM
#define BOOST_PP_TUPLE_REM_0()
#define BOOST_PP_TUPLE_REM_1(e0) e0
#define BOOST_PP_TUPLE_REM_2(e0,e1) e0, e1
#define BOOST_PP_TUPLE_REM_3(e0,e1,e2) e0, e1, e2
#define BOOST_PP_TUPLE_REM_4(e0,e1,e2,e3) e0, e1, e2, e3
#define BOOST_PP_TUPLE_REM_5(e0,e1,e2,e3,e4) e0, e1, e2, e3, e4
#define BOOST_PP_TUPLE_REM_6(e0,e1,e2,e3,e4,e5) e0, e1, e2, e3, e4, e5
#define BOOST_PP_TUPLE_REM_7(e0,e1,e2,e3,e4,e5,e6) e0, e1, e2, e3, e4, e5, e6
#define BOOST_PP_TUPLE_REM_8(e0,e1,e2,e3,e4,e5,e6,e7) e0, e1, e2, e3, e4, e5, e6, e7
#define BOOST_PP_TUPLE_REM_9(e0,e1,e2,e3,e4,e5,e6,e7,e8) e0, e1, e2, e3, e4, e5, e6, e7, e8
#define BOOST_PP_TUPLE_REM_10(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9
#define BOOST_PP_TUPLE_REM_11(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10
#define BOOST_PP_TUPLE_REM_12(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11
#define BOOST_PP_TUPLE_REM_13(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12
#define BOOST_PP_TUPLE_REM_14(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13
#define BOOST_PP_TUPLE_REM_15(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14
#define BOOST_PP_TUPLE_REM_16(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15
#define BOOST_PP_TUPLE_REM_17(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16
#define BOOST_PP_TUPLE_REM_18(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17
#define BOOST_PP_TUPLE_REM_19(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18
#define BOOST_PP_TUPLE_REM_20(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19
#define BOOST_PP_TUPLE_REM_21(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20
#define BOOST_PP_TUPLE_REM_22(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21
#define BOOST_PP_TUPLE_REM_23(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22
#define BOOST_PP_TUPLE_REM_24(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23
#define BOOST_PP_TUPLE_REM_25(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24
#define BOOST_PP_TUPLE_REM_26(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25
#define BOOST_PP_TUPLE_REM_27(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26
#define BOOST_PP_TUPLE_REM_28(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27
#define BOOST_PP_TUPLE_REM_29(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28
#define BOOST_PP_TUPLE_REM_30(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29
#define BOOST_PP_TUPLE_REM_31(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30
#define BOOST_PP_TUPLE_REM_32(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31
#define BOOST_PP_TUPLE_REM_33(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32
#define BOOST_PP_TUPLE_REM_34(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33
#define BOOST_PP_TUPLE_REM_35(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34
#define BOOST_PP_TUPLE_REM_36(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35
#define BOOST_PP_TUPLE_REM_37(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36
#define BOOST_PP_TUPLE_REM_38(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37
#define BOOST_PP_TUPLE_REM_39(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38
#define BOOST_PP_TUPLE_REM_40(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39
#define BOOST_PP_TUPLE_REM_41(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40
#define BOOST_PP_TUPLE_REM_42(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41
#define BOOST_PP_TUPLE_REM_43(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42
#define BOOST_PP_TUPLE_REM_44(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43
#define BOOST_PP_TUPLE_REM_45(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44
#define BOOST_PP_TUPLE_REM_46(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45
#define BOOST_PP_TUPLE_REM_47(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46
#define BOOST_PP_TUPLE_REM_48(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47
#define BOOST_PP_TUPLE_REM_49(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48
#define BOOST_PP_TUPLE_REM_50(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49
#define BOOST_PP_TUPLE_REM_51(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50
#define BOOST_PP_TUPLE_REM_52(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51
#define BOOST_PP_TUPLE_REM_53(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52
#define BOOST_PP_TUPLE_REM_54(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53
#define BOOST_PP_TUPLE_REM_55(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54
#define BOOST_PP_TUPLE_REM_56(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55
#define BOOST_PP_TUPLE_REM_57(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56
#define BOOST_PP_TUPLE_REM_58(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57
#define BOOST_PP_TUPLE_REM_59(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58
#define BOOST_PP_TUPLE_REM_60(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59
#define BOOST_PP_TUPLE_REM_61(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60
#define BOOST_PP_TUPLE_REM_62(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61
#define BOOST_PP_TUPLE_REM_63(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62
#define BOOST_PP_TUPLE_REM_64(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62,e63) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63
#define BOOST_PP_TUPLE_REM_CTOR(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_REM_CTOR_O_, __VA_ARGS__)(__VA_ARGS__)
#define BOOST_PP_TUPLE_REM_CTOR_O_1(tuple) BOOST_PP_REM tuple
#define BOOST_PP_TUPLE_REM_CTOR_O_2(size,tuple) BOOST_PP_TUPLE_REM_CTOR_O_1(tuple)
#define BOOST_PREPROCESSOR_VARIADIC_ELEM_HPP
#define BOOST_PP_VARIADIC_ELEM(n,...) BOOST_PP_CAT(BOOST_PP_VARIADIC_ELEM_, n)(__VA_ARGS__,)
#define BOOST_PP_VARIADIC_ELEM_0(e0,...) e0
#define BOOST_PP_VARIADIC_ELEM_1(e0,e1,...) e1
#define BOOST_PP_VARIADIC_ELEM_2(e0,e1,e2,...) e2
#define BOOST_PP_VARIADIC_ELEM_3(e0,e1,e2,e3,...) e3
#define BOOST_PP_VARIADIC_ELEM_4(e0,e1,e2,e3,e4,...) e4
#define BOOST_PP_VARIADIC_ELEM_5(e0,e1,e2,e3,e4,e5,...) e5
#define BOOST_PP_VARIADIC_ELEM_6(e0,e1,e2,e3,e4,e5,e6,...) e6
#define BOOST_PP_VARIADIC_ELEM_7(e0,e1,e2,e3,e4,e5,e6,e7,...) e7
#define BOOST_PP_VARIADIC_ELEM_8(e0,e1,e2,e3,e4,e5,e6,e7,e8,...) e8
#define BOOST_PP_VARIADIC_ELEM_9(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,...) e9
#define BOOST_PP_VARIADIC_ELEM_10(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,...) e10
#define BOOST_PP_VARIADIC_ELEM_11(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,...) e11
#define BOOST_PP_VARIADIC_ELEM_12(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,...) e12
#define BOOST_PP_VARIADIC_ELEM_13(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,...) e13
#define BOOST_PP_VARIADIC_ELEM_14(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,...) e14
#define BOOST_PP_VARIADIC_ELEM_15(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,...) e15
#define BOOST_PP_VARIADIC_ELEM_16(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,...) e16
#define BOOST_PP_VARIADIC_ELEM_17(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,...) e17
#define BOOST_PP_VARIADIC_ELEM_18(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,...) e18
#define BOOST_PP_VARIADIC_ELEM_19(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,...) e19
#define BOOST_PP_VARIADIC_ELEM_20(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,...) e20
#define BOOST_PP_VARIADIC_ELEM_21(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,...) e21
#define BOOST_PP_VARIADIC_ELEM_22(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,...) e22
#define BOOST_PP_VARIADIC_ELEM_23(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,...) e23
#define BOOST_PP_VARIADIC_ELEM_24(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,...) e24
#define BOOST_PP_VARIADIC_ELEM_25(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,...) e25
#define BOOST_PP_VARIADIC_ELEM_26(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,...) e26
#define BOOST_PP_VARIADIC_ELEM_27(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,...) e27
#define BOOST_PP_VARIADIC_ELEM_28(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,...) e28
#define BOOST_PP_VARIADIC_ELEM_29(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,...) e29
#define BOOST_PP_VARIADIC_ELEM_30(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,...) e30
#define BOOST_PP_VARIADIC_ELEM_31(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,...) e31
#define BOOST_PP_VARIADIC_ELEM_32(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,...) e32
#define BOOST_PP_VARIADIC_ELEM_33(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,...) e33
#define BOOST_PP_VARIADIC_ELEM_34(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,...) e34
#define BOOST_PP_VARIADIC_ELEM_35(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,...) e35
#define BOOST_PP_VARIADIC_ELEM_36(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,...) e36
#define BOOST_PP_VARIADIC_ELEM_37(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,...) e37
#define BOOST_PP_VARIADIC_ELEM_38(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,...) e38
#define BOOST_PP_VARIADIC_ELEM_39(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,...) e39
#define BOOST_PP_VARIADIC_ELEM_40(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,...) e40
#define BOOST_PP_VARIADIC_ELEM_41(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,...) e41
#define BOOST_PP_VARIADIC_ELEM_42(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,...) e42
#define BOOST_PP_VARIADIC_ELEM_43(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,...) e43
#define BOOST_PP_VARIADIC_ELEM_44(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,...) e44
#define BOOST_PP_VARIADIC_ELEM_45(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,...) e45
#define BOOST_PP_VARIADIC_ELEM_46(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,...) e46
#define BOOST_PP_VARIADIC_ELEM_47(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,...) e47
#define BOOST_PP_VARIADIC_ELEM_48(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,...) e48
#define BOOST_PP_VARIADIC_ELEM_49(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,...) e49
#define BOOST_PP_VARIADIC_ELEM_50(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,...) e50
#define BOOST_PP_VARIADIC_ELEM_51(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,...) e51
#define BOOST_PP_VARIADIC_ELEM_52(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,...) e52
#define BOOST_PP_VARIADIC_ELEM_53(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,...) e53
#define BOOST_PP_VARIADIC_ELEM_54(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,...) e54
#define BOOST_PP_VARIADIC_ELEM_55(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,...) e55
#define BOOST_PP_VARIADIC_ELEM_56(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,...) e56
#define BOOST_PP_VARIADIC_ELEM_57(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,...) e57
#define BOOST_PP_VARIADIC_ELEM_58(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,...) e58
#define BOOST_PP_VARIADIC_ELEM_59(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,...) e59
#define BOOST_PP_VARIADIC_ELEM_60(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,...) e60
#define BOOST_PP_VARIADIC_ELEM_61(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,...) e61
#define BOOST_PP_VARIADIC_ELEM_62(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62,...) e62
#define BOOST_PP_VARIADIC_ELEM_63(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62,e63,...) e63
#define BOOST_PP_TUPLE_ELEM(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_ELEM_O_, __VA_ARGS__)(__VA_ARGS__)
#define BOOST_PP_TUPLE_ELEM_O_2(n,tuple) BOOST_PP_VARIADIC_ELEM(n, BOOST_PP_REM tuple)
#define BOOST_PP_TUPLE_ELEM_O_3(size,n,tuple) BOOST_PP_TUPLE_ELEM_O_2(n, tuple)
#define BOOST_PP_TUPLE_ELEM_1_0(a) a
#define BOOST_PP_TUPLE_ELEM_2_0(a,b) a
#define BOOST_PP_TUPLE_ELEM_2_1(a,b) b
#define BOOST_PP_TUPLE_ELEM_3_0(a,b,c) a
#define BOOST_PP_TUPLE_ELEM_3_1(a,b,c) b
#define BOOST_PP_TUPLE_ELEM_3_2(a,b,c) c
#define BOOST_PP_ADD(x,y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_ADD_P, BOOST_PP_ADD_O, (x, y)))
#define BOOST_PP_ADD_P(d,xy) BOOST_PP_TUPLE_ELEM(2, 1, xy)
#define BOOST_PP_ADD_O(d,xy) BOOST_PP_ADD_O_I xy
#define BOOST_PP_ADD_O_I(x,y) (BOOST_PP_INC(x), BOOST_PP_DEC(y))
#define BOOST_PP_ADD_D(d,x,y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_ADD_P, BOOST_PP_ADD_O, (x, y)))
#define BOOST_PREPROCESSOR_ARITHMETIC_SUB_HPP
#define BOOST_PP_SUB(x,y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_SUB_P, BOOST_PP_SUB_O, (x, y)))
#define BOOST_PP_SUB_P(d,xy) BOOST_PP_TUPLE_ELEM(2, 1, xy)
#define BOOST_PP_SUB_O(d,xy) BOOST_PP_SUB_O_I xy
#define BOOST_PP_SUB_O_I(x,y) (BOOST_PP_DEC(x), BOOST_PP_DEC(y))
#define BOOST_PP_SUB_D(d,x,y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_SUB_P, BOOST_PP_SUB_O, (x, y)))
#define BOOST_MPL_PP_AUX_TAIL_PARAM_FUNC(unused,i,op) , BOOST_PP_CAT( BOOST_PP_TUPLE_ELEM(3, 1, op) , BOOST_PP_ADD_D(1, i, BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(3, 0, op))) ) BOOST_PP_TUPLE_ELEM(3, 2, op)()
#define BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i,param,value_func) BOOST_PP_REPEAT( BOOST_PP_SUB_D(1, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, i) , BOOST_MPL_PP_AUX_TAIL_PARAM_FUNC , (i, param, value_func) )
#define BOOST_MPL_PP_DEF_PARAMS_TAIL(i,param,value) BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, BOOST_PP_IDENTITY(=value))
#define BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(i,param,value) BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, BOOST_PP_IDENTITY(=value))
#define BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED
#define BOOST_MPL_AUX_NA_PARAMS(i) BOOST_MPL_PP_ENUM(i, na)
#define BOOST_MPL_AUX_NA_SPEC_ARITY(i,name)
#define BOOST_MPL_AUX_NA_SPEC_MAIN(i,name) template<> struct name< BOOST_MPL_AUX_NA_PARAMS(i) > { template< BOOST_MPL_PP_PARAMS(i, typename T) BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(i, typename T, na) > struct apply : name< BOOST_MPL_PP_PARAMS(i, T) > { }; };
#define BOOST_MPL_AUX_NA_SPEC_LAMBDA(i,name) template< typename Tag > struct lambda< name< BOOST_MPL_AUX_NA_PARAMS(i) > , Tag BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(int_<-1>) > { typedef false_ is_le; typedef name< BOOST_MPL_AUX_NA_PARAMS(i) > result_; typedef name< BOOST_MPL_AUX_NA_PARAMS(i) > type; };
#define BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i,j,name) namespace aux { template< BOOST_MPL_PP_PARAMS(j, typename T) > struct template_arity< name< BOOST_MPL_PP_PARAMS(j, T) > > : int_<j> { }; template<> struct template_arity< name< BOOST_MPL_PP_ENUM(i, na) > > : int_<-1> { }; }
#define BOOST_MPL_AUX_NA_SPEC_ETI(i,name)
#define BOOST_MPL_AUX_NA_PARAM(param) param = na
#define BOOST_MPL_AUX_NA_SPEC_NO_ETI(i,name) BOOST_MPL_AUX_NA_SPEC_MAIN(i, name) BOOST_MPL_AUX_NA_SPEC_LAMBDA(i, name) BOOST_MPL_AUX_NA_SPEC_ARITY(i, name) BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i, i, name)
#define BOOST_MPL_AUX_NA_SPEC(i,name) BOOST_MPL_AUX_NA_SPEC_NO_ETI(i, name) BOOST_MPL_AUX_NA_SPEC_ETI(i, name)
#define BOOST_MPL_AUX_NA_SPEC2(i,j,name) BOOST_MPL_AUX_NA_SPEC_MAIN(i, name) BOOST_MPL_AUX_NA_SPEC_ETI(i, name) BOOST_MPL_AUX_NA_SPEC_LAMBDA(i, name) BOOST_MPL_AUX_NA_SPEC_ARITY(i, name) BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i, j, name)
#define BOOST_MPL_AUX_LAMBDA_SUPPORT_HPP_INCLUDED
#define BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i,name,params)
#define BOOST_MPL_AUX_LAMBDA_SUPPORT(i,name,params)
namespace boost { namespace mpl {
template<
bool C
, typename T1
, typename T2
>
struct if_c
{
typedef T1 type;
};
template<
typename T1
, typename T2
>
struct if_c<false,T1,T2>
{
typedef T2 type;
};
template<
typename T1 = na
, typename T2 = na
, typename T3 = na
>
struct if_
{
private:
typedef if_c<
static_cast<bool>(T1::value)
, T2
, T3
> almost_type_;
public:
typedef typename almost_type_::type type;
};
template<> struct if_< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : if_< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< if_< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef if_< na , na , na > result_; typedef if_< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< if_< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< if_< na , na , na > > : int_<-1> { }; }
}}
#define BOOST_TT_IS_BASE_OF_HPP_INCLUDED
#define BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED
#define BOOST_TT_INTRINSICS_HPP_INCLUDED
#define BOOST_TT_CONFIG_HPP_INCLUDED
#define BOOST_TT_DECL
#define BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION 1
#define BOOST_TT_IS_SAME_HPP_INCLUDED
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TYPE_TRAITS_INTEGRAL_CONSTANT_HPP
#define BOOST_MPL_INTEGRAL_C_HPP_INCLUDED
#define BOOST_MPL_INTEGRAL_C_FWD_HPP_INCLUDED
namespace mpl_ {
template< typename T, T N > struct integral_c;
}
namespace boost { namespace mpl { using ::mpl_::integral_c; } }
#define AUX_WRAPPER_PARAMS(N) typename T, T N
#define AUX_WRAPPER_NAME integral_c
#define AUX_WRAPPER_VALUE_TYPE T
#define AUX_WRAPPER_INST(value) AUX_WRAPPER_NAME< T, value >
namespace mpl_ {
template< typename T, T N >
struct integral_c
{
static const T value = N;
typedef integral_c type;
typedef T value_type;
typedef integral_c_tag tag;
typedef integral_c< T, static_cast<T>((value + 1)) > next;
typedef integral_c< T, static_cast<T>((value - 1)) > prior;
operator T() const ;
};
template< typename T, T N >
T const integral_c< T, N >::value;
}
#undef AUX_WRAPPER_NAME
#undef AUX_WRAPPER_PARAMS
#undef AUX_WRAPPER_INST
#undef AUX_WRAPPER_VALUE_TYPE
namespace mpl_ {
template< bool C >
struct integral_c<bool, C>
{
static const bool value = C;
typedef integral_c_tag tag;
typedef integral_c type;
typedef bool value_type;
operator bool() const ;
};
}
namespace boost{
template <class T, T val>
struct integral_constant : public mpl::integral_c<T, val>
{
typedef integral_constant<T,val> type;
};
template<> struct integral_constant<bool,true> : public mpl::true_
{
typedef integral_constant<bool,true> type;
};
template<> struct integral_constant<bool,false> : public mpl::false_
{
typedef integral_constant<bool,false> type;
};
typedef integral_constant<bool,true> true_type;
typedef integral_constant<bool,false> false_type;
}
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
template< typename T, typename U > struct is_same : public ::boost::integral_constant<bool,false> { public: };
template< typename T > struct is_same< T,T > : public ::boost::integral_constant<bool,true> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
#define BOOST_TT_IS_REFERENCE_HPP_INCLUDED
#define BOOST_TT_IS_LVALUE_REFERENCE_HPP_INCLUDED
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
template< typename T > struct is_lvalue_reference : public ::boost::integral_constant<bool,false> { public: };
template< typename T > struct is_lvalue_reference< T& > : public ::boost::integral_constant<bool,true> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
#define BOOST_TT_IS_RVALUE_REFERENCE_HPP_INCLUDED
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
template< typename T > struct is_rvalue_reference : public ::boost::integral_constant<bool,false> { public: };
template< typename T > struct is_rvalue_reference< T&& > : public ::boost::integral_constant<bool,true> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
#define BOOST_TT_ICE_HPP_INCLUDED
#define BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED
namespace boost {
namespace type_traits {
typedef char yes_type;
struct no_type
{
char padding[8];
};
}
}
#define BOOST_TT_DETAIL_ICE_OR_HPP_INCLUDED
namespace boost {
namespace type_traits {
template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false>
struct ice_or;
template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
struct ice_or
{
static const bool value = true;
};
template <>
struct ice_or<false, false, false, false, false, false, false>
{
static const bool value = false;
};
}
}
#define BOOST_TT_DETAIL_ICE_AND_HPP_INCLUDED
namespace boost {
namespace type_traits {
template <bool b1, bool b2, bool b3 = true, bool b4 = true, bool b5 = true, bool b6 = true, bool b7 = true>
struct ice_and;
template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
struct ice_and
{
static const bool value = false;
};
template <>
struct ice_and<true, true, true, true, true, true, true>
{
static const bool value = true;
};
}
}
#define BOOST_TT_DETAIL_ICE_NOT_HPP_INCLUDED
namespace boost {
namespace type_traits {
template <bool b>
struct ice_not
{
static const bool value = true;
};
template <>
struct ice_not<true>
{
static const bool value = false;
};
}
}
#define BOOST_TT_DETAIL_ICE_EQ_HPP_INCLUDED
namespace boost {
namespace type_traits {
template <int b1, int b2>
struct ice_eq
{
static const bool value = (b1 == b2);
};
template <int b1, int b2>
struct ice_ne
{
static const bool value = (b1 != b2);
};
template <int b1, int b2> bool const ice_eq<b1,b2>::value;
template <int b1, int b2> bool const ice_ne<b1,b2>::value;
}
}
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
namespace detail {
template <typename T>
struct is_reference_impl
{
static const bool value = (::boost::type_traits::ice_or< ::boost::is_lvalue_reference<T>::value, ::boost::is_rvalue_reference<T>::value >::value);
};
}
template< typename T > struct is_reference : public ::boost::integral_constant<bool,::boost::detail::is_reference_impl<T>::value> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
#define BOOST_TT_IS_VOLATILE_HPP_INCLUDED
#define BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED
namespace boost {
namespace detail {
template <typename T> struct cv_traits_imp {};
template <typename T>
struct cv_traits_imp<T*>
{
static const bool is_const = false;
static const bool is_volatile = false;
typedef T unqualified_type;
};
template <typename T>
struct cv_traits_imp<const T*>
{
static const bool is_const = true;
static const bool is_volatile = false;
typedef T unqualified_type;
};
template <typename T>
struct cv_traits_imp<volatile T*>
{
static const bool is_const = false;
static const bool is_volatile = true;
typedef T unqualified_type;
};
template <typename T>
struct cv_traits_imp<const volatile T*>
{
static const bool is_const = true;
static const bool is_volatile = true;
typedef T unqualified_type;
};
}
}
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
namespace detail{
template <class T>
struct is_volatile_rval_filter
{
static const bool value = ::boost::detail::cv_traits_imp<T*>::is_volatile;
};
template <class T>
struct is_volatile_rval_filter<T&&>
{
static const bool value = false;
};
}
template< typename T > struct is_volatile : public ::boost::integral_constant<bool,::boost::detail::is_volatile_rval_filter<T>::value> { public: };
template< typename T > struct is_volatile< T& > : public ::boost::integral_constant<bool,false> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
#define BOOST_INTEL_TT_OPTS
#define BOOST_IS_UNION(T) __is_union(T)
#define BOOST_IS_POD(T) __is_pod(T)
#define BOOST_IS_EMPTY(T) __is_empty(T)
#define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) ((__has_trivial_constructor(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile<T>::value)
#define BOOST_HAS_TRIVIAL_COPY(T) ((__has_trivial_copy(T) BOOST_INTEL_TT_OPTS) && !is_reference<T>::value && ! ::boost::is_volatile<T>::value)
#define BOOST_HAS_TRIVIAL_ASSIGN(T) ((__has_trivial_assign(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile<T>::value && ! ::boost::is_const<T>::value)
#define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) BOOST_INTEL_TT_OPTS)
#define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) BOOST_INTEL_TT_OPTS)
#define BOOST_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) BOOST_INTEL_TT_OPTS) && !is_volatile<T>::value && !is_reference<T>::value)
#define BOOST_HAS_NOTHROW_ASSIGN(T) ((__has_nothrow_assign(T) BOOST_INTEL_TT_OPTS) && !is_volatile<T>::value && !is_const<T>::value)
#define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T)
#define BOOST_IS_ABSTRACT(T) __is_abstract(T)
#define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same<T,U>::value)
#define BOOST_IS_CLASS(T) __is_class(T)
#define BOOST_IS_ENUM(T) __is_enum(T)
#define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T)
#define BOOST_ALIGNMENT_OF(T) __alignof__(T)
#define BOOST_HAS_TYPE_TRAITS_INTRINSICS
#define BOOST_TT_REMOVE_CV_HPP_INCLUDED
#define BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED
#define BOOST_TT_BROKEN_COMPILER_SPEC(T)
#define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(T) BOOST_TT_BROKEN_COMPILER_SPEC(T)
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) template< typename T > struct trait { public: typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) template<> struct trait<spec> { public: typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };
#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) template<> struct trait ##_impl<spec> { public: typedef result type; };
#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait<spec> { public: typedef result type; };
#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) template< param1, param2 > struct trait<spec> { public: typedef result; };
#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait ##_impl<spec> { public: typedef result type; };
namespace boost {
namespace detail{
template <class T>
struct rvalue_ref_filter_rem_cv
{
typedef typename boost::detail::cv_traits_imp<T*>::unqualified_type type;
};
template <class T>
struct rvalue_ref_filter_rem_cv<T&&>
{
typedef T&& type;
};
}
template< typename T > struct remove_cv { public: typedef typename boost::detail::rvalue_ref_filter_rem_cv<T>::type type; };
template< typename T > struct remove_cv<T&> { public: typedef T& type; };
template< typename T, std::size_t N > struct remove_cv<T const[N]> { public: typedef T type[N]; };
template< typename T, std::size_t N > struct remove_cv<T volatile[N]> { public: typedef T type[N]; };
template< typename T, std::size_t N > struct remove_cv<T const volatile[N]> { public: typedef T type[N]; };
}
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
namespace detail {
template <typename B, typename D>
struct is_base_and_derived_impl
{
typedef typename remove_cv<B>::type ncvB;
typedef typename remove_cv<D>::type ncvD;
static const bool value = ((__is_base_of(B,D) && !is_same<B,D>::value) && ! ::boost::is_same<ncvB,ncvD>::value);
};
}
template< typename Base, typename Derived > struct is_base_and_derived : public ::boost::integral_constant<bool,(::boost::detail::is_base_and_derived_impl<Base,Derived>::value)> { public: };
template< typename Base, typename Derived > struct is_base_and_derived< Base&,Derived > : public ::boost::integral_constant<bool,false> { public: };
template< typename Base, typename Derived > struct is_base_and_derived< Base,Derived& > : public ::boost::integral_constant<bool,false> { public: };
template< typename Base, typename Derived > struct is_base_and_derived< Base&,Derived& > : public ::boost::integral_constant<bool,false> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
#define BOOST_TT_IS_CLASS_HPP_INCLUDED
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
namespace detail {
template <typename T>
struct is_class_impl
{
static const bool value = __is_class(T);
};
}
template< typename T > struct is_class : public ::boost::integral_constant<bool,::boost::detail::is_class_impl<T>::value> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
namespace detail{
template <class B, class D>
struct is_base_of_imp
{
typedef typename remove_cv<B>::type ncvB;
typedef typename remove_cv<D>::type ncvD;
static const bool value = (::boost::type_traits::ice_or< (::boost::detail::is_base_and_derived_impl<ncvB,ncvD>::value), (::boost::type_traits::ice_and< ::boost::is_same<ncvB,ncvD>::value, ::boost::is_class<ncvB>::value>::value)>::value);
};
}
template< typename Base, typename Derived > struct is_base_of : public ::boost::integral_constant<bool,(::boost::detail::is_base_of_imp<Base, Derived>::value)> { public: };
template< typename Base, typename Derived > struct is_base_of< Base&,Derived > : public ::boost::integral_constant<bool,false> { public: };
template< typename Base, typename Derived > struct is_base_of< Base,Derived& > : public ::boost::integral_constant<bool,false> { public: };
template< typename Base, typename Derived > struct is_base_of< Base&,Derived& > : public ::boost::integral_constant<bool,false> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
namespace boost {
namespace CV {
enum violation_enum {min_violation, max_violation};
template<class value_policies>
class constrained_value {
public:
typedef typename value_policies::value_type value_type;
constrained_value(value_type value)
;
constrained_value& operator=(value_type v)
;
static value_type max () ;
static value_type min () ;
operator value_type() const ;
protected:
value_type value_;
private:
void assign(value_type value)
;
};
template<typename rep_type, rep_type min_value,
rep_type max_value, class exception_type>
class simple_exception_policy
{
struct exception_wrapper : public exception_type
{
operator std::out_of_range () const
;
};
typedef typename mpl::if_<
is_base_of< std::exception, exception_type >,
exception_type,
exception_wrapper
>::type actual_exception_type;
public:
typedef rep_type value_type;
static rep_type min () ;
static rep_type max () ;
static void on_error(rep_type, rep_type, violation_enum)
;
};
} }
#define DATE_TIME_DATE_DEFS_HPP
namespace boost {
namespace date_time {
enum weekdays {Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday};
enum months_of_year {Jan=1,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec,NotAMonth,NumMonths};
} }
namespace boost {
namespace gregorian {
using date_time::Sunday;
using date_time::Monday;
using date_time::Tuesday;
using date_time::Wednesday;
using date_time::Thursday;
using date_time::Friday;
using date_time::Saturday;
struct bad_weekday : public std::out_of_range
{
bad_weekday() ;
};
typedef CV::simple_exception_policy<unsigned short, 0, 6, bad_weekday> greg_weekday_policies;
typedef CV::constrained_value<greg_weekday_policies> greg_weekday_rep;
class greg_weekday : public greg_weekday_rep {
public:
typedef boost::date_time::weekdays weekday_enum;
greg_weekday(unsigned short day_of_week_num)
;
unsigned short as_number() const ;
const char* as_short_string() const;
const char* as_long_string() const;
const wchar_t* as_short_wstring() const;
const wchar_t* as_long_wstring() const;
weekday_enum as_enum() const ;
};
} }
#define GREG_DAY_OF_YEAR_HPP___
namespace boost {
namespace gregorian {
struct bad_day_of_year : public std::out_of_range
{
bad_day_of_year()
;
};
typedef CV::simple_exception_policy<unsigned short,1,366,bad_day_of_year> greg_day_of_year_policies;
typedef CV::constrained_value<greg_day_of_year_policies> greg_day_of_year_rep;
} }
#define DATE_TIME_GREGORIAN_CALENDAR_HPP__
namespace boost {
namespace date_time {
template<typename ymd_type_, typename date_int_type_>
class gregorian_calendar_base {
public:
typedef ymd_type_ ymd_type;
typedef typename ymd_type::month_type month_type;
typedef typename ymd_type::day_type day_type;
typedef typename ymd_type::year_type year_type;
typedef date_int_type_ date_int_type;
static unsigned short day_of_week(const ymd_type& ymd);
static int week_number(const ymd_type&ymd);
static date_int_type day_number(const ymd_type& ymd);
static date_int_type julian_day_number(const ymd_type& ymd);
static date_int_type modjulian_day_number(const ymd_type& ymd);
static ymd_type from_day_number(date_int_type);
static ymd_type from_julian_day_number(date_int_type);
static ymd_type from_modjulian_day_number(date_int_type);
static bool is_leap_year(year_type);
static unsigned short end_of_month_day(year_type y, month_type m);
static ymd_type epoch();
static unsigned short days_in_week();
};
} }
#undef BOOST_DATE_TIME_INLINE
#define BOOST_DATE_TIME_INLINE inline
namespace boost {
namespace date_time {
} }
#define DATE_TIME_GREG_YMD_HPP__
#define GREG_DAY_HPP___
namespace boost {
namespace gregorian {
struct bad_day_of_month : public std::out_of_range
{
bad_day_of_month()
;
bad_day_of_month(const std::string& s)
;
};
typedef CV::simple_exception_policy<unsigned short, 1, 31, bad_day_of_month> greg_day_policies;
typedef CV::constrained_value<greg_day_policies> greg_day_rep;
class greg_day : public greg_day_rep {
public:
greg_day(unsigned short day_of_month) ;
unsigned short as_number() const ;
operator unsigned short() const ;
private:
};
} }
#define GREG_YEAR_HPP___
namespace boost {
namespace gregorian {
struct bad_year : public std::out_of_range
{
bad_year()
;
};
typedef CV::simple_exception_policy<unsigned short, 1400, 10000, bad_year> greg_year_policies;
typedef CV::constrained_value<greg_year_policies> greg_year_rep;
class greg_year : public greg_year_rep {
public:
greg_year(unsigned short year) ;
operator unsigned short() const ;
private:
};
} }
#define GREG_MONTH_HPP___
#define _GLIBCXX_MAP 1
#define _STL_TREE_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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 _Val>
struct _Rb_tree_node : public _Rb_tree_node_base
{
typedef _Rb_tree_node<_Val>* _Link_type;
__gnu_cxx::__aligned_buffer<_Val> _M_storage;
_Val*
_M_valptr()
;
const _Val*
_M_valptr() const
;
};
__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(_Link_type __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(_Link_type __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(static_cast<typename iterator::_Link_type>
(const_cast<typename iterator::_Base_ptr>(_M_node))); }
reference
operator*() const noexcept
{ return *static_cast<_Link_type>(_M_node)->_M_valptr(); }
pointer
operator->() const noexcept
{ return static_cast<_Link_type>(_M_node)->_M_valptr(); }
_Self&
operator++() noexcept
{
_M_node = _Rb_tree_increment(_M_node);
return *this;
}
_Self
operator++(int) noexcept
{
_Self __tmp = *this;
_M_node = _Rb_tree_increment(_M_node);
return __tmp;
}
_Self&
operator--() noexcept
{
_M_node = _Rb_tree_decrement(_M_node);
return *this;
}
_Self
operator--(int) noexcept
{
_Self __tmp = *this;
_M_node = _Rb_tree_decrement(_M_node);
return __tmp;
}
bool
operator==(const _Self& __x) const noexcept
{ return _M_node == __x._M_node; }
bool
operator!=(const _Self& __x) const noexcept
{ return _M_node != __x._M_node; }
_Base_ptr _M_node;
};
template<typename _Val>
inline bool
operator==(const _Rb_tree_iterator<_Val>& __x,
const _Rb_tree_const_iterator<_Val>& __y) noexcept
{ return __x._M_node == __y._M_node; }
template<typename _Val>
inline bool
operator!=(const _Rb_tree_iterator<_Val>& __x,
const _Rb_tree_const_iterator<_Val>& __y) noexcept
{ return __x._M_node != __y._M_node; }
void
_Rb_tree_insert_and_rebalance(const bool __insert_left,
_Rb_tree_node_base* __x,
_Rb_tree_node_base* __p,
_Rb_tree_node_base& __header) throw ();
_Rb_tree_node_base*
_Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z,
_Rb_tree_node_base& __header) throw ();
template<typename _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(const _Rb_tree_node_base& __header,
_Rb_tree& __t)
;
_Reuse_or_alloc_node(const _Reuse_or_alloc_node&) = delete;
~_Reuse_or_alloc_node()
;
template<typename _Arg>
_Link_type
operator()(_Arg&& __arg)
;
private:
_Base_ptr
_M_extract()
;
_Base_ptr _M_root;
_Base_ptr _M_nodes;
_Rb_tree& _M_t;
};
struct _Alloc_node
{
_Alloc_node(_Rb_tree& __t) ;
template<typename _Arg>
_Link_type
operator()(_Arg&& __arg) const
;
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); }
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
{
_Key_compare _M_key_compare;
_Rb_tree_node_base _M_header;
size_type _M_node_count;
_Rb_tree_impl()
: _Node_allocator(), _M_key_compare(), _M_header(),
_M_node_count(0)
{ _M_initialize(); }
_Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a)
: _Node_allocator(__a), _M_key_compare(__comp), _M_header(),
_M_node_count(0)
{ _M_initialize(); }
_Rb_tree_impl(const _Key_compare& __comp, _Node_allocator&& __a)
: _Node_allocator(std::move(__a)), _M_key_compare(__comp),
_M_header(), _M_node_count(0)
{ _M_initialize(); }
void
_M_reset()
{
this->_M_header._M_parent = 0;
this->_M_header._M_left = &this->_M_header;
this->_M_header._M_right = &this->_M_header;
this->_M_node_count = 0;
}
private:
void
_M_initialize()
{
this->_M_header._M_color = _S_red;
this->_M_header._M_parent = 0;
this->_M_header._M_left = &this->_M_header;
this->_M_header._M_right = &this->_M_header;
}
};
_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);
}
_Link_type
_M_end() noexcept
{ return reinterpret_cast<_Link_type>(&this->_M_impl._M_header); }
_Const_Link_type
_M_end() const noexcept
{ return reinterpret_cast<_Const_Link_type>(&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;
private:
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);
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);
template<typename _NodeGen>
_Link_type
_M_copy(_Const_Link_type __x, _Link_type __p, _NodeGen&);
_Link_type
_M_copy(_Const_Link_type __x, _Link_type __p)
;
void
_M_erase(_Link_type __x);
iterator
_M_lower_bound(_Link_type __x, _Link_type __y,
const _Key& __k);
const_iterator
_M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
const _Key& __k) const;
iterator
_M_upper_bound(_Link_type __x, _Link_type __y,
const _Key& __k);
const_iterator
_M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
const _Key& __k) const;
public:
_Rb_tree() ;
_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._M_key_compare,
_Alloc_traits::_S_select_on_copy(__x._M_get_Node_allocator()))
{
if (__x._M_root() != 0)
{
_M_root() = _M_copy(__x._M_begin(), _M_end());
_M_leftmost() = _S_minimum(_M_root());
_M_rightmost() = _S_maximum(_M_root());
_M_impl._M_node_count = __x._M_impl._M_node_count;
}
}
_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._M_begin(), _M_end());
_M_leftmost() = _S_minimum(_M_root());
_M_rightmost() = _S_maximum(_M_root());
_M_impl._M_node_count = __x._M_impl._M_node_count;
}
}
_Rb_tree(_Rb_tree&& __x)
: _M_impl(__x._M_impl._M_key_compare, __x._M_get_Node_allocator())
{
if (__x._M_root() != 0)
_M_move_data(__x, std::true_type());
}
_Rb_tree(_Rb_tree&& __x, const allocator_type& __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
;
iterator
begin() noexcept
{
return iterator(static_cast<_Link_type>
(this->_M_impl._M_header._M_left));
}
const_iterator
begin() const noexcept
{
return const_iterator(static_cast<_Const_Link_type>
(this->_M_impl._M_header._M_left));
}
iterator
end() noexcept
{ return iterator(static_cast<_Link_type>(&this->_M_impl._M_header)); }
const_iterator
end() const noexcept
{
return const_iterator(static_cast<_Const_Link_type>
(&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(_Alloc_traits::_S_nothrow_swap());
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)
;
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)
;
template<typename... _Args>
pair<iterator, bool>
_M_emplace_unique(_Args&&... __args);
template<typename... _Args>
iterator
_M_emplace_equal(_Args&&... __args);
template<typename... _Args>
iterator
_M_emplace_hint_unique(const_iterator __pos, _Args&&... __args);
template<typename... _Args>
iterator
_M_emplace_hint_equal(const_iterator __pos, _Args&&... __args);
template<typename _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)
;
__attribute ((__abi_tag__ ("cxx11")))
iterator
erase(iterator __position)
;
size_type
erase(const key_type& __x);
__attribute ((__abi_tag__ ("cxx11")))
iterator
erase(const_iterator __first, const_iterator __last)
;
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)
;
const_iterator
lower_bound(const key_type& __k) const
;
iterator
upper_bound(const key_type& __k)
;
const_iterator
upper_bound(const key_type& __k) const
;
pair<iterator, iterator>
equal_range(const key_type& __k);
pair<const_iterator, const_iterator>
equal_range(const key_type& __k) const;
bool
__rb_verify() const;
_Rb_tree&
operator=(_Rb_tree&&) noexcept(_Alloc_traits::_S_nothrow_move());
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&, std::true_type);
void
_M_move_data(_Rb_tree&, std::false_type);
};
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
bool
operator==(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
bool
operator<(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
bool
operator!=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
bool
operator>(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
bool
operator<=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
bool
operator>=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
void
swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
;
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=(_Rb_tree&& __x)
noexcept(_Alloc_traits::_S_nothrow_move())
{
_M_impl._M_key_compare = __x._M_impl._M_key_compare;
if (_Alloc_traits::_S_propagate_on_move_assign()
|| _Alloc_traits::_S_always_equal()
|| _M_get_Node_allocator() == __x._M_get_Node_allocator())
{
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());
return *this;
}
_Reuse_or_alloc_node __roan(_M_impl._M_header, *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._M_begin(), _M_end(), __lbd);
_M_leftmost() = _S_minimum(_M_root());
_M_rightmost() = _S_maximum(_M_root());
_M_impl._M_node_count = __x._M_impl._M_node_count;
__x.clear();
}
return *this;
}
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
void
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t)
noexcept(_Alloc_traits::_S_nothrow_swap())
{
if (_M_root() == 0)
{
if (__t._M_root() != 0)
{
_M_root() = __t._M_root();
_M_leftmost() = __t._M_leftmost();
_M_rightmost() = __t._M_rightmost();
_M_root()->_M_parent = _M_end();
_M_impl._M_node_count = __t._M_impl._M_node_count;
__t._M_impl._M_reset();
}
}
else if (__t._M_root() == 0)
{
__t._M_root() = _M_root();
__t._M_leftmost() = _M_leftmost();
__t._M_rightmost() = _M_rightmost();
__t._M_root()->_M_parent = __t._M_end();
__t._M_impl._M_node_count = _M_impl._M_node_count;
_M_impl._M_reset();
}
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());
}
__attribute__ ((__pure__)) unsigned int
_Rb_tree_black_count(const _Rb_tree_node_base* __node,
const _Rb_tree_node_base* __root) throw ();
}
#define _STL_MAP_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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:
typedef typename _Alloc::value_type _Alloc_value_type;
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) ;
public:
bool operator()(const value_type& __x, const value_type& __y) const
;
};
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;
map() ;
explicit
map(const _Compare& __comp,
const allocator_type& __a = allocator_type()) ;
map(const map& __x) ;
map(map&& __x)
noexcept(is_nothrow_copy_constructible<_Compare>::value)
: _M_t(std::move(__x._M_t)) { }
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); }
template<typename _InputIterator>
map(_InputIterator __first, _InputIterator __last)
: _M_t()
{ _M_t._M_insert_unique(__first, __last); }
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&
operator=(const map& __x)
{
_M_t = __x._M_t;
return *this;
}
map&
operator=(map&&) = default;
map&
operator=(initializer_list<value_type> __l)
;
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(); }
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;
}
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;
}
template<typename... _Args>
std::pair<iterator, bool>
emplace(_Args&&... __args)
{ return _M_t._M_emplace_unique(std::forward<_Args>(__args)...); }
template<typename... _Args>
iterator
emplace_hint(const_iterator __pos, _Args&&... __args)
{
return _M_t._M_emplace_hint_unique(__pos,
std::forward<_Args>(__args)...);
}
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)); }
void
insert(std::initializer_list<value_type> __list)
{ insert(__list.begin(), __list.end()); }
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)); }
template<typename _InputIterator>
void
insert(_InputIterator __first, _InputIterator __last)
{ _M_t._M_insert_unique(__first, __last); }
iterator
erase(const_iterator __position)
{ return _M_t.erase(__position); }
__attribute ((__abi_tag__ ("cxx11")))
iterator
erase(iterator __position)
{ return _M_t.erase(__position); }
size_type
erase(const key_type& __x)
{ return _M_t.erase(__x); }
iterator
erase(const_iterator __first, const_iterator __last)
{ return _M_t.erase(__first, __last); }
void
swap(map& __x)
noexcept(_Alloc_traits::_S_nothrow_swap())
{ _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()); }
iterator
find(const key_type& __x)
{ return _M_t.find(__x); }
const_iterator
find(const key_type& __x) const
{ return _M_t.find(__x); }
size_type
count(const key_type& __x) const
{ return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
iterator
lower_bound(const key_type& __x)
{ return _M_t.lower_bound(__x); }
const_iterator
lower_bound(const key_type& __x) const
{ return _M_t.lower_bound(__x); }
iterator
upper_bound(const key_type& __x)
{ return _M_t.upper_bound(__x); }
const_iterator
upper_bound(const key_type& __x) const
{ return _M_t.upper_bound(__x); }
std::pair<iterator, iterator>
equal_range(const key_type& __x)
{ return _M_t.equal_range(__x); }
std::pair<const_iterator, const_iterator>
equal_range(const key_type& __x) const
{ return _M_t.equal_range(__x); }
template<typename _K1, typename _T1, typename _C1, typename _A1>
friend bool
operator==(const map<_K1, _T1, _C1, _A1>&,
const map<_K1, _T1, _C1, _A1>&);
template<typename _K1, typename _T1, typename _C1, typename _A1>
friend bool
operator<(const map<_K1, _T1, _C1, _A1>&,
const map<_K1, _T1, _C1, _A1>&);
};
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator==(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator<(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator!=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator>(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator<=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator>=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
void
swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
map<_Key, _Tp, _Compare, _Alloc>& __y)
;
}
#define _STL_MULTIMAP_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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:
typedef typename _Alloc::value_type _Alloc_value_type;
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) ;
public:
bool operator()(const value_type& __x, const value_type& __y) const
;
};
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;
multimap() ;
explicit
multimap(const _Compare& __comp,
const allocator_type& __a = allocator_type()) ;
multimap(const multimap& __x) ;
multimap(multimap&& __x)
noexcept(is_nothrow_copy_constructible<_Compare>::value)
: _M_t(std::move(__x._M_t)) { }
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); }
template<typename _InputIterator>
multimap(_InputIterator __first, _InputIterator __last)
: _M_t()
{ _M_t._M_insert_equal(__first, __last); }
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&
operator=(const multimap& __x)
{
_M_t = __x._M_t;
return *this;
}
multimap&
operator=(multimap&&) = default;
multimap&
operator=(initializer_list<value_type> __l)
;
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(); }
template<typename... _Args>
iterator
emplace(_Args&&... __args)
{ return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); }
template<typename... _Args>
iterator
emplace_hint(const_iterator __pos, _Args&&... __args)
{
return _M_t._M_emplace_hint_equal(__pos,
std::forward<_Args>(__args)...);
}
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)); }
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)); }
template<typename _InputIterator>
void
insert(_InputIterator __first, _InputIterator __last)
{ _M_t._M_insert_equal(__first, __last); }
void
insert(initializer_list<value_type> __l)
{ this->insert(__l.begin(), __l.end()); }
iterator
erase(const_iterator __position)
{ return _M_t.erase(__position); }
__attribute ((__abi_tag__ ("cxx11")))
iterator
erase(iterator __position)
{ return _M_t.erase(__position); }
size_type
erase(const key_type& __x)
{ return _M_t.erase(__x); }
iterator
erase(const_iterator __first, const_iterator __last)
{ return _M_t.erase(__first, __last); }
void
swap(multimap& __x)
noexcept(_Alloc_traits::_S_nothrow_swap())
{ _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()); }
iterator
find(const key_type& __x)
{ return _M_t.find(__x); }
const_iterator
find(const key_type& __x) const
{ return _M_t.find(__x); }
size_type
count(const key_type& __x) const
{ return _M_t.count(__x); }
iterator
lower_bound(const key_type& __x)
{ return _M_t.lower_bound(__x); }
const_iterator
lower_bound(const key_type& __x) const
{ return _M_t.lower_bound(__x); }
iterator
upper_bound(const key_type& __x)
{ return _M_t.upper_bound(__x); }
const_iterator
upper_bound(const key_type& __x) const
{ return _M_t.upper_bound(__x); }
std::pair<iterator, iterator>
equal_range(const key_type& __x)
{ return _M_t.equal_range(__x); }
std::pair<const_iterator, const_iterator>
equal_range(const key_type& __x) const
{ return _M_t.equal_range(__x); }
template<typename _K1, typename _T1, typename _C1, typename _A1>
friend bool
operator==(const multimap<_K1, _T1, _C1, _A1>&,
const multimap<_K1, _T1, _C1, _A1>&);
template<typename _K1, typename _T1, typename _C1, typename _A1>
friend bool
operator<(const multimap<_K1, _T1, _C1, _A1>&,
const multimap<_K1, _T1, _C1, _A1>&);
};
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator==(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator<(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator!=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator<=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator>=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
void
swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
multimap<_Key, _Tp, _Compare, _Alloc>& __y)
;
}
namespace boost {
namespace gregorian {
typedef date_time::months_of_year months_of_year;
using date_time::Jan;
using date_time::Feb;
using date_time::Mar;
using date_time::Apr;
using date_time::May;
using date_time::Jun;
using date_time::Jul;
using date_time::Aug;
using date_time::Sep;
using date_time::Oct;
using date_time::Nov;
using date_time::Dec;
using date_time::NotAMonth;
using date_time::NumMonths;
struct bad_month : public std::out_of_range
{
bad_month() ;
};
typedef CV::simple_exception_policy<unsigned short, 1, 12, bad_month> greg_month_policies;
typedef CV::constrained_value<greg_month_policies> greg_month_rep;
class greg_month : public greg_month_rep {
public:
typedef date_time::months_of_year month_enum;
typedef std::map<std::string, unsigned short> month_map_type;
typedef boost::shared_ptr<month_map_type> month_map_ptr_type;
greg_month(month_enum theMonth) ;
greg_month(unsigned short theMonth) ;
operator unsigned short() const ;
unsigned short as_number() const ;
month_enum as_enum() const ;
const char* as_short_string() const;
const char* as_long_string() const;
const wchar_t* as_short_wstring() const;
const wchar_t* as_long_wstring() const;
static month_map_ptr_type get_month_map_ptr();
const char* as_short_string(char) const
;
const char* as_long_string(char) const
;
const wchar_t* as_short_string(wchar_t) const
;
const wchar_t* as_long_string(wchar_t) const
;
};
} }
namespace boost {
namespace gregorian {
typedef date_time::year_month_day_base<greg_year,
greg_month,
greg_day> greg_year_month_day;
} }
namespace boost {
namespace gregorian {
typedef date_time::int_adapter<uint32_t> fancy_date_rep;
class gregorian_calendar :
public date_time::gregorian_calendar_base<greg_year_month_day, fancy_date_rep::int_type> {
public:
typedef greg_weekday day_of_week_type;
typedef greg_day_of_year_rep day_of_year_type;
typedef fancy_date_rep date_rep_type;
typedef fancy_date_rep date_traits_type;
private:
};
} }
#define GREG_DURATION_HPP___
#define DATE_TIME_DATE_DURATION__
namespace boost {
namespace date_time {
template<class duration_rep_traits>
class date_duration : private
boost::less_than_comparable1< date_duration< duration_rep_traits >
, boost::equality_comparable1< date_duration< duration_rep_traits >
, boost::addable1< date_duration< duration_rep_traits >
, boost::subtractable1< date_duration< duration_rep_traits >
, boost::dividable2< date_duration< duration_rep_traits >, int
> > > > >
{
public:
typedef typename duration_rep_traits::int_type duration_rep_type;
typedef typename duration_rep_traits::impl_type duration_rep;
explicit date_duration(duration_rep day_count) ;
date_duration(special_values sv)
;
date_duration(const date_duration<duration_rep_traits>& other)
;
duration_rep get_rep()const
;
bool is_special()const
;
duration_rep_type days() const
;
static date_duration unit()
;
bool operator==(const date_duration& rhs) const
;
bool operator<(const date_duration& rhs) const
;
date_duration& operator-=(const date_duration& rhs)
;
date_duration& operator+=(const date_duration& rhs)
;
date_duration operator-() const
;
date_duration& operator/=(int divisor)
;
bool is_negative() const
;
private:
duration_rep days_;
};
struct duration_traits_long
{
typedef long int_type;
typedef long impl_type;
static int_type as_number(impl_type i) ;
};
struct duration_traits_adapted
{
typedef long int_type;
typedef boost::date_time::int_adapter<long> impl_type;
static int_type as_number(impl_type i) ;
};
} }
namespace boost {
namespace gregorian {
typedef boost::date_time::duration_traits_adapted date_duration_rep;
class date_duration :
public boost::date_time::date_duration< date_duration_rep >
{
typedef boost::date_time::date_duration< date_duration_rep > base_type;
public:
typedef base_type::duration_rep duration_rep;
explicit date_duration(duration_rep day_count = 0) ;
date_duration(date_time::special_values sv) ;
date_duration(const date_duration& other)
;
date_duration(const base_type& other)
;
bool operator== (const date_duration& rhs) const
;
bool operator!= (const date_duration& rhs) const
;
bool operator< (const date_duration& rhs) const
;
bool operator> (const date_duration& rhs) const
;
bool operator<= (const date_duration& rhs) const
;
bool operator>= (const date_duration& rhs) const
;
date_duration& operator-= (const date_duration& rhs)
;
friend date_duration operator- (date_duration rhs, date_duration const& lhs)
;
date_duration& operator+= (const date_duration& rhs)
;
friend date_duration operator+ (date_duration rhs, date_duration const& lhs)
;
date_duration operator- ()const
;
date_duration& operator/= (int divisor)
;
friend date_duration operator/ (date_duration rhs, int lhs)
;
static date_duration unit()
;
};
typedef date_duration days;
} }
#define DATE_DURATION_TYPES_HPP___
namespace boost {
namespace date_time {
template <class duration_config>
class weeks_duration : public date_duration<duration_config> {
public:
weeks_duration(typename duration_config::impl_type w) ;
weeks_duration(special_values sv) ;
};
template<class t>
class years_duration;
template<class base_config>
class months_duration
{
private:
typedef typename base_config::int_rep int_rep;
typedef typename int_rep::int_type int_type;
typedef typename base_config::date_type date_type;
typedef typename date_type::duration_type duration_type;
typedef typename base_config::month_adjustor_type month_adjustor_type;
typedef months_duration<base_config> months_type;
typedef years_duration<base_config> years_type;
public:
months_duration(int_rep num) ;
months_duration(special_values sv)
;
int_rep number_of_months() const ;
duration_type get_neg_offset(const date_type& d) const
;
duration_type get_offset(const date_type& d) const
;
bool operator==(const months_type& rhs) const
;
bool operator!=(const months_type& rhs) const
;
months_type operator+(const months_type& rhs)const
;
months_type& operator+=(const months_type& rhs)
;
months_type operator-(const months_type& rhs)const
;
months_type& operator-=(const months_type& rhs)
;
months_type operator*(const int_type rhs)const
;
months_type& operator*=(const int_type rhs)
;
months_type operator/(const int_type rhs)const
;
months_type& operator/=(const int_type rhs)
;
months_type operator+(const years_type& y)const
;
months_type& operator+=(const years_type& y)
;
months_type operator-(const years_type& y) const
;
months_type& operator-=(const years_type& y)
;
friend date_type operator+(const date_type& d, const months_type& m)
;
friend date_type operator+=(date_type& d, const months_type& m)
;
friend date_type operator-(const date_type& d, const months_type& m)
;
friend date_type operator-=(date_type& d, const months_type& m)
;
private:
int_rep _m;
};
template<class base_config>
class years_duration
{
private:
typedef typename base_config::int_rep int_rep;
typedef typename int_rep::int_type int_type;
typedef typename base_config::date_type date_type;
typedef typename date_type::duration_type duration_type;
typedef typename base_config::month_adjustor_type month_adjustor_type;
typedef years_duration<base_config> years_type;
typedef months_duration<base_config> months_type;
public:
years_duration(int_rep num) ;
years_duration(special_values sv)
;
int_rep number_of_years() const ;
duration_type get_neg_offset(const date_type& d) const
;
duration_type get_offset(const date_type& d) const
;
bool operator==(const years_type& rhs) const
;
bool operator!=(const years_type& rhs) const
;
years_type operator+(const years_type& rhs)const
;
years_type& operator+=(const years_type& rhs)
;
years_type operator-(const years_type& rhs)const
;
years_type& operator-=(const years_type& rhs)
;
years_type operator*(const int_type rhs)const
;
years_type& operator*=(const int_type rhs)
;
years_type operator/(const int_type rhs)const
;
years_type& operator/=(const int_type rhs)
;
months_type operator+(const months_type& m) const
;
months_type operator-(const months_type& m) const
;
friend date_type operator+(const date_type& d, const years_type& y)
;
friend date_type operator+=(date_type& d, const years_type& y)
;
friend date_type operator-(const date_type& d, const years_type& y)
;
friend date_type operator-=(date_type& d, const years_type& y)
;
private:
int_rep _y;
};
}}
#define GREG_DURATION_TYPES_HPP___
#define GREG_DATE_HPP___
namespace boost {
namespace gregorian {
using date_time::special_values;
using date_time::not_special;
using date_time::neg_infin;
using date_time::pos_infin;
using date_time::not_a_date_time;
using date_time::max_date_time;
using date_time::min_date_time;
class date : public date_time::date<date, gregorian_calendar, date_duration>
{
public:
typedef gregorian_calendar::year_type year_type;
typedef gregorian_calendar::month_type month_type;
typedef gregorian_calendar::day_type day_type;
typedef gregorian_calendar::day_of_year_type day_of_year_type;
typedef gregorian_calendar::ymd_type ymd_type;
typedef gregorian_calendar::date_rep_type date_rep_type;
typedef gregorian_calendar::date_int_type date_int_type;
typedef date_duration duration_type;
date()
;
date(year_type y, month_type m, day_type d)
;
explicit date(const ymd_type& ymd)
;
explicit date(const date_int_type& rhs)
;
explicit date(date_rep_type rhs)
;
explicit date(special_values sv)
;
date_int_type julian_day() const
;
day_of_year_type day_of_year() const
;
date_int_type modjulian_day() const
;
int week_number() const
;
date_int_type day_number() const
;
date end_of_month() const
;
private:
};
} }
#define _DATE_TIME_ADJUST_FUNCTORS_HPP___
#define _DATE_TIME_WRAPPING_INT_HPP__
namespace boost {
namespace date_time {
template<typename int_type_, int_type_ wrap_val>
class wrapping_int {
public:
typedef int_type_ int_type;
static int_type wrap_value() ;
wrapping_int(int_type v) ;
int_type as_int() const ;
operator int_type() const ;
template< typename IntT >
IntT add(IntT v)
;
template< typename IntT >
IntT subtract(IntT v)
;
private:
int_type value_;
template< typename IntT >
IntT calculate_wrap(IntT wrap)
;
};
template<typename int_type_, int_type_ wrap_min, int_type_ wrap_max>
class wrapping_int2 {
public:
typedef int_type_ int_type;
static int_type wrap_value() ;
static int_type min_value() ;
wrapping_int2(int_type v) ;
int_type as_int() const ;
operator int_type() const ;
template< typename IntT >
IntT add(IntT v)
;
template< typename IntT >
IntT subtract(IntT v)
;
private:
int_type value_;
template< typename IntT >
IntT calculate_wrap(IntT wrap)
;
};
} }
namespace boost {
namespace date_time {
template<class date_type>
class day_functor
{
public:
typedef typename date_type::duration_type duration_type;
day_functor(int f) ;
duration_type get_offset(const date_type& d) const
;
duration_type get_neg_offset(const date_type& d) const
;
private:
int f_;
};
template<class date_type>
class month_functor
{
public:
typedef typename date_type::duration_type duration_type;
typedef typename date_type::calendar_type cal_type;
typedef typename cal_type::ymd_type ymd_type;
typedef typename cal_type::day_type day_type;
month_functor(int f) ;
duration_type get_offset(const date_type& d) const
;
duration_type get_neg_offset(const date_type& d) const
;
private:
int f_;
mutable short origDayOfMonth_;
};
template<class date_type>
class week_functor
{
public:
typedef typename date_type::duration_type duration_type;
typedef typename date_type::calendar_type calendar_type;
week_functor(int f) ;
duration_type get_offset(const date_type& d) const
;
duration_type get_neg_offset(const date_type& d) const
;
private:
int f_;
};
template<class date_type>
class year_functor
{
public:
typedef typename date_type::duration_type duration_type;
year_functor(int f) ;
duration_type get_offset(const date_type& d) const
;
duration_type get_neg_offset(const date_type& d) const
;
private:
month_functor<date_type> _mf;
};
} }
namespace boost {
namespace gregorian {
struct greg_durations_config {
typedef date date_type;
typedef date_time::int_adapter<int> int_rep;
typedef date_time::month_functor<date_type> month_adjustor_type;
};
typedef date_time::months_duration<greg_durations_config> months;
typedef date_time::years_duration<greg_durations_config> years;
class weeks_duration : public date_duration {
public:
weeks_duration(duration_rep w) ;
weeks_duration(date_time::special_values sv) ;
};
typedef weeks_duration weeks;
}}
#define DATE_TIME_DATE_GENERATORS_HPP__
#define _GLIBCXX_SSTREAM 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits, typename _Alloc>
class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef _Alloc allocator_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef basic_streambuf<char_type, traits_type> __streambuf_type;
typedef basic_string<char_type, _Traits, _Alloc> __string_type;
typedef typename __string_type::size_type __size_type;
protected:
ios_base::openmode _M_mode;
__string_type _M_string;
public:
explicit
basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
;
explicit
basic_stringbuf(const __string_type& __str,
ios_base::openmode __mode = ios_base::in | ios_base::out)
;
basic_stringbuf(const basic_stringbuf&) = delete;
basic_stringbuf(basic_stringbuf&& __rhs)
;
basic_stringbuf&
operator=(const basic_stringbuf&) = delete;
basic_stringbuf&
operator=(basic_stringbuf&& __rhs)
;
void
swap(basic_stringbuf& __rhs)
;
__string_type
str() const
;
void
str(const __string_type& __s)
;
protected:
void
_M_stringbuf_init(ios_base::openmode __mode)
;
virtual streamsize
showmanyc()
;
virtual int_type
underflow();
virtual int_type
pbackfail(int_type __c = traits_type::eof());
virtual int_type
overflow(int_type __c = traits_type::eof());
virtual __streambuf_type*
setbuf(char_type* __s, streamsize __n)
;
virtual pos_type
seekoff(off_type __off, ios_base::seekdir __way,
ios_base::openmode __mode = ios_base::in | ios_base::out);
virtual pos_type
seekpos(pos_type __sp,
ios_base::openmode __mode = ios_base::in | ios_base::out);
void
_M_sync(char_type* __base, __size_type __i, __size_type __o);
void
_M_update_egptr()
;
void
_M_pbump(char_type* __pbeg, char_type* __pend, off_type __off);
};
template<typename _CharT, typename _Traits, typename _Alloc>
class basic_istringstream : public basic_istream<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef _Alloc allocator_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
typedef basic_istream<char_type, traits_type> __istream_type;
private:
__stringbuf_type _M_stringbuf;
public:
explicit
basic_istringstream(ios_base::openmode __mode = ios_base::in)
;
explicit
basic_istringstream(const __string_type& __str,
ios_base::openmode __mode = ios_base::in)
;
~basic_istringstream()
;
basic_istringstream(const basic_istringstream&) = delete;
basic_istringstream(basic_istringstream&& __rhs)
;
basic_istringstream&
operator=(const basic_istringstream&) = delete;
basic_istringstream&
operator=(basic_istringstream&& __rhs)
;
void
swap(basic_istringstream& __rhs)
;
__stringbuf_type*
rdbuf() const
;
__string_type
str() const
;
void
str(const __string_type& __s)
;
};
template <typename _CharT, typename _Traits, typename _Alloc>
class basic_ostringstream : public basic_ostream<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef _Alloc allocator_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
typedef basic_ostream<char_type, traits_type> __ostream_type;
private:
__stringbuf_type _M_stringbuf;
public:
explicit
basic_ostringstream(ios_base::openmode __mode = ios_base::out)
;
explicit
basic_ostringstream(const __string_type& __str,
ios_base::openmode __mode = ios_base::out)
;
~basic_ostringstream()
;
basic_ostringstream(const basic_ostringstream&) = delete;
basic_ostringstream(basic_ostringstream&& __rhs)
;
basic_ostringstream&
operator=(const basic_ostringstream&) = delete;
basic_ostringstream&
operator=(basic_ostringstream&& __rhs)
;
void
swap(basic_ostringstream& __rhs)
;
__stringbuf_type*
rdbuf() const
;
__string_type
str() const
;
void
str(const __string_type& __s)
;
};
template <typename _CharT, typename _Traits, typename _Alloc>
class basic_stringstream : public basic_iostream<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef _Alloc allocator_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
typedef basic_iostream<char_type, traits_type> __iostream_type;
private:
__stringbuf_type _M_stringbuf;
public:
explicit
basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
;
explicit
basic_stringstream(const __string_type& __str,
ios_base::openmode __m = ios_base::out | ios_base::in)
;
~basic_stringstream()
;
basic_stringstream(const basic_stringstream&) = delete;
basic_stringstream(basic_stringstream&& __rhs)
;
basic_stringstream&
operator=(const basic_stringstream&) = delete;
basic_stringstream&
operator=(basic_stringstream&& __rhs)
;
void
swap(basic_stringstream& __rhs)
;
__stringbuf_type*
rdbuf() const
;
__string_type
str() const
;
void
str(const __string_type& __s)
;
};
template <class _CharT, class _Traits, class _Allocator>
void
swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x,
basic_stringbuf<_CharT, _Traits, _Allocator>& __y)
;
template <class _CharT, class _Traits, class _Allocator>
void
swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x,
basic_istringstream<_CharT, _Traits, _Allocator>& __y)
;
template <class _CharT, class _Traits, class _Allocator>
void
swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x,
basic_ostringstream<_CharT, _Traits, _Allocator>& __y)
;
template <class _CharT, class _Traits, class _Allocator>
void
swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x,
basic_stringstream<_CharT, _Traits, _Allocator>& __y)
;
}
#define _SSTREAM_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
extern template class basic_stringbuf<char>;
extern template class basic_istringstream<char>;
extern template class basic_ostringstream<char>;
extern template class basic_stringstream<char>;
extern template class basic_stringbuf<wchar_t>;
extern template class basic_istringstream<wchar_t>;
extern template class basic_ostringstream<wchar_t>;
extern template class basic_stringstream<wchar_t>;
}
namespace boost {
namespace date_time {
template<class date_type>
class year_based_generator
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::year_type year_type;
year_based_generator() ;
virtual ~year_based_generator() ;
virtual date_type get_date(year_type y) const = 0;
virtual std::string to_string() const =0;
};
template<class date_type>
class partial_date : public year_based_generator<date_type>
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_type day_type;
typedef typename calendar_type::month_type month_type;
typedef typename calendar_type::year_type year_type;
typedef typename date_type::duration_type duration_type;
typedef typename duration_type::duration_rep duration_rep;
partial_date(day_type d, month_type m)
;
partial_date(duration_rep days)
;
date_type get_date(year_type y) const
;
date_type operator()(year_type y) const
;
bool operator==(const partial_date& rhs) const
;
bool operator<(const partial_date& rhs) const
;
month_type month() const
;
day_type day() const
;
virtual std::string to_string() const
;
private:
day_type day_;
month_type month_;
};
const char* nth_as_str(int n);
template<class date_type>
class nth_kday_of_month : public year_based_generator<date_type>
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_of_week_type day_of_week_type;
typedef typename calendar_type::month_type month_type;
typedef typename calendar_type::year_type year_type;
typedef typename date_type::duration_type duration_type;
enum week_num {first=1, second, third, fourth, fifth};
nth_kday_of_month(week_num week_no,
day_of_week_type dow,
month_type m)
;
date_type get_date(year_type y) const
;
month_type month() const
;
week_num nth_week() const
;
day_of_week_type day_of_week() const
;
const char* nth_week_as_str() const
;
virtual std::string to_string() const
;
private:
month_type month_;
week_num wn_;
day_of_week_type dow_;
};
template<class date_type>
class first_kday_of_month : public year_based_generator<date_type>
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_of_week_type day_of_week_type;
typedef typename calendar_type::month_type month_type;
typedef typename calendar_type::year_type year_type;
typedef typename date_type::duration_type duration_type;
first_kday_of_month(day_of_week_type dow, month_type m)
;
date_type get_date(year_type year) const
;
month_type month() const
;
day_of_week_type day_of_week() const
;
virtual std::string to_string() const
;
private:
month_type month_;
day_of_week_type dow_;
};
template<class date_type>
class last_kday_of_month : public year_based_generator<date_type>
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_of_week_type day_of_week_type;
typedef typename calendar_type::month_type month_type;
typedef typename calendar_type::year_type year_type;
typedef typename date_type::duration_type duration_type;
last_kday_of_month(day_of_week_type dow, month_type m)
;
date_type get_date(year_type year) const
;
month_type month() const
;
day_of_week_type day_of_week() const
;
virtual std::string to_string() const
;
private:
month_type month_;
day_of_week_type dow_;
};
template<class date_type>
class first_kday_after
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_of_week_type day_of_week_type;
typedef typename date_type::duration_type duration_type;
first_kday_after(day_of_week_type dow)
;
date_type get_date(date_type start_day) const
;
day_of_week_type day_of_week() const
;
private:
day_of_week_type dow_;
};
template<class date_type>
class first_kday_before
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_of_week_type day_of_week_type;
typedef typename date_type::duration_type duration_type;
first_kday_before(day_of_week_type dow)
;
date_type get_date(date_type start_day) const
;
day_of_week_type day_of_week() const
;
private:
day_of_week_type dow_;
};
template<typename date_type, class weekday_type>
typename date_type::duration_type days_until_weekday(const date_type& d, const weekday_type& wd)
;
template<typename date_type, class weekday_type>
typename date_type::duration_type days_before_weekday(const date_type& d, const weekday_type& wd)
;
template<class date_type, class weekday_type>
date_type next_weekday(const date_type& d, const weekday_type& wd)
;
template<class date_type, class weekday_type>
date_type previous_weekday(const date_type& d, const weekday_type& wd)
;
} }
#define DATE_CLOCK_DEVICE_HPP___
namespace boost {
namespace date_time {
template<class date_type>
class day_clock
{
public:
typedef typename date_type::ymd_type ymd_type;
static date_type local_day()
;
static typename date_type::ymd_type local_day_ymd()
;
static typename date_type::ymd_type universal_day_ymd()
;
static date_type universal_day()
;
private:
static ::std::tm* get_local_time(std::tm& result)
;
static ::std::tm* get_universal_time(std::tm& result)
;
};
} }
#define DATE_ITERATOR_HPP___
namespace boost {
namespace date_time {
enum date_resolutions {day, week, months, year, decade, century, NumDateResolutions};
template<class date_type>
class date_itr_base {
public:
typedef typename date_type::duration_type duration_type;
typedef date_type value_type;
typedef std::input_iterator_tag iterator_category;
date_itr_base(date_type d) ;
virtual ~date_itr_base() ;
date_itr_base& operator++()
;
date_itr_base& operator--()
;
virtual duration_type get_offset(const date_type& current) const=0;
virtual duration_type get_neg_offset(const date_type& current) const=0;
date_type operator*() ;
date_type* operator->() ;
bool operator< (const date_type& d) ;
bool operator<= (const date_type& d) ;
bool operator> (const date_type& d) ;
bool operator>= (const date_type& d) ;
bool operator== (const date_type& d) ;
bool operator!= (const date_type& d) ;
private:
date_type current_;
};
template<class offset_functor, class date_type>
class date_itr : public date_itr_base<date_type> {
public:
typedef typename date_type::duration_type duration_type;
date_itr(date_type d, int factor=1)
;
private:
virtual duration_type get_offset(const date_type& current) const
;
virtual duration_type get_neg_offset(const date_type& current) const
;
offset_functor of_;
};
} }
namespace boost {
namespace gregorian {
typedef date_time::period<date, date_duration> date_period;
typedef date_time::year_based_generator<date> year_based_generator;
typedef date_time::partial_date<date> partial_date;
typedef date_time::nth_kday_of_month<date> nth_kday_of_month;
typedef nth_kday_of_month nth_day_of_the_week_in_month;
typedef date_time::first_kday_of_month<date> first_kday_of_month;
typedef first_kday_of_month first_day_of_the_week_in_month;
typedef date_time::last_kday_of_month<date> last_kday_of_month;
typedef last_kday_of_month last_day_of_the_week_in_month;
typedef date_time::first_kday_after<date> first_kday_after;
typedef first_kday_after first_day_of_the_week_after;
typedef date_time::first_kday_before<date> first_kday_before;
typedef first_kday_before first_day_of_the_week_before;
typedef date_time::day_clock<date> day_clock;
typedef date_time::date_itr_base<date> date_iterator;
typedef date_time::date_itr<date_time::day_functor<date>,
date> day_iterator;
typedef date_time::date_itr<date_time::week_functor<date>,
date> week_iterator;
typedef date_time::date_itr<date_time::month_functor<date>,
date> month_iterator;
typedef date_time::date_itr<date_time::year_functor<date>,
date> year_iterator;
using date_time::days_until_weekday;
using date_time::days_before_weekday;
using date_time::next_weekday;
using date_time::previous_weekday;
} }
namespace boost {
namespace posix_time {
#define BOOST_DATE_TIME_HAS_MILLISECONDS
#define BOOST_DATE_TIME_HAS_MICROSECONDS
#undef BOOST_DATE_TIME_HAS_NANOSECONDS
typedef date_time::time_resolution_traits<
boost::date_time::time_resolution_traits_adapted64_impl, boost::date_time::micro,
1000000, 6 > time_res_traits;
class time_duration :
public date_time::time_duration<time_duration, time_res_traits>
{
public:
typedef time_res_traits rep_type;
typedef time_res_traits::day_type day_type;
typedef time_res_traits::hour_type hour_type;
typedef time_res_traits::min_type min_type;
typedef time_res_traits::sec_type sec_type;
typedef time_res_traits::fractional_seconds_type fractional_seconds_type;
typedef time_res_traits::tick_type tick_type;
typedef time_res_traits::impl_type impl_type;
time_duration(hour_type hour,
min_type min,
sec_type sec,
fractional_seconds_type fs=0)
;
time_duration()
;
time_duration(boost::date_time::special_values sv)
;
friend class date_time::time_duration<time_duration, time_res_traits>;
protected:
explicit time_duration(impl_type tick_count)
;
};
class millisec_posix_time_system_config
{
public:
typedef boost::int64_t time_rep_type;
typedef gregorian::date date_type;
typedef gregorian::date_duration date_duration_type;
typedef time_duration time_duration_type;
typedef time_res_traits::tick_type int_type;
typedef time_res_traits::impl_type impl_type;
typedef time_res_traits resolution_traits;
static const boost::int64_t tick_per_second = 1000000;
};
} }
#define DATE_TIME_TIME_SYSTEM_SPLIT_HPP
namespace boost {
namespace date_time {
template<typename config>
class split_timedate_system
{
public:
typedef typename config::time_rep_type time_rep_type;
typedef typename config::date_type date_type;
typedef typename config::time_duration_type time_duration_type;
typedef typename config::date_duration_type date_duration_type;
typedef typename config::int_type int_type;
typedef typename config::resolution_traits resolution_traits;
private:
static const int_type ticks_per_day = 86400L * config::tick_per_second;
public:
typedef date_time::wrapping_int<int_type, ticks_per_day> wrap_int_type;
static time_rep_type get_time_rep(special_values sv)
;
static time_rep_type get_time_rep(const date_type& day,
const time_duration_type& tod,
date_time::dst_flags = not_dst)
;
static date_type get_date(const time_rep_type& val)
;
static time_duration_type get_time_of_day(const time_rep_type& val)
;
static std::string zone_name(const time_rep_type&)
;
static bool is_equal(const time_rep_type& lhs, const time_rep_type& rhs)
;
static bool is_less(const time_rep_type& lhs, const time_rep_type& rhs)
;
static time_rep_type add_days(const time_rep_type& base,
const date_duration_type& dd)
;
static time_rep_type subtract_days(const time_rep_type& base,
const date_duration_type& dd)
;
static time_rep_type subtract_time_duration(const time_rep_type& base,
const time_duration_type& td)
;
static time_rep_type add_time_duration(const time_rep_type& base,
time_duration_type td)
;
static time_duration_type subtract_times(const time_rep_type& lhs,
const time_rep_type& rhs)
;
};
} }
#define DATE_TIME_TIME_SYSTEM_COUNTED_HPP
namespace boost {
namespace date_time {
template<class config>
struct counted_time_rep
{
typedef typename config::int_type int_type;
typedef typename config::date_type date_type;
typedef typename config::impl_type impl_type;
typedef typename date_type::duration_type date_duration_type;
typedef typename date_type::calendar_type calendar_type;
typedef typename date_type::ymd_type ymd_type;
typedef typename config::time_duration_type time_duration_type;
typedef typename config::resolution_traits resolution_traits;
counted_time_rep(const date_type& d, const time_duration_type& time_of_day)
;
explicit counted_time_rep(int_type count)
;
explicit counted_time_rep(impl_type count)
;
date_type date() const
;
unsigned long day_count() const
;
int_type time_count() const
;
int_type tod() const
;
static int_type frac_sec_per_day()
;
bool is_pos_infinity()const
;
bool is_neg_infinity()const
;
bool is_not_a_date_time()const
;
bool is_special()const
;
impl_type get_rep()const
;
private:
impl_type time_count_;
};
template<class time_rep>
class counted_time_system
{
public:
typedef time_rep time_rep_type;
typedef typename time_rep_type::impl_type impl_type;
typedef typename time_rep_type::time_duration_type time_duration_type;
typedef typename time_duration_type::fractional_seconds_type fractional_seconds_type;
typedef typename time_rep_type::date_type date_type;
typedef typename time_rep_type::date_duration_type date_duration_type;
template<class T> static void unused_var(const T&) ;
static time_rep_type get_time_rep(const date_type& day,
const time_duration_type& tod,
date_time::dst_flags dst=not_dst)
;
static time_rep_type get_time_rep(special_values sv)
;
static date_type get_date(const time_rep_type& val)
;
static time_duration_type get_time_of_day(const time_rep_type& val)
;
static std::string zone_name(const time_rep_type&)
;
static bool is_equal(const time_rep_type& lhs, const time_rep_type& rhs)
;
static bool is_less(const time_rep_type& lhs, const time_rep_type& rhs)
;
static time_rep_type add_days(const time_rep_type& base,
const date_duration_type& dd)
;
static time_rep_type subtract_days(const time_rep_type& base,
const date_duration_type& dd)
;
static time_rep_type subtract_time_duration(const time_rep_type& base,
const time_duration_type& td)
;
static time_rep_type add_time_duration(const time_rep_type& base,
time_duration_type td)
;
static time_duration_type subtract_times(const time_rep_type& lhs,
const time_rep_type& rhs)
;
};
} }
namespace boost {
namespace posix_time {
typedef date_time::counted_time_rep<millisec_posix_time_system_config> int64_time_rep;
typedef date_time::counted_time_system<int64_time_rep> posix_time_system;
} }
#define DATE_TIME_TIME_HPP___
namespace boost {
namespace date_time {
template <class T, class time_system>
class base_time : private
boost::less_than_comparable<T
, boost::equality_comparable<T
> >
{
public:
typedef T time_type;
typedef typename time_system::time_rep_type time_rep_type;
typedef typename time_system::date_type date_type;
typedef typename time_system::date_duration_type date_duration_type;
typedef typename time_system::time_duration_type time_duration_type;
base_time(const date_type& day,
const time_duration_type& td,
dst_flags dst=not_dst)
;
base_time(special_values sv)
;
base_time(const time_rep_type& rhs)
;
date_type date() const
;
time_duration_type time_of_day() const
;
std::string zone_name(bool =false) const
;
std::string zone_abbrev(bool =false) const
;
std::string zone_as_posix_string() const
;
bool is_not_a_date_time() const
;
bool is_infinity() const
;
bool is_pos_infinity() const
;
bool is_neg_infinity() const
;
bool is_special() const
;
bool operator==(const time_type& rhs) const
;
bool operator<(const time_type& rhs) const
;
time_duration_type operator-(const time_type& rhs) const
;
time_type operator+(const date_duration_type& dd) const
;
time_type operator+=(const date_duration_type& dd)
;
time_type operator-(const date_duration_type& dd) const
;
time_type operator-=(const date_duration_type& dd)
;
time_type operator+(const time_duration_type& td) const
;
time_type operator+=(const time_duration_type& td)
;
time_type operator-(const time_duration_type& rhs) const
;
time_type operator-=(const time_duration_type& td)
;
protected:
time_rep_type time_;
};
} }
namespace boost {
namespace posix_time {
using date_time::special_values;
using date_time::not_special;
using date_time::neg_infin;
using date_time::pos_infin;
using date_time::not_a_date_time;
using date_time::max_date_time;
using date_time::min_date_time;
class ptime : public date_time::base_time<ptime, posix_time_system>
{
public:
typedef posix_time_system time_system_type;
typedef time_system_type::time_rep_type time_rep_type;
typedef time_system_type::time_duration_type time_duration_type;
typedef ptime time_type;
ptime(gregorian::date d,time_duration_type td)
;
explicit ptime(gregorian::date d)
;
ptime(const time_rep_type& rhs)
;
ptime(const special_values sv)
;
ptime()
;
};
} }
#define DATE_DURATION_OPERATORS_HPP___
namespace boost {
namespace posix_time {
ptime
operator+(const ptime& t, const boost::gregorian::months& m)
;
ptime
operator+=(ptime& t, const boost::gregorian::months& m)
;
ptime
operator-(const ptime& t, const boost::gregorian::months& m)
;
ptime
operator-=(ptime& t, const boost::gregorian::months& m)
;
ptime
operator+(const ptime& t, const boost::gregorian::years& y)
;
ptime
operator+=(ptime& t, const boost::gregorian::years& y)
;
ptime
operator-(const ptime& t, const boost::gregorian::years& y)
;
ptime
operator-=(ptime& t, const boost::gregorian::years& y)
;
}}
#define POSIX_TIME_DURATION_HPP___
namespace boost {
namespace posix_time {
class hours : public time_duration
{
public:
explicit hours(long h)
;
};
class minutes : public time_duration
{
public:
explicit minutes(long m)
;
};
class seconds : public time_duration
{
public:
explicit seconds(long s)
;
};
typedef date_time::subsecond_duration<time_duration,1000> millisec;
typedef date_time::subsecond_duration<time_duration,1000> milliseconds;
typedef date_time::subsecond_duration<time_duration,1000000> microsec;
typedef date_time::subsecond_duration<time_duration,1000000> microseconds;
} }
#define POSIX_TIME_PERIOD_HPP___
namespace boost {
namespace posix_time {
typedef date_time::period<ptime, time_duration> time_period;
} }
#define DATE_TIME_TIME_ITERATOR_HPP___
namespace boost {
namespace date_time {
template<class time_type>
class time_itr {
public:
typedef typename time_type::time_duration_type time_duration_type;
time_itr(time_type t, time_duration_type d) ;
time_itr& operator++()
;
time_itr& operator--()
;
time_type operator*() ;
time_type* operator->() ;
bool operator< (const time_type& t) ;
bool operator<= (const time_type& t) ;
bool operator!= (const time_type& t) ;
bool operator== (const time_type& t) ;
bool operator> (const time_type& t) ;
bool operator>= (const time_type& t) ;
private:
time_type current_;
time_duration_type offset_;
};
} }
#define DATE_TIME_DST_RULES_HPP__
namespace boost {
namespace date_time {
enum time_is_dst_result {is_not_in_dst, is_in_dst,
ambiguous, invalid_time_label};
template<class date_type_,
class time_duration_type_>
class dst_calculator
{
public:
typedef time_duration_type_ time_duration_type;
typedef date_type_ date_type;
static time_is_dst_result
process_local_dst_start_day(const time_duration_type& time_of_day,
unsigned int dst_start_offset_minutes,
long dst_length_minutes)
;
static time_is_dst_result
process_local_dst_end_day(const time_duration_type& time_of_day,
unsigned int dst_end_offset_minutes,
long dst_length_minutes)
;
static time_is_dst_result
local_is_dst(const date_type& current_day,
const time_duration_type& time_of_day,
const date_type& dst_start_day,
const time_duration_type& dst_start_offset,
const date_type& dst_end_day,
const time_duration_type& dst_end_offset,
const time_duration_type& dst_length_minutes)
;
static time_is_dst_result
local_is_dst(const date_type& current_day,
const time_duration_type& time_of_day,
const date_type& dst_start_day,
unsigned int dst_start_offset_minutes,
const date_type& dst_end_day,
unsigned int dst_end_offset_minutes,
long dst_length_minutes)
;
};
template<class date_type,
class time_duration_type,
class dst_traits>
class dst_calc_engine
{
public:
typedef typename date_type::year_type year_type;
typedef typename date_type::calendar_type calendar_type;
typedef dst_calculator<date_type, time_duration_type> dstcalc;
static time_is_dst_result local_is_dst(const date_type& d,
const time_duration_type& td)
;
static bool is_dst_boundary_day(date_type d)
;
static time_duration_type dst_offset()
;
static date_type local_dst_start_day(year_type year)
;
static date_type local_dst_end_day(year_type year)
;
};
template<class date_type_,
class time_duration_type_,
unsigned int dst_start_offset_minutes=120,
short dst_length_minutes=60>
class us_dst_rules
{
public:
typedef time_duration_type_ time_duration_type;
typedef date_type_ date_type;
typedef typename date_type::year_type year_type;
typedef typename date_type::calendar_type calendar_type;
typedef date_time::last_kday_of_month<date_type> lkday;
typedef date_time::first_kday_of_month<date_type> fkday;
typedef date_time::nth_kday_of_month<date_type> nkday;
typedef dst_calculator<date_type, time_duration_type> dstcalc;
static time_is_dst_result local_is_dst(const date_type& d,
const time_duration_type& td)
;
static bool is_dst_boundary_day(date_type d)
;
static date_type local_dst_start_day(year_type year)
;
static date_type local_dst_end_day(year_type year)
;
static time_duration_type dst_offset()
;
private:
};
template<class date_type_, class time_duration_type_>
class null_dst_rules
{
public:
typedef time_duration_type_ time_duration_type;
typedef date_type_ date_type;
static time_is_dst_result local_is_dst(const date_type&,
const time_duration_type&)
;
static time_is_dst_result utc_is_dst(const date_type&,
const time_duration_type&)
;
static bool is_dst_boundary_day(date_type )
;
static time_duration_type dst_offset()
;
};
} }
namespace boost {
namespace posix_time {
typedef date_time::time_itr<ptime> time_iterator;
typedef date_time::second_clock<ptime> second_clock;
typedef date_time::microsec_clock<ptime> microsec_clock;
typedef date_time::null_dst_rules<ptime::date_type, time_duration> no_dst;
typedef date_time::us_dst_rules<ptime::date_type, time_duration> us_dst;
} }
namespace boost {
namespace asio {
template <typename Time>
struct time_traits;
template <>
struct time_traits<boost::posix_time::ptime>
{
typedef boost::posix_time::ptime time_type;
typedef boost::posix_time::time_duration duration_type;
static time_type now()
;
static time_type add(const time_type& t, const duration_type& d)
;
static duration_type subtract(const time_type& t1, const time_type& t2)
;
static bool less_than(const time_type& t1, const time_type& t2)
;
static boost::posix_time::time_duration to_posix_duration(
const duration_type& d)
;
};
}
}
#define BOOST_ASIO_DETAIL_TIMER_QUEUE_PTIME_HPP
namespace boost {
namespace asio {
namespace detail {
struct forwarding_posix_time_traits : time_traits<boost::posix_time::ptime> {};
template <>
class timer_queue<time_traits<boost::posix_time::ptime> >
: public timer_queue_base
{
public:
typedef boost::posix_time::ptime time_type;
typedef boost::posix_time::time_duration duration_type;
typedef timer_queue<forwarding_posix_time_traits>::per_timer_data
per_timer_data;
inline timer_queue();
inline virtual ~timer_queue();
inline bool enqueue_timer(const time_type& time,
per_timer_data& timer, wait_op* op);
inline virtual bool empty() const;
inline virtual long wait_duration_msec(long max_duration) const;
inline virtual long wait_duration_usec(long max_duration) const;
inline virtual void get_ready_timers(op_queue<operation>& ops);
inline virtual void get_all_timers(op_queue<operation>& ops);
inline std::size_t cancel_timer(
per_timer_data& timer, op_queue<operation>& ops,
std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
private:
timer_queue<forwarding_posix_time_traits> impl_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_TIMER_QUEUE_PTIME_IPP
namespace boost {
namespace asio {
namespace detail {
bool timer_queue<time_traits<boost::posix_time::ptime> >::enqueue_timer(
const time_type& time, per_timer_data& timer, wait_op* op)
{
return impl_.enqueue_timer(time, timer, op);
}
bool timer_queue<time_traits<boost::posix_time::ptime> >::empty() const
{
return impl_.empty();
}
}
}
}
namespace boost {
namespace asio {
template <typename TimeType,
typename TimeTraits = boost::asio::time_traits<TimeType> >
class deadline_timer_service
: public boost::asio::detail::service_base<
deadline_timer_service<TimeType, TimeTraits> >
{
public:
typedef TimeTraits traits_type;
typedef typename traits_type::time_type time_type;
typedef typename traits_type::duration_type duration_type;
private:
typedef detail::deadline_timer_service<traits_type> service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
explicit deadline_timer_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void destroy(implementation_type& impl)
;
std::size_t cancel(implementation_type& impl, boost::system::error_code& ec)
;
std::size_t cancel_one(implementation_type& impl,
boost::system::error_code& ec)
;
time_type expires_at(const implementation_type& impl) const
;
std::size_t expires_at(implementation_type& impl,
const time_type& expiry_time, boost::system::error_code& ec)
;
duration_type expires_from_now(const implementation_type& impl) const
;
std::size_t expires_from_now(implementation_type& impl,
const duration_type& expiry_time, boost::system::error_code& ec)
;
void wait(implementation_type& impl, boost::system::error_code& ec)
;
template <typename WaitHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WaitHandler, void (boost::system::error_code)>::type>::type
async_wait(implementation_type& impl,
WaitHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename Time,
typename TimeTraits = boost::asio::time_traits<Time>,
typename TimerService = deadline_timer_service<Time, TimeTraits> >
class basic_deadline_timer
: public basic_io_object<TimerService>
{
public:
typedef TimeTraits traits_type;
typedef typename traits_type::time_type time_type;
typedef typename traits_type::duration_type duration_type;
explicit basic_deadline_timer(boost::asio::io_service& io_service)
;
basic_deadline_timer(boost::asio::io_service& io_service,
const time_type& expiry_time)
;
basic_deadline_timer(boost::asio::io_service& io_service,
const duration_type& expiry_time)
;
std::size_t cancel()
;
std::size_t cancel(boost::system::error_code& ec)
;
std::size_t cancel_one()
;
std::size_t cancel_one(boost::system::error_code& ec)
;
time_type expires_at() const
;
std::size_t expires_at(const time_type& expiry_time)
;
std::size_t expires_at(const time_type& expiry_time,
boost::system::error_code& ec)
;
duration_type expires_from_now() const
;
std::size_t expires_from_now(const duration_type& expiry_time)
;
std::size_t expires_from_now(const duration_type& expiry_time,
boost::system::error_code& ec)
;
void wait()
;
void wait(boost::system::error_code& ec)
;
template <typename WaitHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WaitHandler, void (boost::system::error_code)>::type>::type
async_wait(WaitHandler&& handler)
;
};
}
}
#define BOOST_ASIO_BASIC_RAW_SOCKET_HPP
#define BOOST_ASIO_RAW_SOCKET_SERVICE_HPP
namespace boost {
namespace asio {
template <typename Protocol>
class raw_socket_service
: public boost::asio::detail::service_base<raw_socket_service<Protocol> >
{
public:
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
private:
typedef detail::reactive_socket_service<Protocol> service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
typedef typename service_impl_type::native_handle_type native_type;
typedef typename service_impl_type::native_handle_type native_handle_type;
explicit raw_socket_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
raw_socket_service& other_service,
implementation_type& other_impl)
;
template <typename Protocol1>
void converting_move_construct(implementation_type& impl,
typename raw_socket_service<
Protocol1>::implementation_type& other_impl,
typename enable_if<is_convertible<
Protocol1, Protocol>::value>::type* = 0)
;
void destroy(implementation_type& impl)
;
boost::system::error_code open(implementation_type& impl,
const protocol_type& protocol, boost::system::error_code& ec)
;
boost::system::error_code assign(implementation_type& impl,
const protocol_type& protocol, const native_handle_type& native_socket,
boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_type native(implementation_type& impl)
;
native_handle_type native_handle(implementation_type& impl)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
bool at_mark(const implementation_type& impl,
boost::system::error_code& ec) const
;
std::size_t available(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code bind(implementation_type& impl,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
boost::system::error_code connect(implementation_type& impl,
const endpoint_type& peer_endpoint, boost::system::error_code& ec)
;
template <typename ConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ConnectHandler, void (boost::system::error_code)>::type>::type
async_connect(implementation_type& impl,
const endpoint_type& peer_endpoint,
ConnectHandler&& handler)
;
template <typename SettableSocketOption>
boost::system::error_code set_option(implementation_type& impl,
const SettableSocketOption& option, boost::system::error_code& ec)
;
template <typename GettableSocketOption>
boost::system::error_code get_option(const implementation_type& impl,
GettableSocketOption& option, boost::system::error_code& ec) const
;
template <typename IoControlCommand>
boost::system::error_code io_control(implementation_type& impl,
IoControlCommand& command, boost::system::error_code& ec)
;
bool non_blocking(const implementation_type& impl) const
;
boost::system::error_code non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const implementation_type& impl) const
;
boost::system::error_code native_non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
endpoint_type local_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
endpoint_type remote_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code shutdown(implementation_type& impl,
socket_base::shutdown_type what, boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t send(implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(implementation_type& impl, const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename ConstBufferSequence>
std::size_t send_to(implementation_type& impl,
const ConstBufferSequence& buffers, const endpoint_type& destination,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send_to(implementation_type& impl,
const ConstBufferSequence& buffers, const endpoint_type& destination,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags,
ReadHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive_from(implementation_type& impl,
const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive_from(implementation_type& impl,
const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
socket_base::message_flags flags,
ReadHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename Protocol,
typename RawSocketService = raw_socket_service<Protocol> >
class basic_raw_socket
: public basic_socket<Protocol, RawSocketService>
{
public:
typedef typename RawSocketService::native_handle_type native_type;
typedef typename RawSocketService::native_handle_type native_handle_type;
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
explicit basic_raw_socket(boost::asio::io_service& io_service)
;
basic_raw_socket(boost::asio::io_service& io_service,
const protocol_type& protocol)
;
basic_raw_socket(boost::asio::io_service& io_service,
const endpoint_type& endpoint)
;
basic_raw_socket(boost::asio::io_service& io_service,
const protocol_type& protocol, const native_handle_type& native_socket)
;
basic_raw_socket(basic_raw_socket&& other)
;
basic_raw_socket& operator=(basic_raw_socket&& other)
;
template <typename Protocol1, typename RawSocketService1>
basic_raw_socket(basic_raw_socket<Protocol1, RawSocketService1>&& other,
typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
;
template <typename Protocol1, typename RawSocketService1>
typename enable_if<is_convertible<Protocol1, Protocol>::value,
basic_raw_socket>::type& operator=(
basic_raw_socket<Protocol1, RawSocketService1>&& other)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename ConstBufferSequence>
std::size_t send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination)
;
template <typename ConstBufferSequence>
std::size_t send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags)
;
template <typename ConstBufferSequence>
std::size_t send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination,
WriteHandler&& handler)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags,
ReadHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint)
;
template <typename MutableBufferSequence>
std::size_t receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint, socket_base::message_flags flags)
;
template <typename MutableBufferSequence>
std::size_t receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint, socket_base::message_flags flags,
boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint,
ReadHandler&& handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint, socket_base::message_flags flags,
ReadHandler&& handler)
;
};
}
}
#define BOOST_ASIO_BASIC_SEQ_PACKET_SOCKET_HPP
#define BOOST_ASIO_SEQ_PACKET_SOCKET_SERVICE_HPP
namespace boost {
namespace asio {
template <typename Protocol>
class seq_packet_socket_service
: public boost::asio::detail::service_base<
seq_packet_socket_service<Protocol> >
{
public:
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
private:
typedef detail::reactive_socket_service<Protocol> service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
typedef typename service_impl_type::native_handle_type native_type;
typedef typename service_impl_type::native_handle_type native_handle_type;
explicit seq_packet_socket_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
seq_packet_socket_service& other_service,
implementation_type& other_impl)
;
template <typename Protocol1>
void converting_move_construct(implementation_type& impl,
typename seq_packet_socket_service<
Protocol1>::implementation_type& other_impl,
typename enable_if<is_convertible<
Protocol1, Protocol>::value>::type* = 0)
;
void destroy(implementation_type& impl)
;
boost::system::error_code open(implementation_type& impl,
const protocol_type& protocol, boost::system::error_code& ec)
;
boost::system::error_code assign(implementation_type& impl,
const protocol_type& protocol, const native_handle_type& native_socket,
boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_type native(implementation_type& impl)
;
native_handle_type native_handle(implementation_type& impl)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
bool at_mark(const implementation_type& impl,
boost::system::error_code& ec) const
;
std::size_t available(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code bind(implementation_type& impl,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
boost::system::error_code connect(implementation_type& impl,
const endpoint_type& peer_endpoint, boost::system::error_code& ec)
;
template <typename ConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ConnectHandler, void (boost::system::error_code)>::type>::type
async_connect(implementation_type& impl,
const endpoint_type& peer_endpoint,
ConnectHandler&& handler)
;
template <typename SettableSocketOption>
boost::system::error_code set_option(implementation_type& impl,
const SettableSocketOption& option, boost::system::error_code& ec)
;
template <typename GettableSocketOption>
boost::system::error_code get_option(const implementation_type& impl,
GettableSocketOption& option, boost::system::error_code& ec) const
;
template <typename IoControlCommand>
boost::system::error_code io_control(implementation_type& impl,
IoControlCommand& command, boost::system::error_code& ec)
;
bool non_blocking(const implementation_type& impl) const
;
boost::system::error_code non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const implementation_type& impl) const
;
boost::system::error_code native_non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
endpoint_type local_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
endpoint_type remote_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code shutdown(implementation_type& impl,
socket_base::shutdown_type what, boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t send(implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(implementation_type& impl,
const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
socket_base::message_flags& out_flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(implementation_type& impl,
const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
socket_base::message_flags& out_flags,
ReadHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename Protocol,
typename SeqPacketSocketService = seq_packet_socket_service<Protocol> >
class basic_seq_packet_socket
: public basic_socket<Protocol, SeqPacketSocketService>
{
public:
typedef typename SeqPacketSocketService::native_handle_type native_type;
typedef typename SeqPacketSocketService::native_handle_type
native_handle_type;
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
explicit basic_seq_packet_socket(boost::asio::io_service& io_service)
;
basic_seq_packet_socket(boost::asio::io_service& io_service,
const protocol_type& protocol)
;
basic_seq_packet_socket(boost::asio::io_service& io_service,
const endpoint_type& endpoint)
;
basic_seq_packet_socket(boost::asio::io_service& io_service,
const protocol_type& protocol, const native_handle_type& native_socket)
;
basic_seq_packet_socket(basic_seq_packet_socket&& other)
;
basic_seq_packet_socket& operator=(basic_seq_packet_socket&& other)
;
template <typename Protocol1, typename SeqPacketSocketService1>
basic_seq_packet_socket(
basic_seq_packet_socket<Protocol1, SeqPacketSocketService1>&& other,
typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
;
template <typename Protocol1, typename SeqPacketSocketService1>
typename enable_if<is_convertible<Protocol1, Protocol>::value,
basic_seq_packet_socket>::type& operator=(
basic_seq_packet_socket<Protocol1, SeqPacketSocketService1>&& other)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags& out_flags)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags in_flags,
socket_base::message_flags& out_flags)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags in_flags,
socket_base::message_flags& out_flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
socket_base::message_flags& out_flags,
ReadHandler&& handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
socket_base::message_flags in_flags,
socket_base::message_flags& out_flags,
ReadHandler&& handler)
;
};
}
}
#define BOOST_ASIO_BASIC_SERIAL_PORT_HPP
#define BOOST_ASIO_SERIAL_PORT_BASE_HPP
#define _TERMIOS_H 1
extern "C" {
typedef unsigned char cc_t;
typedef unsigned int speed_t;
typedef unsigned int tcflag_t;
#define NCCS 32
struct termios
{
tcflag_t c_iflag;
tcflag_t c_oflag;
tcflag_t c_cflag;
tcflag_t c_lflag;
cc_t c_line;
cc_t c_cc[32];
speed_t c_ispeed;
speed_t c_ospeed;
#define _HAVE_STRUCT_TERMIOS_C_ISPEED 1
#define _HAVE_STRUCT_TERMIOS_C_OSPEED 1
};
#define VINTR 0
#define VQUIT 1
#define VERASE 2
#define VKILL 3
#define VEOF 4
#define VTIME 5
#define VMIN 6
#define VSWTC 7
#define VSTART 8
#define VSTOP 9
#define VSUSP 10
#define VEOL 11
#define VREPRINT 12
#define VDISCARD 13
#define VWERASE 14
#define VLNEXT 15
#define VEOL2 16
#define IGNBRK 0000001
#define BRKINT 0000002
#define IGNPAR 0000004
#define PARMRK 0000010
#define INPCK 0000020
#define ISTRIP 0000040
#define INLCR 0000100
#define IGNCR 0000200
#define ICRNL 0000400
#define IUCLC 0001000
#define IXON 0002000
#define IXANY 0004000
#define IXOFF 0010000
#define IMAXBEL 0020000
#define IUTF8 0040000
#define OPOST 0000001
#define OLCUC 0000002
#define ONLCR 0000004
#define OCRNL 0000010
#define ONOCR 0000020
#define ONLRET 0000040
#define OFILL 0000100
#define OFDEL 0000200
#define NLDLY 0000400
#define NL0 0000000
#define NL1 0000400
#define CRDLY 0003000
#define CR0 0000000
#define CR1 0001000
#define CR2 0002000
#define CR3 0003000
#define TABDLY 0014000
#define TAB0 0000000
#define TAB1 0004000
#define TAB2 0010000
#define TAB3 0014000
#define BSDLY 0020000
#define BS0 0000000
#define BS1 0020000
#define FFDLY 0100000
#define FF0 0000000
#define FF1 0100000
#define VTDLY 0040000
#define VT0 0000000
#define VT1 0040000
#define XTABS 0014000
#define CBAUD 0010017
#define B0 0000000
#define B50 0000001
#define B75 0000002
#define B110 0000003
#define B134 0000004
#define B150 0000005
#define B200 0000006
#define B300 0000007
#define B600 0000010
#define B1200 0000011
#define B1800 0000012
#define B2400 0000013
#define B4800 0000014
#define B9600 0000015
#define B19200 0000016
#define B38400 0000017
#define EXTA B19200
#define EXTB B38400
#define CSIZE 0000060
#define CS5 0000000
#define CS6 0000020
#define CS7 0000040
#define CS8 0000060
#define CSTOPB 0000100
#define CREAD 0000200
#define PARENB 0000400
#define PARODD 0001000
#define HUPCL 0002000
#define CLOCAL 0004000
#define CBAUDEX 0010000
#define B57600 0010001
#define B115200 0010002
#define B230400 0010003
#define B460800 0010004
#define B500000 0010005
#define B576000 0010006
#define B921600 0010007
#define B1000000 0010010
#define B1152000 0010011
#define B1500000 0010012
#define B2000000 0010013
#define B2500000 0010014
#define B3000000 0010015
#define B3500000 0010016
#define B4000000 0010017
#define __MAX_BAUD B4000000
#define CIBAUD 002003600000
#define CMSPAR 010000000000
#define CRTSCTS 020000000000
#define ISIG 0000001
#define ICANON 0000002
#define XCASE 0000004
#define ECHO 0000010
#define ECHOE 0000020
#define ECHOK 0000040
#define ECHONL 0000100
#define NOFLSH 0000200
#define TOSTOP 0000400
#define ECHOCTL 0001000
#define ECHOPRT 0002000
#define ECHOKE 0004000
#define FLUSHO 0010000
#define PENDIN 0040000
#define IEXTEN 0100000
#define EXTPROC 0200000
#define TCOOFF 0
#define TCOON 1
#define TCIOFF 2
#define TCION 3
#define TCIFLUSH 0
#define TCOFLUSH 1
#define TCIOFLUSH 2
#define TCSANOW 0
#define TCSADRAIN 1
#define TCSAFLUSH 2
#define _IOT_termios _IOT (_IOTS (cflag_t), 4, _IOTS (cc_t), NCCS, _IOTS (speed_t), 2)
#define CCEQ(val,c) ((c) == (val) && (val) != _POSIX_VDISABLE)
extern speed_t cfgetospeed (const struct termios *__termios_p) throw ();
extern speed_t cfgetispeed (const struct termios *__termios_p) throw ();
extern int cfsetospeed (struct termios *__termios_p, speed_t __speed) throw ();
extern int cfsetispeed (struct termios *__termios_p, speed_t __speed) throw ();
extern int cfsetspeed (struct termios *__termios_p, speed_t __speed) throw ();
extern int tcgetattr (int __fd, struct termios *__termios_p) throw ();
extern int tcsetattr (int __fd, int __optional_actions,
const struct termios *__termios_p) throw ();
extern void cfmakeraw (struct termios *__termios_p) throw ();
extern int tcsendbreak (int __fd, int __duration) throw ();
extern int tcdrain (int __fd);
extern int tcflush (int __fd, int __queue_selector) throw ();
extern int tcflow (int __fd, int __action) throw ();
extern __pid_t tcgetsid (int __fd) throw ();
}
#define BOOST_ASIO_OPTION_STORAGE termios
namespace boost {
namespace asio {
class serial_port_base
{
public:
class baud_rate
{
public:
explicit baud_rate(unsigned int rate = 0);
unsigned int value() const;
inline boost::system::error_code store(
termios& storage,
boost::system::error_code& ec) const;
inline boost::system::error_code load(
const termios& storage,
boost::system::error_code& ec);
private:
unsigned int value_;
};
class flow_control
{
public:
enum type { none, software, hardware };
inline explicit flow_control(type t = none);
type value() const;
inline boost::system::error_code store(
termios& storage,
boost::system::error_code& ec) const;
inline boost::system::error_code load(
const termios& storage,
boost::system::error_code& ec);
private:
type value_;
};
class parity
{
public:
enum type { none, odd, even };
inline explicit parity(type t = none);
type value() const;
inline boost::system::error_code store(
termios& storage,
boost::system::error_code& ec) const;
inline boost::system::error_code load(
const termios& storage,
boost::system::error_code& ec);
private:
type value_;
};
class stop_bits
{
public:
enum type { one, onepointfive, two };
inline explicit stop_bits(type t = one);
type value() const;
inline boost::system::error_code store(
termios& storage,
boost::system::error_code& ec) const;
inline boost::system::error_code load(
const termios& storage,
boost::system::error_code& ec);
private:
type value_;
};
class character_size
{
public:
inline explicit character_size(unsigned int t = 8);
unsigned int value() const;
inline boost::system::error_code store(
termios& storage,
boost::system::error_code& ec) const;
inline boost::system::error_code load(
const termios& storage,
boost::system::error_code& ec);
private:
unsigned int value_;
};
protected:
~serial_port_base()
;
};
}
}
#undef BOOST_ASIO_OPTION_STORAGE
#define BOOST_ASIO_IMPL_SERIAL_PORT_BASE_HPP
namespace boost {
namespace asio {
}
}
#define BOOST_ASIO_IMPL_SERIAL_PORT_BASE_IPP
#define BOOST_ASIO_OPTION_STORAGE termios
namespace boost {
namespace asio {
}
}
#undef BOOST_ASIO_OPTION_STORAGE
#define BOOST_ASIO_SERIAL_PORT_SERVICE_HPP
#define BOOST_ASIO_DETAIL_REACTIVE_SERIAL_PORT_SERVICE_HPP
#define BOOST_ASIO_DETAIL_DESCRIPTOR_OPS_HPP
namespace boost {
namespace asio {
namespace detail {
namespace descriptor_ops {
enum
{
user_set_non_blocking = 1,
internal_non_blocking = 2,
non_blocking = user_set_non_blocking | internal_non_blocking,
possible_dup = 4
};
typedef unsigned char state_type;
template <typename ReturnType>
ReturnType error_wrapper(ReturnType return_value,
boost::system::error_code& ec)
;
inline int open(const char* path, int flags,
boost::system::error_code& ec);
inline int close(int d, state_type& state,
boost::system::error_code& ec);
inline bool set_user_non_blocking(int d,
state_type& state, bool value, boost::system::error_code& ec);
inline bool set_internal_non_blocking(int d,
state_type& state, bool value, boost::system::error_code& ec);
typedef iovec buf;
inline std::size_t sync_read(int d, state_type state, buf* bufs,
std::size_t count, bool all_empty, boost::system::error_code& ec);
inline bool non_blocking_read(int d, buf* bufs, std::size_t count,
boost::system::error_code& ec, std::size_t& bytes_transferred);
inline std::size_t sync_write(int d, state_type state,
const buf* bufs, std::size_t count, bool all_empty,
boost::system::error_code& ec);
inline bool non_blocking_write(int d,
const buf* bufs, std::size_t count,
boost::system::error_code& ec, std::size_t& bytes_transferred);
inline int ioctl(int d, state_type& state, long cmd,
ioctl_arg_type* arg, boost::system::error_code& ec);
inline int fcntl(int d, int cmd, boost::system::error_code& ec);
inline int fcntl(int d, int cmd,
long arg, boost::system::error_code& ec);
inline int poll_read(int d,
state_type state, boost::system::error_code& ec);
inline int poll_write(int d,
state_type state, boost::system::error_code& ec);
}
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_DESCRIPTOR_OPS_IPP
#undef __need_error_t
namespace boost {
namespace asio {
namespace detail {
namespace descriptor_ops {
int open(const char* path, int flags, boost::system::error_code& ec)
;
int close(int d, state_type& state, boost::system::error_code& ec)
;
bool set_user_non_blocking(int d, state_type& state,
bool value, boost::system::error_code& ec)
;
bool set_internal_non_blocking(int d, state_type& state,
bool value, boost::system::error_code& ec)
;
std::size_t sync_read(int d, state_type state, buf* bufs,
std::size_t count, bool all_empty, boost::system::error_code& ec)
;
bool non_blocking_read(int d, buf* bufs, std::size_t count,
boost::system::error_code& ec, std::size_t& bytes_transferred)
;
std::size_t sync_write(int d, state_type state, const buf* bufs,
std::size_t count, bool all_empty, boost::system::error_code& ec)
;
bool non_blocking_write(int d, const buf* bufs, std::size_t count,
boost::system::error_code& ec, std::size_t& bytes_transferred)
;
int ioctl(int d, state_type& state, long cmd,
ioctl_arg_type* arg, boost::system::error_code& ec)
;
int fcntl(int d, int cmd, boost::system::error_code& ec)
;
int fcntl(int d, int cmd, long arg, boost::system::error_code& ec)
;
int poll_read(int d, state_type state, boost::system::error_code& ec)
;
int poll_write(int d, state_type state, boost::system::error_code& ec)
;
}
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_DESCRIPTOR_SERVICE_HPP
#define BOOST_ASIO_DETAIL_DESCRIPTOR_READ_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename MutableBufferSequence>
class descriptor_read_op_base : public reactor_op
{
public:
descriptor_read_op_base(int descriptor,
const MutableBufferSequence& buffers, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
int descriptor_;
MutableBufferSequence buffers_;
};
template <typename MutableBufferSequence, typename Handler>
class descriptor_read_op
: public descriptor_read_op_base<MutableBufferSequence>
{
public:
struct ptr { Handler* h; void* v; descriptor_read_op* p; ~ptr() ; void reset() ; };
descriptor_read_op(int descriptor,
const MutableBufferSequence& buffers, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_DESCRIPTOR_WRITE_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename ConstBufferSequence>
class descriptor_write_op_base : public reactor_op
{
public:
descriptor_write_op_base(int descriptor,
const ConstBufferSequence& buffers, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
int descriptor_;
ConstBufferSequence buffers_;
};
template <typename ConstBufferSequence, typename Handler>
class descriptor_write_op
: public descriptor_write_op_base<ConstBufferSequence>
{
public:
struct ptr { Handler* h; void* v; descriptor_write_op* p; ~ptr() ; void reset() ; };
descriptor_write_op(int descriptor,
const ConstBufferSequence& buffers, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
class reactive_descriptor_service
{
public:
typedef int native_handle_type;
class implementation_type
: private boost::asio::detail::noncopyable
{
public:
implementation_type()
;
private:
friend class reactive_descriptor_service;
int descriptor_;
descriptor_ops::state_type state_;
reactor::per_descriptor_data reactor_data_;
};
inline reactive_descriptor_service(
boost::asio::io_service& io_service);
inline void shutdown_service();
inline void construct(implementation_type& impl);
inline void move_construct(implementation_type& impl,
implementation_type& other_impl);
inline void move_assign(implementation_type& impl,
reactive_descriptor_service& other_service,
implementation_type& other_impl);
inline void destroy(implementation_type& impl);
inline boost::system::error_code assign(implementation_type& impl,
const native_handle_type& native_descriptor,
boost::system::error_code& ec);
bool is_open(const implementation_type& impl) const
;
inline boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec);
native_handle_type native_handle(const implementation_type& impl) const
;
inline native_handle_type release(implementation_type& impl);
inline boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec);
template <typename IO_Control_Command>
boost::system::error_code io_control(implementation_type& impl,
IO_Control_Command& command, boost::system::error_code& ec)
;
bool non_blocking(const implementation_type& impl) const
;
boost::system::error_code non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const implementation_type& impl) const
;
boost::system::error_code native_non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
size_t write_some(implementation_type& impl,
const ConstBufferSequence& buffers, boost::system::error_code& ec)
;
size_t write_some(implementation_type& impl,
const null_buffers&, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename Handler>
void async_write_some(implementation_type& impl,
const ConstBufferSequence& buffers, Handler& handler)
;
template <typename Handler>
void async_write_some(implementation_type& impl,
const null_buffers&, Handler& handler)
;
template <typename MutableBufferSequence>
size_t read_some(implementation_type& impl,
const MutableBufferSequence& buffers, boost::system::error_code& ec)
;
size_t read_some(implementation_type& impl,
const null_buffers&, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename Handler>
void async_read_some(implementation_type& impl,
const MutableBufferSequence& buffers, Handler& handler)
;
template <typename Handler>
void async_read_some(implementation_type& impl,
const null_buffers&, Handler& handler)
;
private:
inline void start_op(implementation_type& impl, int op_type,
reactor_op* op, bool is_continuation, bool is_non_blocking, bool noop);
reactor& reactor_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_REACTIVE_DESCRIPTOR_SERVICE_IPP
namespace boost {
namespace asio {
namespace detail {
}
}
}
namespace boost {
namespace asio {
namespace detail {
class reactive_serial_port_service
{
public:
typedef reactive_descriptor_service::native_handle_type native_handle_type;
typedef reactive_descriptor_service::implementation_type implementation_type;
inline reactive_serial_port_service(
boost::asio::io_service& io_service);
inline void shutdown_service();
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
reactive_serial_port_service& other_service,
implementation_type& other_impl)
;
void destroy(implementation_type& impl)
;
inline boost::system::error_code open(implementation_type& impl,
const std::string& device, boost::system::error_code& ec);
boost::system::error_code assign(implementation_type& impl,
const native_handle_type& native_descriptor,
boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_handle_type native_handle(implementation_type& impl)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
template <typename SettableSerialPortOption>
boost::system::error_code set_option(implementation_type& impl,
const SettableSerialPortOption& option, boost::system::error_code& ec)
;
template <typename GettableSerialPortOption>
boost::system::error_code get_option(const implementation_type& impl,
GettableSerialPortOption& option, boost::system::error_code& ec) const
;
boost::system::error_code send_break(implementation_type& impl,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
size_t write_some(implementation_type& impl,
const ConstBufferSequence& buffers, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename Handler>
void async_write_some(implementation_type& impl,
const ConstBufferSequence& buffers, Handler& handler)
;
template <typename MutableBufferSequence>
size_t read_some(implementation_type& impl,
const MutableBufferSequence& buffers, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename Handler>
void async_read_some(implementation_type& impl,
const MutableBufferSequence& buffers, Handler& handler)
;
private:
typedef boost::system::error_code (*store_function_type)(
const void*, termios&, boost::system::error_code&);
template <typename SettableSerialPortOption>
static boost::system::error_code store_option(const void* option,
termios& storage, boost::system::error_code& ec)
;
inline boost::system::error_code do_set_option(
implementation_type& impl, store_function_type store,
const void* option, boost::system::error_code& ec);
typedef boost::system::error_code (*load_function_type)(
void*, const termios&, boost::system::error_code&);
template <typename GettableSerialPortOption>
static boost::system::error_code load_option(void* option,
const termios& storage, boost::system::error_code& ec)
;
inline boost::system::error_code do_get_option(
const implementation_type& impl, load_function_type load,
void* option, boost::system::error_code& ec) const;
reactive_descriptor_service descriptor_service_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_REACTIVE_SERIAL_PORT_SERVICE_IPP
namespace boost {
namespace asio {
namespace detail {
}
}
}
#define BOOST_ASIO_DETAIL_WIN_IOCP_SERIAL_PORT_SERVICE_HPP
namespace boost {
namespace asio {
class serial_port_service
: public boost::asio::detail::service_base<serial_port_service>
{
public:
private:
typedef detail::reactive_serial_port_service service_impl_type;
public:
typedef service_impl_type::implementation_type implementation_type;
typedef service_impl_type::native_handle_type native_type;
typedef service_impl_type::native_handle_type native_handle_type;
explicit serial_port_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
serial_port_service& other_service,
implementation_type& other_impl)
;
void destroy(implementation_type& impl)
;
boost::system::error_code open(implementation_type& impl,
const std::string& device, boost::system::error_code& ec)
;
boost::system::error_code assign(implementation_type& impl,
const native_handle_type& handle, boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_type native(implementation_type& impl)
;
native_handle_type native_handle(implementation_type& impl)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
template <typename SettableSerialPortOption>
boost::system::error_code set_option(implementation_type& impl,
const SettableSerialPortOption& option, boost::system::error_code& ec)
;
template <typename GettableSerialPortOption>
boost::system::error_code get_option(const implementation_type& impl,
GettableSerialPortOption& option, boost::system::error_code& ec) const
;
boost::system::error_code send_break(implementation_type& impl,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t write_some(implementation_type& impl,
const ConstBufferSequence& buffers, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(implementation_type& impl,
const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t read_some(implementation_type& impl,
const MutableBufferSequence& buffers, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(implementation_type& impl,
const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename SerialPortService = serial_port_service>
class basic_serial_port
: public basic_io_object<SerialPortService>,
public serial_port_base
{
public:
typedef typename SerialPortService::native_handle_type native_type;
typedef typename SerialPortService::native_handle_type native_handle_type;
typedef basic_serial_port<SerialPortService> lowest_layer_type;
explicit basic_serial_port(boost::asio::io_service& io_service)
;
explicit basic_serial_port(boost::asio::io_service& io_service,
const char* device)
;
explicit basic_serial_port(boost::asio::io_service& io_service,
const std::string& device)
;
basic_serial_port(boost::asio::io_service& io_service,
const native_handle_type& native_serial_port)
;
basic_serial_port(basic_serial_port&& other)
;
basic_serial_port& operator=(basic_serial_port&& other)
;
lowest_layer_type& lowest_layer()
;
const lowest_layer_type& lowest_layer() const
;
void open(const std::string& device)
;
boost::system::error_code open(const std::string& device,
boost::system::error_code& ec)
;
void assign(const native_handle_type& native_serial_port)
;
boost::system::error_code assign(const native_handle_type& native_serial_port,
boost::system::error_code& ec)
;
bool is_open() const
;
void close()
;
boost::system::error_code close(boost::system::error_code& ec)
;
native_type native()
;
native_handle_type native_handle()
;
void cancel()
;
boost::system::error_code cancel(boost::system::error_code& ec)
;
void send_break()
;
boost::system::error_code send_break(boost::system::error_code& ec)
;
template <typename SettableSerialPortOption>
void set_option(const SettableSerialPortOption& option)
;
template <typename SettableSerialPortOption>
boost::system::error_code set_option(const SettableSerialPortOption& option,
boost::system::error_code& ec)
;
template <typename GettableSerialPortOption>
void get_option(GettableSerialPortOption& option)
;
template <typename GettableSerialPortOption>
boost::system::error_code get_option(GettableSerialPortOption& option,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
};
}
}
#define BOOST_ASIO_BASIC_SIGNAL_SET_HPP
#define BOOST_ASIO_SIGNAL_SET_SERVICE_HPP
#define BOOST_ASIO_DETAIL_SIGNAL_SET_SERVICE_HPP
#define _SIGNAL_H
extern "C" {
#define _SIGSET_H_fns 1
#define _EXTERN_INLINE __extern_inline
#define __sigmask(sig) (((unsigned long int) 1) << (((sig) - 1) % (8 * sizeof (unsigned long int))))
#define __sigword(sig) (((sig) - 1) / (8 * sizeof (unsigned long int)))
#define __sigemptyset(set) (__extension__ ({ int __cnt = _SIGSET_NWORDS; sigset_t *__set = (set); while (--__cnt >= 0) __set->__val[__cnt] = 0; 0; }))
#define __sigfillset(set) (__extension__ ({ int __cnt = _SIGSET_NWORDS; sigset_t *__set = (set); while (--__cnt >= 0) __set->__val[__cnt] = ~0UL; 0; }))
#define __sigisemptyset(set) (__extension__ ({ int __cnt = _SIGSET_NWORDS; const sigset_t *__set = (set); int __ret = __set->__val[--__cnt]; while (!__ret && --__cnt >= 0) __ret = __set->__val[__cnt]; __ret == 0; }))
#define __sigandset(dest,left,right) (__extension__ ({ int __cnt = _SIGSET_NWORDS; sigset_t *__dest = (dest); const sigset_t *__left = (left); const sigset_t *__right = (right); while (--__cnt >= 0) __dest->__val[__cnt] = (__left->__val[__cnt] & __right->__val[__cnt]); 0; }))
#define __sigorset(dest,left,right) (__extension__ ({ int __cnt = _SIGSET_NWORDS; sigset_t *__dest = (dest); const sigset_t *__left = (left); const sigset_t *__right = (right); while (--__cnt >= 0) __dest->__val[__cnt] = (__left->__val[__cnt] | __right->__val[__cnt]); 0; }))
extern int __sigismember (const __sigset_t *, int);
extern int __sigaddset (__sigset_t *, int);
extern int __sigdelset (__sigset_t *, int);
#define __sig_atomic_t_defined
typedef __sig_atomic_t sig_atomic_t;
#undef __need_sig_atomic_t
#undef __need_sigset_t
#define SIG_ERR ((__sighandler_t) -1)
#define SIG_DFL ((__sighandler_t) 0)
#define SIG_IGN ((__sighandler_t) 1)
#define SIG_HOLD ((__sighandler_t) 2)
#define SIGHUP 1
#define SIGINT 2
#define SIGQUIT 3
#define SIGILL 4
#define SIGTRAP 5
#define SIGABRT 6
#define SIGIOT 6
#define SIGBUS 7
#define SIGFPE 8
#define SIGKILL 9
#define SIGUSR1 10
#define SIGSEGV 11
#define SIGUSR2 12
#define SIGPIPE 13
#define SIGALRM 14
#define SIGTERM 15
#define SIGSTKFLT 16
#define SIGCLD SIGCHLD
#define SIGCHLD 17
#define SIGCONT 18
#define SIGSTOP 19
#define SIGTSTP 20
#define SIGTTIN 21
#define SIGTTOU 22
#define SIGURG 23
#define SIGXCPU 24
#define SIGXFSZ 25
#define SIGVTALRM 26
#define SIGPROF 27
#define SIGWINCH 28
#define SIGPOLL SIGIO
#define SIGIO 29
#define SIGPWR 30
#define SIGSYS 31
#define SIGUNUSED 31
#define _NSIG 65
#define SIGRTMIN (__libc_current_sigrtmin ())
#define SIGRTMAX (__libc_current_sigrtmax ())
#define __SIGRTMIN 32
#define __SIGRTMAX (_NSIG - 1)
#define __need_timespec
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
#define __have_siginfo_t 1
#define __SI_MAX_SIZE 128
#define __SI_PAD_SIZE ((__SI_MAX_SIZE / sizeof (int)) - 4)
typedef __clock_t __sigchld_clock_t;
#define __SI_ALIGNMENT
typedef struct
{
int si_signo;
int si_errno;
int si_code;
union
{
int _pad[((128 / sizeof (int)) - 4)];
struct
{
__pid_t si_pid;
__uid_t si_uid;
} _kill;
struct
{
int si_tid;
int si_overrun;
sigval_t si_sigval;
} _timer;
struct
{
__pid_t si_pid;
__uid_t si_uid;
sigval_t si_sigval;
} _rt;
struct
{
__pid_t si_pid;
__uid_t si_uid;
int si_status;
__sigchld_clock_t si_utime;
__sigchld_clock_t si_stime;
} _sigchld;
struct
{
void *si_addr;
short int si_addr_lsb;
} _sigfault;
struct
{
long int si_band;
int si_fd;
} _sigpoll;
struct
{
void *_call_addr;
int _syscall;
unsigned int _arch;
} _sigsys;
} _sifields;
} siginfo_t ;
#define si_pid _sifields._kill.si_pid
#define si_uid _sifields._kill.si_uid
#define si_timerid _sifields._timer.si_tid
#define si_overrun _sifields._timer.si_overrun
#define si_status _sifields._sigchld.si_status
#define si_utime _sifields._sigchld.si_utime
#define si_stime _sifields._sigchld.si_stime
#define si_value _sifields._rt.si_sigval
#define si_int _sifields._rt.si_sigval.sival_int
#define si_ptr _sifields._rt.si_sigval.sival_ptr
#define si_addr _sifields._sigfault.si_addr
#define si_addr_lsb _sifields._sigfault.si_addr_lsb
#define si_band _sifields._sigpoll.si_band
#define si_fd _sifields._sigpoll.si_fd
#define si_call_addr _sifields._sigsys._call_addr
#define si_syscall _sifields._sigsys._syscall
#define si_arch _sifields._sigsys._arch
enum
{
SI_ASYNCNL = -60,
#define SI_ASYNCNL SI_ASYNCNL
SI_TKILL = -6,
#define SI_TKILL SI_TKILL
SI_SIGIO,
#define SI_SIGIO SI_SIGIO
SI_ASYNCIO,
#define SI_ASYNCIO SI_ASYNCIO
SI_MESGQ,
#define SI_MESGQ SI_MESGQ
SI_TIMER,
#define SI_TIMER SI_TIMER
SI_QUEUE,
#define SI_QUEUE SI_QUEUE
SI_USER,
#define SI_USER SI_USER
SI_KERNEL = 0x80
#define SI_KERNEL SI_KERNEL
};
enum
{
ILL_ILLOPC = 1,
#define ILL_ILLOPC ILL_ILLOPC
ILL_ILLOPN,
#define ILL_ILLOPN ILL_ILLOPN
ILL_ILLADR,
#define ILL_ILLADR ILL_ILLADR
ILL_ILLTRP,
#define ILL_ILLTRP ILL_ILLTRP
ILL_PRVOPC,
#define ILL_PRVOPC ILL_PRVOPC
ILL_PRVREG,
#define ILL_PRVREG ILL_PRVREG
ILL_COPROC,
#define ILL_COPROC ILL_COPROC
ILL_BADSTK
#define ILL_BADSTK ILL_BADSTK
};
enum
{
FPE_INTDIV = 1,
#define FPE_INTDIV FPE_INTDIV
FPE_INTOVF,
#define FPE_INTOVF FPE_INTOVF
FPE_FLTDIV,
#define FPE_FLTDIV FPE_FLTDIV
FPE_FLTOVF,
#define FPE_FLTOVF FPE_FLTOVF
FPE_FLTUND,
#define FPE_FLTUND FPE_FLTUND
FPE_FLTRES,
#define FPE_FLTRES FPE_FLTRES
FPE_FLTINV,
#define FPE_FLTINV FPE_FLTINV
FPE_FLTSUB
#define FPE_FLTSUB FPE_FLTSUB
};
enum
{
SEGV_MAPERR = 1,
#define SEGV_MAPERR SEGV_MAPERR
SEGV_ACCERR
#define SEGV_ACCERR SEGV_ACCERR
};
enum
{
BUS_ADRALN = 1,
#define BUS_ADRALN BUS_ADRALN
BUS_ADRERR,
#define BUS_ADRERR BUS_ADRERR
BUS_OBJERR,
#define BUS_OBJERR BUS_OBJERR
BUS_MCEERR_AR,
#define BUS_MCEERR_AR BUS_MCEERR_AR
BUS_MCEERR_AO
#define BUS_MCEERR_AO BUS_MCEERR_AO
};
enum
{
TRAP_BRKPT = 1,
#define TRAP_BRKPT TRAP_BRKPT
TRAP_TRACE
#define TRAP_TRACE TRAP_TRACE
};
enum
{
CLD_EXITED = 1,
#define CLD_EXITED CLD_EXITED
CLD_KILLED,
#define CLD_KILLED CLD_KILLED
CLD_DUMPED,
#define CLD_DUMPED CLD_DUMPED
CLD_TRAPPED,
#define CLD_TRAPPED CLD_TRAPPED
CLD_STOPPED,
#define CLD_STOPPED CLD_STOPPED
CLD_CONTINUED
#define CLD_CONTINUED CLD_CONTINUED
};
enum
{
POLL_IN = 1,
#define POLL_IN POLL_IN
POLL_OUT,
#define POLL_OUT POLL_OUT
POLL_MSG,
#define POLL_MSG POLL_MSG
POLL_ERR,
#define POLL_ERR POLL_ERR
POLL_PRI,
#define POLL_PRI POLL_PRI
POLL_HUP
#define POLL_HUP POLL_HUP
};
#undef __need_siginfo_t
typedef void (*__sighandler_t) (int);
extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
throw ();
extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler)
throw ();
extern __sighandler_t signal (int __sig, __sighandler_t __handler)
throw ();
extern __sighandler_t bsd_signal (int __sig, __sighandler_t __handler)
throw ();
extern int kill (__pid_t __pid, int __sig) throw ();
extern int killpg (__pid_t __pgrp, int __sig) throw ();
extern int raise (int __sig) throw ();
extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
throw ();
extern int gsignal (int __sig) throw ();
extern void psignal (int __sig, const char *__s);
extern void psiginfo (const siginfo_t *__pinfo, const char *__s);
extern int __sigpause (int __sig_or_mask, int __is_sig);
extern int sigpause (int __sig) __asm__ ("__xpg_sigpause");
#define sigmask(sig) __sigmask(sig)
extern int sigblock (int __mask) throw () __attribute__ ((__deprecated__));
extern int sigsetmask (int __mask) throw () __attribute__ ((__deprecated__));
extern int siggetmask (void) throw () __attribute__ ((__deprecated__));
#define NSIG _NSIG
typedef __sighandler_t sighandler_t;
typedef __sighandler_t sig_t;
extern int sigemptyset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
extern int sigfillset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
extern int sigaddset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
extern int sigdelset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
extern int sigismember (const sigset_t *__set, int __signo)
throw () __attribute__ ((__nonnull__ (1)));
extern int sigisemptyset (const sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
extern int sigandset (sigset_t *__set, const sigset_t *__left,
const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
extern int sigorset (sigset_t *__set, const sigset_t *__left,
const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
struct sigaction
{
union
{
__sighandler_t sa_handler;
void (*sa_sigaction) (int, siginfo_t *, void *);
}
__sigaction_handler;
#define sa_handler __sigaction_handler.sa_handler
#define sa_sigaction __sigaction_handler.sa_sigaction
__sigset_t sa_mask;
int sa_flags;
void (*sa_restorer) (void);
};
#define SA_NOCLDSTOP 1
#define SA_NOCLDWAIT 2
#define SA_SIGINFO 4
#define SA_ONSTACK 0x08000000
#define SA_RESTART 0x10000000
#define SA_NODEFER 0x40000000
#define SA_RESETHAND 0x80000000
#define SA_INTERRUPT 0x20000000
#define SA_NOMASK SA_NODEFER
#define SA_ONESHOT SA_RESETHAND
#define SA_STACK SA_ONSTACK
#define SIG_BLOCK 0
#define SIG_UNBLOCK 1
#define SIG_SETMASK 2
extern int sigprocmask (int __how, const sigset_t *__restrict __set,
sigset_t *__restrict __oset) throw ();
extern int sigsuspend (const sigset_t *__set) __attribute__ ((__nonnull__ (1)));
extern int sigaction (int __sig, const struct sigaction *__restrict __act,
struct sigaction *__restrict __oact) throw ();
extern int sigpending (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
extern int sigwait (const sigset_t *__restrict __set, int *__restrict __sig)
__attribute__ ((__nonnull__ (1, 2)));
extern int sigwaitinfo (const sigset_t *__restrict __set,
siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1)));
extern int sigtimedwait (const sigset_t *__restrict __set,
siginfo_t *__restrict __info,
const struct timespec *__restrict __timeout)
__attribute__ ((__nonnull__ (1)));
extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val)
throw ();
extern const char *const _sys_siglist[65];
extern const char *const sys_siglist[65];
struct sigvec
{
__sighandler_t sv_handler;
int sv_mask;
int sv_flags;
#define sv_onstack sv_flags
};
#define SV_ONSTACK (1 << 0)
#define SV_INTERRUPT (1 << 1)
#define SV_RESETHAND (1 << 2)
extern int sigvec (int __sig, const struct sigvec *__vec,
struct sigvec *__ovec) throw ();
#define _BITS_SIGCONTEXT_H 1
#define FP_XSTATE_MAGIC1 0x46505853U
#define FP_XSTATE_MAGIC2 0x46505845U
#define FP_XSTATE_MAGIC2_SIZE sizeof(FP_XSTATE_MAGIC2)
struct _fpx_sw_bytes
{
__uint32_t magic1;
__uint32_t extended_size;
__uint64_t xstate_bv;
__uint32_t xstate_size;
__uint32_t padding[7];
};
struct _fpreg
{
unsigned short significand[4];
unsigned short exponent;
};
struct _fpxreg
{
unsigned short significand[4];
unsigned short exponent;
unsigned short padding[3];
};
struct _xmmreg
{
__uint32_t element[4];
};
struct _fpstate
{
__uint16_t cwd;
__uint16_t swd;
__uint16_t ftw;
__uint16_t fop;
__uint64_t rip;
__uint64_t rdp;
__uint32_t mxcsr;
__uint32_t mxcr_mask;
struct _fpxreg _st[8];
struct _xmmreg _xmm[16];
__uint32_t padding[24];
};
struct sigcontext
{
__uint64_t r8;
__uint64_t r9;
__uint64_t r10;
__uint64_t r11;
__uint64_t r12;
__uint64_t r13;
__uint64_t r14;
__uint64_t r15;
__uint64_t rdi;
__uint64_t rsi;
__uint64_t rbp;
__uint64_t rbx;
__uint64_t rdx;
__uint64_t rax;
__uint64_t rcx;
__uint64_t rsp;
__uint64_t rip;
__uint64_t eflags;
unsigned short cs;
unsigned short gs;
unsigned short fs;
unsigned short __pad0;
__uint64_t err;
__uint64_t trapno;
__uint64_t oldmask;
__uint64_t cr2;
__extension__ union
{
struct _fpstate * fpstate;
__uint64_t __fpstate_word;
};
__uint64_t __reserved1 [8];
};
struct _xsave_hdr
{
__uint64_t xstate_bv;
__uint64_t reserved1[2];
__uint64_t reserved2[5];
};
struct _ymmh_state
{
__uint32_t ymmh_space[64];
};
struct _xstate
{
struct _fpstate fpstate;
struct _xsave_hdr xstate_hdr;
struct _ymmh_state ymmh;
};
extern int sigreturn (struct sigcontext *__scp) throw ();
#define __need_size_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
extern int siginterrupt (int __sig, int __interrupt) throw ();
struct sigstack
{
void *ss_sp;
int ss_onstack;
};
enum
{
SS_ONSTACK = 1,
#define SS_ONSTACK SS_ONSTACK
SS_DISABLE
#define SS_DISABLE SS_DISABLE
};
#define MINSIGSTKSZ 2048
#define SIGSTKSZ 8192
typedef struct sigaltstack
{
void *ss_sp;
int ss_flags;
size_t ss_size;
} stack_t;
#define _SYS_UCONTEXT_H 1
__extension__ typedef long long int greg_t;
#define NGREG 23
typedef greg_t gregset_t[23];
enum
{
REG_R8 = 0,
#define REG_R8 REG_R8
REG_R9,
#define REG_R9 REG_R9
REG_R10,
#define REG_R10 REG_R10
REG_R11,
#define REG_R11 REG_R11
REG_R12,
#define REG_R12 REG_R12
REG_R13,
#define REG_R13 REG_R13
REG_R14,
#define REG_R14 REG_R14
REG_R15,
#define REG_R15 REG_R15
REG_RDI,
#define REG_RDI REG_RDI
REG_RSI,
#define REG_RSI REG_RSI
REG_RBP,
#define REG_RBP REG_RBP
REG_RBX,
#define REG_RBX REG_RBX
REG_RDX,
#define REG_RDX REG_RDX
REG_RAX,
#define REG_RAX REG_RAX
REG_RCX,
#define REG_RCX REG_RCX
REG_RSP,
#define REG_RSP REG_RSP
REG_RIP,
#define REG_RIP REG_RIP
REG_EFL,
#define REG_EFL REG_EFL
REG_CSGSFS,
#define REG_CSGSFS REG_CSGSFS
REG_ERR,
#define REG_ERR REG_ERR
REG_TRAPNO,
#define REG_TRAPNO REG_TRAPNO
REG_OLDMASK,
#define REG_OLDMASK REG_OLDMASK
REG_CR2
#define REG_CR2 REG_CR2
};
struct _libc_fpxreg
{
unsigned short int significand[4];
unsigned short int exponent;
unsigned short int padding[3];
};
struct _libc_xmmreg
{
__uint32_t element[4];
};
struct _libc_fpstate
{
__uint16_t cwd;
__uint16_t swd;
__uint16_t ftw;
__uint16_t fop;
__uint64_t rip;
__uint64_t rdp;
__uint32_t mxcsr;
__uint32_t mxcr_mask;
struct _libc_fpxreg _st[8];
struct _libc_xmmreg _xmm[16];
__uint32_t padding[24];
};
typedef struct _libc_fpstate *fpregset_t;
typedef struct
{
gregset_t gregs;
fpregset_t fpregs;
__extension__ unsigned long long __reserved1 [8];
} mcontext_t;
typedef struct ucontext
{
unsigned long int uc_flags;
struct ucontext *uc_link;
stack_t uc_stack;
mcontext_t uc_mcontext;
__sigset_t uc_sigmask;
struct _libc_fpstate __fpregs_mem;
} ucontext_t;
extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
throw () __attribute__ ((__deprecated__));
extern int sigaltstack (const struct sigaltstack *__restrict __ss,
struct sigaltstack *__restrict __oss) throw ();
extern int sighold (int __sig) throw ();
extern int sigrelse (int __sig) throw ();
extern int sigignore (int __sig) throw ();
extern __sighandler_t sigset (int __sig, __sighandler_t __disp) throw ();
#define _BITS_SIGTHREAD_H 1
extern int pthread_sigmask (int __how,
const __sigset_t *__restrict __newmask,
__sigset_t *__restrict __oldmask)throw ();
extern int pthread_kill (pthread_t __threadid, int __signo) throw ();
extern int pthread_sigqueue (pthread_t __threadid, int __signo,
const union sigval __value) throw ();
extern int __libc_current_sigrtmin (void) throw ();
extern int __libc_current_sigrtmax (void) throw ();
}
#define BOOST_ASIO_DETAIL_SIGNAL_HANDLER_HPP
#define BOOST_ASIO_DETAIL_SIGNAL_OP_HPP
namespace boost {
namespace asio {
namespace detail {
class signal_op
: public operation
{
public:
boost::system::error_code ec_;
int signal_number_;
protected:
signal_op(func_type func)
;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Handler>
class signal_handler : public signal_op
{
public:
struct ptr { Handler* h; void* v; signal_handler* p; ~ptr() ; void reset() ; };
signal_handler(Handler& h)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
enum { max_signal_number = 65 };
extern inline struct signal_state* get_signal_state();
extern "C" inline void boost_asio_signal_handler(int signal_number);
class signal_set_service
{
public:
class registration
{
public:
registration()
;
private:
friend class signal_set_service;
int signal_number_;
op_queue<signal_op>* queue_;
std::size_t undelivered_;
registration* next_in_table_;
registration* prev_in_table_;
registration* next_in_set_;
};
class implementation_type
{
public:
implementation_type()
;
private:
friend class signal_set_service;
op_queue<signal_op> queue_;
registration* signals_;
};
inline signal_set_service(boost::asio::io_service& io_service);
inline ~signal_set_service();
inline void shutdown_service();
inline void fork_service(
boost::asio::io_service::fork_event fork_ev);
inline void construct(implementation_type& impl);
inline void destroy(implementation_type& impl);
inline boost::system::error_code add(implementation_type& impl,
int signal_number, boost::system::error_code& ec);
inline boost::system::error_code remove(implementation_type& impl,
int signal_number, boost::system::error_code& ec);
inline boost::system::error_code clear(implementation_type& impl,
boost::system::error_code& ec);
inline boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec);
template <typename Handler>
void async_wait(implementation_type& impl, Handler& handler)
;
inline static void deliver_signal(int signal_number);
private:
inline static void add_service(signal_set_service* service);
inline static void remove_service(signal_set_service* service);
inline static void open_descriptors();
inline static void close_descriptors();
inline void start_wait_op(implementation_type& impl, signal_op* op);
io_service_impl& io_service_;
class pipe_read_op;
reactor& reactor_;
reactor::per_descriptor_data reactor_data_;
registration* registrations_[max_signal_number];
signal_set_service* next_;
signal_set_service* prev_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_SIGNAL_SET_SERVICE_IPP
#define BOOST_ASIO_DETAIL_SIGNAL_BLOCKER_HPP
#define BOOST_ASIO_DETAIL_POSIX_SIGNAL_BLOCKER_HPP
#define _GLIBCXX_CSIGNAL 1
#undef raise
namespace std
{
using ::sig_atomic_t;
using ::signal;
using ::raise;
}
namespace boost {
namespace asio {
namespace detail {
class posix_signal_blocker
: private noncopyable
{
public:
posix_signal_blocker()
;
~posix_signal_blocker()
;
void block()
;
void unblock()
;
private:
bool blocked_;
sigset_t old_mask_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
typedef posix_signal_blocker signal_blocker;
}
}
}
#define BOOST_ASIO_DETAIL_STATIC_MUTEX_HPP
#define BOOST_ASIO_DETAIL_POSIX_STATIC_MUTEX_HPP
namespace boost {
namespace asio {
namespace detail {
struct posix_static_mutex
{
typedef boost::asio::detail::scoped_lock<posix_static_mutex> scoped_lock;
void init()
;
void lock()
;
void unlock()
;
::pthread_mutex_t mutex_;
};
#define BOOST_ASIO_POSIX_STATIC_MUTEX_INIT { PTHREAD_MUTEX_INITIALIZER }
}
}
}
namespace boost {
namespace asio {
namespace detail {
typedef posix_static_mutex static_mutex;
#define BOOST_ASIO_STATIC_MUTEX_INIT BOOST_ASIO_POSIX_STATIC_MUTEX_INIT
}
}
}
namespace boost {
namespace asio {
namespace detail {
struct signal_state
{
static_mutex mutex_;
int read_descriptor_;
int write_descriptor_;
bool fork_prepared_;
class signal_set_service* service_list_;
std::size_t registration_count_[max_signal_number];
};
signal_state* get_signal_state()
;
void boost_asio_signal_handler(int signal_number)
;
class signal_set_service::pipe_read_op : public reactor_op
{
public:
pipe_read_op()
;
static bool do_perform(reactor_op*)
;
static void do_complete(io_service_impl* , operation* base,
const boost::system::error_code& ,
std::size_t )
;
};
}
}
}
namespace boost {
namespace asio {
class signal_set_service
: public boost::asio::detail::service_base<signal_set_service>
{
public:
public:
typedef detail::signal_set_service::implementation_type implementation_type;
explicit signal_set_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void destroy(implementation_type& impl)
;
boost::system::error_code add(implementation_type& impl,
int signal_number, boost::system::error_code& ec)
;
boost::system::error_code remove(implementation_type& impl,
int signal_number, boost::system::error_code& ec)
;
boost::system::error_code clear(implementation_type& impl,
boost::system::error_code& ec)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
template <typename SignalHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<SignalHandler, void (boost::system::error_code, int)>::type>::type
async_wait(implementation_type& impl,
SignalHandler&& handler)
;
private:
void shutdown_service()
;
void fork_service(boost::asio::io_service::fork_event event)
;
detail::signal_set_service service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename SignalSetService = signal_set_service>
class basic_signal_set
: public basic_io_object<SignalSetService>
{
public:
explicit basic_signal_set(boost::asio::io_service& io_service)
;
basic_signal_set(boost::asio::io_service& io_service, int signal_number_1)
;
basic_signal_set(boost::asio::io_service& io_service, int signal_number_1,
int signal_number_2)
;
basic_signal_set(boost::asio::io_service& io_service, int signal_number_1,
int signal_number_2, int signal_number_3)
;
void add(int signal_number)
;
boost::system::error_code add(int signal_number,
boost::system::error_code& ec)
;
void remove(int signal_number)
;
boost::system::error_code remove(int signal_number,
boost::system::error_code& ec)
;
void clear()
;
boost::system::error_code clear(boost::system::error_code& ec)
;
void cancel()
;
boost::system::error_code cancel(boost::system::error_code& ec)
;
template <typename SignalHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<SignalHandler, void (boost::system::error_code, int)>::type>::type
async_wait(SignalHandler&& handler)
;
};
}
}
#define BOOST_ASIO_BASIC_SOCKET_ACCEPTOR_HPP
#define BOOST_ASIO_SOCKET_ACCEPTOR_SERVICE_HPP
namespace boost {
namespace asio {
template <typename Protocol>
class socket_acceptor_service
: public boost::asio::detail::service_base<socket_acceptor_service<Protocol> >
{
public:
typedef Protocol protocol_type;
typedef typename protocol_type::endpoint endpoint_type;
private:
typedef detail::reactive_socket_service<Protocol> service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
typedef typename service_impl_type::native_handle_type native_type;
typedef typename service_impl_type::native_handle_type native_handle_type;
explicit socket_acceptor_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
socket_acceptor_service& other_service,
implementation_type& other_impl)
;
template <typename Protocol1>
void converting_move_construct(implementation_type& impl,
typename socket_acceptor_service<
Protocol1>::implementation_type& other_impl,
typename enable_if<is_convertible<
Protocol1, Protocol>::value>::type* = 0)
;
void destroy(implementation_type& impl)
;
boost::system::error_code open(implementation_type& impl,
const protocol_type& protocol, boost::system::error_code& ec)
;
boost::system::error_code assign(implementation_type& impl,
const protocol_type& protocol, const native_handle_type& native_acceptor,
boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
boost::system::error_code bind(implementation_type& impl,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
boost::system::error_code listen(implementation_type& impl, int backlog,
boost::system::error_code& ec)
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_type native(implementation_type& impl)
;
native_handle_type native_handle(implementation_type& impl)
;
template <typename SettableSocketOption>
boost::system::error_code set_option(implementation_type& impl,
const SettableSocketOption& option, boost::system::error_code& ec)
;
template <typename GettableSocketOption>
boost::system::error_code get_option(const implementation_type& impl,
GettableSocketOption& option, boost::system::error_code& ec) const
;
template <typename IoControlCommand>
boost::system::error_code io_control(implementation_type& impl,
IoControlCommand& command, boost::system::error_code& ec)
;
bool non_blocking(const implementation_type& impl) const
;
boost::system::error_code non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const implementation_type& impl) const
;
boost::system::error_code native_non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
endpoint_type local_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
template <typename Protocol1, typename SocketService>
boost::system::error_code accept(implementation_type& impl,
basic_socket<Protocol1, SocketService>& peer,
endpoint_type* peer_endpoint, boost::system::error_code& ec,
typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
;
template <typename Protocol1, typename SocketService, typename AcceptHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<AcceptHandler, void (boost::system::error_code)>::type>::type
async_accept(implementation_type& impl,
basic_socket<Protocol1, SocketService>& peer,
endpoint_type* peer_endpoint,
AcceptHandler&& handler,
typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename Protocol,
typename SocketAcceptorService = socket_acceptor_service<Protocol> >
class basic_socket_acceptor
: public basic_io_object<SocketAcceptorService>,
public socket_base
{
public:
typedef typename SocketAcceptorService::native_handle_type native_type;
typedef typename SocketAcceptorService::native_handle_type native_handle_type;
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
explicit basic_socket_acceptor(boost::asio::io_service& io_service)
;
basic_socket_acceptor(boost::asio::io_service& io_service,
const protocol_type& protocol)
;
basic_socket_acceptor(boost::asio::io_service& io_service,
const endpoint_type& endpoint, bool reuse_addr = true)
;
basic_socket_acceptor(boost::asio::io_service& io_service,
const protocol_type& protocol, const native_handle_type& native_acceptor)
;
basic_socket_acceptor(basic_socket_acceptor&& other)
;
basic_socket_acceptor& operator=(basic_socket_acceptor&& other)
;
template <typename Protocol1, typename SocketAcceptorService1>
friend class basic_socket_acceptor;
template <typename Protocol1, typename SocketAcceptorService1>
basic_socket_acceptor(
basic_socket_acceptor<Protocol1, SocketAcceptorService1>&& other,
typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
;
template <typename Protocol1, typename SocketAcceptorService1>
typename enable_if<is_convertible<Protocol1, Protocol>::value,
basic_socket_acceptor>::type& operator=(
basic_socket_acceptor<Protocol1, SocketAcceptorService1>&& other)
;
void open(const protocol_type& protocol = protocol_type())
;
boost::system::error_code open(const protocol_type& protocol,
boost::system::error_code& ec)
;
void assign(const protocol_type& protocol,
const native_handle_type& native_acceptor)
;
boost::system::error_code assign(const protocol_type& protocol,
const native_handle_type& native_acceptor, boost::system::error_code& ec)
;
bool is_open() const
;
void bind(const endpoint_type& endpoint)
;
boost::system::error_code bind(const endpoint_type& endpoint,
boost::system::error_code& ec)
;
void listen(int backlog = socket_base::max_connections)
;
boost::system::error_code listen(int backlog, boost::system::error_code& ec)
;
void close()
;
boost::system::error_code close(boost::system::error_code& ec)
;
native_type native()
;
native_handle_type native_handle()
;
void cancel()
;
boost::system::error_code cancel(boost::system::error_code& ec)
;
template <typename SettableSocketOption>
void set_option(const SettableSocketOption& option)
;
template <typename SettableSocketOption>
boost::system::error_code set_option(const SettableSocketOption& option,
boost::system::error_code& ec)
;
template <typename GettableSocketOption>
void get_option(GettableSocketOption& option)
;
template <typename GettableSocketOption>
boost::system::error_code get_option(GettableSocketOption& option,
boost::system::error_code& ec)
;
template <typename IoControlCommand>
void io_control(IoControlCommand& command)
;
template <typename IoControlCommand>
boost::system::error_code io_control(IoControlCommand& command,
boost::system::error_code& ec)
;
bool non_blocking() const
;
void non_blocking(bool mode)
;
boost::system::error_code non_blocking(
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking() const
;
void native_non_blocking(bool mode)
;
boost::system::error_code native_non_blocking(
bool mode, boost::system::error_code& ec)
;
endpoint_type local_endpoint() const
;
endpoint_type local_endpoint(boost::system::error_code& ec) const
;
template <typename Protocol1, typename SocketService>
void accept(basic_socket<Protocol1, SocketService>& peer,
typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
;
template <typename Protocol1, typename SocketService>
boost::system::error_code accept(
basic_socket<Protocol1, SocketService>& peer,
boost::system::error_code& ec,
typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
;
template <typename Protocol1, typename SocketService, typename AcceptHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<AcceptHandler, void (boost::system::error_code)>::type>::type
async_accept(basic_socket<Protocol1, SocketService>& peer,
AcceptHandler&& handler,
typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
;
template <typename SocketService>
void accept(basic_socket<protocol_type, SocketService>& peer,
endpoint_type& peer_endpoint)
;
template <typename SocketService>
boost::system::error_code accept(
basic_socket<protocol_type, SocketService>& peer,
endpoint_type& peer_endpoint, boost::system::error_code& ec)
;
template <typename SocketService, typename AcceptHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<AcceptHandler, void (boost::system::error_code)>::type>::type
async_accept(basic_socket<protocol_type, SocketService>& peer,
endpoint_type& peer_endpoint, AcceptHandler&& handler)
;
};
}
}
#define BOOST_ASIO_BASIC_SOCKET_IOSTREAM_HPP
#define BOOST_ASIO_BASIC_SOCKET_STREAMBUF_HPP
#define BOOST_ASIO_DETAIL_ARRAY_HPP
namespace boost {
namespace asio {
namespace detail {
using std::array;
}
}
}
#define BOOST_ASIO_STREAM_SOCKET_SERVICE_HPP
namespace boost {
namespace asio {
template <typename Protocol>
class stream_socket_service
: public boost::asio::detail::service_base<stream_socket_service<Protocol> >
{
public:
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
private:
typedef detail::reactive_socket_service<Protocol> service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
typedef typename service_impl_type::native_handle_type native_type;
typedef typename service_impl_type::native_handle_type native_handle_type;
explicit stream_socket_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
stream_socket_service& other_service,
implementation_type& other_impl)
;
template <typename Protocol1>
void converting_move_construct(implementation_type& impl,
typename stream_socket_service<
Protocol1>::implementation_type& other_impl,
typename enable_if<is_convertible<
Protocol1, Protocol>::value>::type* = 0)
;
void destroy(implementation_type& impl)
;
boost::system::error_code open(implementation_type& impl,
const protocol_type& protocol, boost::system::error_code& ec)
;
boost::system::error_code assign(implementation_type& impl,
const protocol_type& protocol, const native_handle_type& native_socket,
boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_type native(implementation_type& impl)
;
native_handle_type native_handle(implementation_type& impl)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
bool at_mark(const implementation_type& impl,
boost::system::error_code& ec) const
;
std::size_t available(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code bind(implementation_type& impl,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
boost::system::error_code connect(implementation_type& impl,
const endpoint_type& peer_endpoint, boost::system::error_code& ec)
;
template <typename ConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ConnectHandler, void (boost::system::error_code)>::type>::type
async_connect(implementation_type& impl,
const endpoint_type& peer_endpoint,
ConnectHandler&& handler)
;
template <typename SettableSocketOption>
boost::system::error_code set_option(implementation_type& impl,
const SettableSocketOption& option, boost::system::error_code& ec)
;
template <typename GettableSocketOption>
boost::system::error_code get_option(const implementation_type& impl,
GettableSocketOption& option, boost::system::error_code& ec) const
;
template <typename IoControlCommand>
boost::system::error_code io_control(implementation_type& impl,
IoControlCommand& command, boost::system::error_code& ec)
;
bool non_blocking(const implementation_type& impl) const
;
boost::system::error_code non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const implementation_type& impl) const
;
boost::system::error_code native_non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
endpoint_type local_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
endpoint_type remote_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code shutdown(implementation_type& impl,
socket_base::shutdown_type what, boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t send(implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags,
ReadHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
#define BOOST_ASIO_DEADLINE_TIMER_HPP
namespace boost {
namespace asio {
typedef basic_deadline_timer<boost::posix_time::ptime> deadline_timer;
}
}
namespace boost {
namespace asio {
namespace detail {
class socket_streambuf_base
{
protected:
io_service io_service_;
};
}
template <typename Protocol,
typename StreamSocketService = stream_socket_service<Protocol>,
typename Time = boost::posix_time::ptime,
typename TimeTraits = boost::asio::time_traits<Time>,
typename TimerService = deadline_timer_service<Time, TimeTraits> >
class basic_socket_streambuf
: public std::streambuf,
private detail::socket_streambuf_base,
public basic_socket<Protocol, StreamSocketService>
{
private:
typedef TimeTraits traits_helper;
public:
typedef typename Protocol::endpoint endpoint_type;
typedef typename traits_helper::time_type time_type;
typedef typename traits_helper::duration_type duration_type;
basic_socket_streambuf()
;
virtual ~basic_socket_streambuf()
;
basic_socket_streambuf<Protocol, StreamSocketService,
Time, TimeTraits, TimerService>* connect(
const endpoint_type& endpoint)
;
template <typename... T>
basic_socket_streambuf<Protocol, StreamSocketService,
Time, TimeTraits, TimerService>* connect(T... x)
;
basic_socket_streambuf<Protocol, StreamSocketService,
Time, TimeTraits, TimerService>* close()
;
const boost::system::error_code& puberror() const
;
time_type expires_at() const
;
void expires_at(const time_type& expiry_time)
;
duration_type expires_from_now() const
;
void expires_from_now(const duration_type& expiry_time)
;
protected:
int_type underflow()
;
int_type overflow(int_type c)
;
int sync()
;
std::streambuf* setbuf(char_type* s, std::streamsize n)
;
virtual const boost::system::error_code& error() const
;
private:
void init_buffers()
;
template <typename ResolverQuery>
void resolve_and_connect(const ResolverQuery& query)
;
struct io_handler;
friend struct io_handler;
struct io_handler
{
basic_socket_streambuf* this_;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred = 0)
;
};
struct timer_handler;
friend struct timer_handler;
struct timer_handler
{
basic_socket_streambuf* this_;
void operator()(const boost::system::error_code&)
;
};
void construct_timer()
;
void destroy_timer()
;
void start_timer()
;
enum { putback_max = 8 };
enum { buffer_size = 512 };
boost::asio::detail::array<char, buffer_size> get_buffer_;
boost::asio::detail::array<char, buffer_size> put_buffer_;
bool unbuffered_;
boost::system::error_code ec_;
std::size_t bytes_transferred_;
TimerService* timer_service_;
typename TimerService::implementation_type timer_implementation_;
enum state { no_timer, timer_is_pending, timer_has_expired } timer_state_;
};
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Protocol, typename StreamSocketService,
typename Time, typename TimeTraits, typename TimerService>
class socket_iostream_base
{
protected:
basic_socket_streambuf<Protocol, StreamSocketService,
Time, TimeTraits, TimerService> streambuf_;
};
}
template <typename Protocol,
typename StreamSocketService = stream_socket_service<Protocol>,
typename Time = boost::posix_time::ptime,
typename TimeTraits = boost::asio::time_traits<Time>,
typename TimerService = deadline_timer_service<Time, TimeTraits> >
class basic_socket_iostream
: private detail::socket_iostream_base<Protocol,
StreamSocketService, Time, TimeTraits, TimerService>,
public std::basic_iostream<char>
{
private:
typedef TimeTraits traits_helper;
public:
typedef typename Protocol::endpoint endpoint_type;
typedef typename traits_helper::time_type time_type;
typedef typename traits_helper::duration_type duration_type;
basic_socket_iostream()
;
template <typename... T>
explicit basic_socket_iostream(T... x)
;
template <typename... T>
void connect(T... x)
;
void close()
;
basic_socket_streambuf<Protocol, StreamSocketService,
Time, TimeTraits, TimerService>* rdbuf() const
;
const boost::system::error_code& error() const
;
time_type expires_at() const
;
void expires_at(const time_type& expiry_time)
;
duration_type expires_from_now() const
;
void expires_from_now(const duration_type& expiry_time)
;
};
}
}
#define BOOST_ASIO_BASIC_STREAM_SOCKET_HPP
namespace boost {
namespace asio {
template <typename Protocol,
typename StreamSocketService = stream_socket_service<Protocol> >
class basic_stream_socket
: public basic_socket<Protocol, StreamSocketService>
{
public:
typedef typename StreamSocketService::native_handle_type native_type;
typedef typename StreamSocketService::native_handle_type native_handle_type;
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
explicit basic_stream_socket(boost::asio::io_service& io_service)
;
basic_stream_socket(boost::asio::io_service& io_service,
const protocol_type& protocol)
;
basic_stream_socket(boost::asio::io_service& io_service,
const endpoint_type& endpoint)
;
basic_stream_socket(boost::asio::io_service& io_service,
const protocol_type& protocol, const native_handle_type& native_socket)
;
basic_stream_socket(basic_stream_socket&& other)
;
basic_stream_socket& operator=(basic_stream_socket&& other)
;
template <typename Protocol1, typename StreamSocketService1>
basic_stream_socket(
basic_stream_socket<Protocol1, StreamSocketService1>&& other,
typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
;
template <typename Protocol1, typename StreamSocketService1>
typename enable_if<is_convertible<Protocol1, Protocol>::value,
basic_stream_socket>::type& operator=(
basic_stream_socket<Protocol1, StreamSocketService1>&& other)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags,
ReadHandler&& handler)
{
typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
return this->get_service().async_receive(this->get_implementation(),
buffers, flags, static_cast<ReadHandler&&>(handler));
}
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers)
{
boost::system::error_code ec;
std::size_t s = this->get_service().send(
this->get_implementation(), buffers, 0, ec);
boost::asio::detail::throw_error(ec, "write_some");
return s;
}
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers,
boost::system::error_code& ec)
{
return this->get_service().send(this->get_implementation(), buffers, 0, ec);
}
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(const ConstBufferSequence& buffers,
WriteHandler&& handler)
{
typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
return this->get_service().async_send(this->get_implementation(),
buffers, 0, static_cast<WriteHandler&&>(handler));
}
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers)
{
boost::system::error_code ec;
std::size_t s = this->get_service().receive(
this->get_implementation(), buffers, 0, ec);
boost::asio::detail::throw_error(ec, "read_some");
return s;
}
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers,
boost::system::error_code& ec)
{
return this->get_service().receive(
this->get_implementation(), buffers, 0, ec);
}
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(const MutableBufferSequence& buffers,
ReadHandler&& handler)
{
typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
return this->get_service().async_receive(this->get_implementation(),
buffers, 0, static_cast<ReadHandler&&>(handler));
}
};
}
}
#define BOOST_ASIO_BASIC_STREAMBUF_HPP
#define BOOST_ASIO_BASIC_STREAMBUF_FWD_HPP
namespace boost {
namespace asio {
template <typename Allocator = std::allocator<char> >
class basic_streambuf;
}
}
namespace boost {
namespace asio {
template <typename Allocator>
class basic_streambuf
: public std::streambuf,
private noncopyable
{
public:
typedef boost::asio::const_buffers_1 const_buffers_type;
typedef boost::asio::mutable_buffers_1 mutable_buffers_type;
explicit basic_streambuf(
std::size_t maximum_size = (std::numeric_limits<std::size_t>::max)(),
const Allocator& allocator = Allocator())
: max_size_(maximum_size),
buffer_(allocator)
{
std::size_t pend = (std::min<std::size_t>)(max_size_, buffer_delta);
buffer_.resize((std::max<std::size_t>)(pend, 1));
setg(&buffer_[0], &buffer_[0], &buffer_[0]);
setp(&buffer_[0], &buffer_[0] + pend);
}
std::size_t size() const
{
return pptr() - gptr();
}
std::size_t max_size() const
{
return max_size_;
}
const_buffers_type data() const
;
mutable_buffers_type prepare(std::size_t n)
;
void commit(std::size_t n)
;
void consume(std::size_t n)
;
protected:
enum { buffer_delta = 128 };
int_type underflow()
;
int_type overflow(int_type c)
;
void reserve(std::size_t n)
;
private:
std::size_t max_size_;
std::vector<char_type, Allocator> buffer_;
friend std::size_t read_size_helper(
basic_streambuf& sb, std::size_t max_size)
;
};
template <typename Allocator>
std::size_t read_size_helper(
basic_streambuf<Allocator>& sb, std::size_t max_size)
;
}
}
#define BOOST_ASIO_BASIC_WAITABLE_TIMER_HPP
#define BOOST_ASIO_WAIT_TRAITS_HPP
namespace boost {
namespace asio {
template <typename Clock>
struct wait_traits
{
static typename Clock::duration to_wait_duration(
const typename Clock::duration& d)
;
};
}
}
#define BOOST_ASIO_WAITABLE_TIMER_SERVICE_HPP
#define BOOST_ASIO_DETAIL_CHRONO_TIME_TRAITS_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Clock, typename WaitTraits>
struct chrono_time_traits
{
typedef Clock clock_type;
typedef typename clock_type::duration duration_type;
typedef typename clock_type::time_point time_type;
typedef typename duration_type::period period_type;
static time_type now()
;
static time_type add(const time_type& t, const duration_type& d)
;
static duration_type subtract(const time_type& t1, const time_type& t2)
;
static bool less_than(const time_type& t1, const time_type& t2)
;
class posix_time_duration
{
public:
explicit posix_time_duration(const duration_type& d)
;
int64_t ticks() const
;
int64_t total_seconds() const
;
int64_t total_milliseconds() const
;
int64_t total_microseconds() const
;
private:
template <int64_t Num, int64_t Den>
int64_t duration_cast() const
;
duration_type d_;
};
static posix_time_duration to_posix_duration(const duration_type& d)
;
};
}
}
}
namespace boost {
namespace asio {
template <typename Clock,
typename WaitTraits = boost::asio::wait_traits<Clock> >
class waitable_timer_service
: public boost::asio::detail::service_base<
waitable_timer_service<Clock, WaitTraits> >
{
public:
typedef Clock clock_type;
typedef typename clock_type::duration duration;
typedef typename clock_type::time_point time_point;
typedef WaitTraits traits_type;
private:
typedef detail::deadline_timer_service<
detail::chrono_time_traits<Clock, WaitTraits> > service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
explicit waitable_timer_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void destroy(implementation_type& impl)
;
std::size_t cancel(implementation_type& impl, boost::system::error_code& ec)
;
std::size_t cancel_one(implementation_type& impl,
boost::system::error_code& ec)
;
time_point expires_at(const implementation_type& impl) const
;
std::size_t expires_at(implementation_type& impl,
const time_point& expiry_time, boost::system::error_code& ec)
;
duration expires_from_now(const implementation_type& impl) const
;
std::size_t expires_from_now(implementation_type& impl,
const duration& expiry_time, boost::system::error_code& ec)
;
void wait(implementation_type& impl, boost::system::error_code& ec)
;
template <typename WaitHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WaitHandler, void (boost::system::error_code)>::type>::type
async_wait(implementation_type& impl,
WaitHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename Clock,
typename WaitTraits = boost::asio::wait_traits<Clock>,
typename WaitableTimerService = waitable_timer_service<Clock, WaitTraits> >
class basic_waitable_timer
: public basic_io_object<WaitableTimerService>
{
public:
typedef Clock clock_type;
typedef typename clock_type::duration duration;
typedef typename clock_type::time_point time_point;
typedef WaitTraits traits_type;
explicit basic_waitable_timer(boost::asio::io_service& io_service)
;
basic_waitable_timer(boost::asio::io_service& io_service,
const time_point& expiry_time)
;
basic_waitable_timer(boost::asio::io_service& io_service,
const duration& expiry_time)
;
std::size_t cancel()
;
std::size_t cancel(boost::system::error_code& ec)
;
std::size_t cancel_one()
;
std::size_t cancel_one(boost::system::error_code& ec)
;
time_point expires_at() const
;
std::size_t expires_at(const time_point& expiry_time)
;
std::size_t expires_at(const time_point& expiry_time,
boost::system::error_code& ec)
;
duration expires_from_now() const
;
std::size_t expires_from_now(const duration& expiry_time)
;
std::size_t expires_from_now(const duration& expiry_time,
boost::system::error_code& ec)
{
return this->service.expires_from_now(
this->implementation, expiry_time, ec);
}
void wait()
{
boost::system::error_code ec;
this->service.wait(this->implementation, ec);
boost::asio::detail::throw_error(ec, "wait");
}
void wait(boost::system::error_code& ec)
{
this->service.wait(this->implementation, ec);
}
template <typename WaitHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WaitHandler, void (boost::system::error_code)>::type>::type
async_wait(WaitHandler&& handler)
{
typedef typename handler_type<WaitHandler, void(boost::system::error_code)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "WaitHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> __attribute__((__unused__)) type_check;
return this->service.async_wait(this->implementation,
static_cast<WaitHandler&&>(handler));
}
};
}
}
#define BOOST_ASIO_BUFFERED_READ_STREAM_FWD_HPP
namespace boost {
namespace asio {
template <typename Stream>
class buffered_read_stream;
}
}
#define BOOST_ASIO_BUFFERED_READ_STREAM_HPP
#define BOOST_ASIO_DETAIL_BUFFER_RESIZE_GUARD_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Buffer>
class buffer_resize_guard
{
public:
buffer_resize_guard(Buffer& buffer)
: buffer_(buffer),
old_size_(buffer.size())
{
}
~buffer_resize_guard()
{
if (old_size_ != (std::numeric_limits<size_t>::max)())
{
buffer_.resize(old_size_);
}
}
void commit()
{
old_size_ = (std::numeric_limits<size_t>::max)();
}
private:
Buffer& buffer_;
size_t old_size_;
};
}
}
}
#define BOOST_ASIO_DETAIL_BUFFERED_STREAM_STORAGE_HPP
namespace boost {
namespace asio {
namespace detail {
class buffered_stream_storage
{
public:
typedef unsigned char byte_type;
typedef std::size_t size_type;
explicit buffered_stream_storage(std::size_t buffer_capacity)
: begin_offset_(0),
end_offset_(0),
buffer_(buffer_capacity)
{
}
void clear()
{
begin_offset_ = 0;
end_offset_ = 0;
}
mutable_buffer data()
{
return boost::asio::buffer(buffer_) + begin_offset_;
}
const_buffer data() const
{
return boost::asio::buffer(buffer_) + begin_offset_;
}
bool empty() const
{
return begin_offset_ == end_offset_;
}
size_type size() const
{
return end_offset_ - begin_offset_;
}
void resize(size_type length)
{
(static_cast<void> (0));
if (begin_offset_ + length <= capacity())
{
end_offset_ = begin_offset_ + length;
}
else
{
using namespace std;
memmove(&buffer_[0], &buffer_[0] + begin_offset_, size());
end_offset_ = length;
begin_offset_ = 0;
}
}
size_type capacity() const
{
return buffer_.size();
}
void consume(size_type count)
{
(static_cast<void> (0));
begin_offset_ += count;
if (empty())
clear();
}
private:
size_type begin_offset_;
size_type end_offset_;
std::vector<byte_type> buffer_;
};
}
}
}
namespace boost {
namespace asio {
template <typename Stream>
class buffered_read_stream
: private noncopyable
{
public:
typedef typename remove_reference<Stream>::type next_layer_type;
typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
static const std::size_t default_buffer_size = 1024;
template <typename Arg>
explicit buffered_read_stream(Arg& a)
: next_layer_(a),
storage_(default_buffer_size)
{
}
template <typename Arg>
buffered_read_stream(Arg& a, std::size_t buffer_size)
: next_layer_(a),
storage_(buffer_size)
{
}
next_layer_type& next_layer()
{
return next_layer_;
}
lowest_layer_type& lowest_layer()
{
return next_layer_.lowest_layer();
}
const lowest_layer_type& lowest_layer() const
{
return next_layer_.lowest_layer();
}
boost::asio::io_service& get_io_service()
{
return next_layer_.get_io_service();
}
void close()
{
next_layer_.close();
}
boost::system::error_code close(boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
std::size_t fill();
std::size_t fill(boost::system::error_code& ec);
template <typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_fill(ReadHandler&& handler);
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers);
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers,
boost::system::error_code& ec);
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(const MutableBufferSequence& buffers,
ReadHandler&& handler);
template <typename MutableBufferSequence>
std::size_t peek(const MutableBufferSequence& buffers);
template <typename MutableBufferSequence>
std::size_t peek(const MutableBufferSequence& buffers,
boost::system::error_code& ec);
std::size_t in_avail()
;
std::size_t in_avail(boost::system::error_code& ec)
;
private:
template <typename MutableBufferSequence>
std::size_t copy(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t peek_copy(const MutableBufferSequence& buffers)
;
Stream next_layer_;
detail::buffered_stream_storage storage_;
};
}
}
#define BOOST_ASIO_IMPL_BUFFERED_READ_STREAM_HPP
namespace boost {
namespace asio {
namespace detail
{
template <typename ReadHandler>
class buffered_fill_handler
{
public:
buffered_fill_handler(detail::buffered_stream_storage& storage,
std::size_t previous_size, ReadHandler& handler)
;
buffered_fill_handler(const buffered_fill_handler& other)
;
buffered_fill_handler(buffered_fill_handler&& other)
;
void operator()(const boost::system::error_code& ec,
const std::size_t bytes_transferred)
;
detail::buffered_stream_storage& storage_;
std::size_t previous_size_;
ReadHandler handler_;
};
template <typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
buffered_fill_handler<ReadHandler>* this_handler)
;
template <typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
buffered_fill_handler<ReadHandler>* this_handler)
;
template <typename ReadHandler>
bool asio_handler_is_continuation(
buffered_fill_handler<ReadHandler>* this_handler)
;
template <typename Function, typename ReadHandler>
void asio_handler_invoke(Function& function,
buffered_fill_handler<ReadHandler>* this_handler)
;
template <typename Function, typename ReadHandler>
void asio_handler_invoke(const Function& function,
buffered_fill_handler<ReadHandler>* this_handler)
;
}
namespace detail
{
template <typename MutableBufferSequence, typename ReadHandler>
class buffered_read_some_handler
{
public:
buffered_read_some_handler(detail::buffered_stream_storage& storage,
const MutableBufferSequence& buffers, ReadHandler& handler)
;
buffered_read_some_handler(const buffered_read_some_handler& other)
;
buffered_read_some_handler(buffered_read_some_handler&& other)
;
void operator()(const boost::system::error_code& ec, std::size_t)
;
detail::buffered_stream_storage& storage_;
MutableBufferSequence buffers_;
ReadHandler handler_;
};
template <typename MutableBufferSequence, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
buffered_read_some_handler<
MutableBufferSequence, ReadHandler>* this_handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
buffered_read_some_handler<
MutableBufferSequence, ReadHandler>* this_handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
bool asio_handler_is_continuation(
buffered_read_some_handler<
MutableBufferSequence, ReadHandler>* this_handler)
;
template <typename Function, typename MutableBufferSequence,
typename ReadHandler>
void asio_handler_invoke(Function& function,
buffered_read_some_handler<
MutableBufferSequence, ReadHandler>* this_handler)
;
template <typename Function, typename MutableBufferSequence,
typename ReadHandler>
void asio_handler_invoke(const Function& function,
buffered_read_some_handler<
MutableBufferSequence, ReadHandler>* this_handler)
;
}
}
}
#define BOOST_ASIO_BUFFERED_STREAM_FWD_HPP
namespace boost {
namespace asio {
template <typename Stream>
class buffered_stream;
}
}
#define BOOST_ASIO_BUFFERED_STREAM_HPP
#define BOOST_ASIO_BUFFERED_WRITE_STREAM_HPP
#define BOOST_ASIO_BUFFERED_WRITE_STREAM_FWD_HPP
namespace boost {
namespace asio {
template <typename Stream>
class buffered_write_stream;
}
}
#define BOOST_ASIO_COMPLETION_CONDITION_HPP
namespace boost {
namespace asio {
namespace detail {
enum { default_max_transfer_size = 65536 };
std::size_t adapt_completion_condition_result(bool result)
;
std::size_t adapt_completion_condition_result(std::size_t result)
;
class transfer_all_t
{
public:
typedef std::size_t result_type;
template <typename Error>
std::size_t operator()(const Error& err, std::size_t)
;
};
class transfer_at_least_t
{
public:
typedef std::size_t result_type;
explicit transfer_at_least_t(std::size_t minimum)
;
template <typename Error>
std::size_t operator()(const Error& err, std::size_t bytes_transferred)
;
private:
std::size_t minimum_;
};
class transfer_exactly_t
{
public:
typedef std::size_t result_type;
explicit transfer_exactly_t(std::size_t size)
;
template <typename Error>
std::size_t operator()(const Error& err, std::size_t bytes_transferred)
;
private:
std::size_t size_;
};
}
detail::transfer_all_t transfer_all()
;
detail::transfer_at_least_t transfer_at_least(std::size_t minimum)
;
detail::transfer_exactly_t transfer_exactly(std::size_t size)
;
}
}
#define BOOST_ASIO_WRITE_HPP
namespace boost {
namespace asio {
template <typename SyncWriteStream, typename ConstBufferSequence>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers);
template <typename SyncWriteStream, typename ConstBufferSequence>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
boost::system::error_code& ec);
template <typename SyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
CompletionCondition completion_condition);
template <typename SyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
CompletionCondition completion_condition, boost::system::error_code& ec);
template <typename SyncWriteStream, typename Allocator>
std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b);
template <typename SyncWriteStream, typename Allocator>
std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
boost::system::error_code& ec);
template <typename SyncWriteStream, typename Allocator,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition);
template <typename SyncWriteStream, typename Allocator,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition, boost::system::error_code& ec);
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
WriteHandler&& handler);
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
CompletionCondition completion_condition,
WriteHandler&& handler);
template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
WriteHandler&& handler);
template <typename AsyncWriteStream, typename Allocator,
typename CompletionCondition, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition,
WriteHandler&& handler);
}
}
#define BOOST_ASIO_IMPL_WRITE_HPP
#define BOOST_ASIO_DETAIL_BASE_FROM_COMPLETION_COND_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename CompletionCondition>
class base_from_completion_cond
{
protected:
explicit base_from_completion_cond(CompletionCondition completion_condition)
;
std::size_t check_for_completion(
const boost::system::error_code& ec,
std::size_t total_transferred)
;
private:
CompletionCondition completion_condition_;
};
template <>
class base_from_completion_cond<transfer_all_t>
{
protected:
explicit base_from_completion_cond(transfer_all_t)
;
static std::size_t check_for_completion(
const boost::system::error_code& ec,
std::size_t total_transferred)
;
};
}
}
}
#define BOOST_ASIO_DETAIL_CONSUMING_BUFFERS_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Buffer, typename Buffer_Iterator>
class consuming_buffers_iterator
{
public:
typedef std::ptrdiff_t difference_type;
typedef Buffer value_type;
typedef const Buffer* pointer;
typedef const Buffer& reference;
typedef std::forward_iterator_tag iterator_category;
consuming_buffers_iterator()
;
consuming_buffers_iterator(bool at_end, const Buffer& first,
Buffer_Iterator begin_remainder, Buffer_Iterator end_remainder,
std::size_t max_size)
;
const Buffer& operator*() const
;
const Buffer* operator->() const
;
consuming_buffers_iterator& operator++()
;
consuming_buffers_iterator operator++(int)
;
friend bool operator==(const consuming_buffers_iterator& a,
const consuming_buffers_iterator& b)
;
friend bool operator!=(const consuming_buffers_iterator& a,
const consuming_buffers_iterator& b)
;
private:
void increment()
;
bool equal(const consuming_buffers_iterator& other) const
;
const Buffer& dereference() const
;
bool at_end_;
Buffer first_;
Buffer_Iterator begin_remainder_;
Buffer_Iterator end_remainder_;
std::size_t offset_;
std::size_t max_size_;
};
template <typename Buffer, typename Buffers>
class consuming_buffers
{
public:
typedef Buffer value_type;
typedef consuming_buffers_iterator<Buffer, typename Buffers::const_iterator>
const_iterator;
consuming_buffers(const Buffers& buffers)
: buffers_(buffers),
at_end_(buffers_.begin() == buffers_.end()),
begin_remainder_(buffers_.begin()),
max_size_((std::numeric_limits<std::size_t>::max)())
{
if (!at_end_)
{
first_ = *buffers_.begin();
++begin_remainder_;
}
}
consuming_buffers(const consuming_buffers& other)
: buffers_(other.buffers_),
at_end_(other.at_end_),
first_(other.first_),
begin_remainder_(buffers_.begin()),
max_size_(other.max_size_)
{
typename Buffers::const_iterator first = other.buffers_.begin();
typename Buffers::const_iterator second = other.begin_remainder_;
std::advance(begin_remainder_, std::distance(first, second));
}
consuming_buffers& operator=(const consuming_buffers& other)
{
buffers_ = other.buffers_;
at_end_ = other.at_end_;
first_ = other.first_;
begin_remainder_ = buffers_.begin();
typename Buffers::const_iterator first = other.buffers_.begin();
typename Buffers::const_iterator second = other.begin_remainder_;
std::advance(begin_remainder_, std::distance(first, second));
max_size_ = other.max_size_;
return *this;
}
const_iterator begin() const
;
const_iterator end() const
;
void prepare(std::size_t max_size)
;
void consume(std::size_t size)
;
private:
Buffers buffers_;
bool at_end_;
Buffer first_;
typename Buffers::const_iterator begin_remainder_;
std::size_t max_size_;
};
template <typename Buffer>
class consuming_buffers<Buffer, boost::asio::null_buffers>
: public boost::asio::null_buffers
{
public:
consuming_buffers(const boost::asio::null_buffers&)
;
void prepare(std::size_t)
;
void consume(std::size_t)
;
};
}
}
}
#define BOOST_ASIO_DETAIL_DEPENDENT_TYPE_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename DependsOn, typename T>
struct dependent_type
{
typedef T type;
};
}
}
}
namespace boost {
namespace asio {
template <typename SyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
CompletionCondition completion_condition, boost::system::error_code& ec)
;
template <typename SyncWriteStream, typename ConstBufferSequence>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers)
;
template <typename SyncWriteStream, typename ConstBufferSequence>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename SyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
CompletionCondition completion_condition)
;
template <typename SyncWriteStream, typename Allocator,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s,
boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition, boost::system::error_code& ec)
;
template <typename SyncWriteStream, typename Allocator>
std::size_t write(SyncWriteStream& s,
boost::asio::basic_streambuf<Allocator>& b)
;
template <typename SyncWriteStream, typename Allocator>
std::size_t write(SyncWriteStream& s,
boost::asio::basic_streambuf<Allocator>& b,
boost::system::error_code& ec)
;
template <typename SyncWriteStream, typename Allocator,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s,
boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition)
;
namespace detail
{
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition, typename WriteHandler>
class write_op
: detail::base_from_completion_cond<CompletionCondition>
{
public:
write_op(AsyncWriteStream& stream, const ConstBufferSequence& buffers,
CompletionCondition completion_condition, WriteHandler& handler)
;
write_op(const write_op& other)
;
write_op(write_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncWriteStream& stream_;
boost::asio::detail::consuming_buffers<
const_buffer, ConstBufferSequence> buffers_;
int start_;
std::size_t total_transferred_;
WriteHandler handler_;
};
template <typename AsyncWriteStream,
typename CompletionCondition, typename WriteHandler>
class write_op<AsyncWriteStream, boost::asio::mutable_buffers_1,
CompletionCondition, WriteHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
write_op(AsyncWriteStream& stream,
const boost::asio::mutable_buffers_1& buffers,
CompletionCondition completion_condition,
WriteHandler& handler)
;
write_op(const write_op& other)
;
write_op(write_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncWriteStream& stream_;
boost::asio::mutable_buffer buffer_;
int start_;
std::size_t total_transferred_;
WriteHandler handler_;
};
template <typename AsyncWriteStream,
typename CompletionCondition, typename WriteHandler>
class write_op<AsyncWriteStream, boost::asio::const_buffers_1,
CompletionCondition, WriteHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
write_op(AsyncWriteStream& stream,
const boost::asio::const_buffers_1& buffers,
CompletionCondition completion_condition,
WriteHandler& handler)
;
write_op(const write_op& other)
;
write_op(write_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncWriteStream& stream_;
boost::asio::const_buffer buffer_;
int start_;
std::size_t total_transferred_;
WriteHandler handler_;
};
template <typename AsyncWriteStream, typename Elem,
typename CompletionCondition, typename WriteHandler>
class write_op<AsyncWriteStream, boost::array<Elem, 2>,
CompletionCondition, WriteHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
write_op(AsyncWriteStream& stream, const boost::array<Elem, 2>& buffers,
CompletionCondition completion_condition, WriteHandler& handler)
;
write_op(const write_op& other)
;
write_op(write_op&& other)
: detail::base_from_completion_cond<CompletionCondition>(other),
stream_(other.stream_),
buffers_(other.buffers_),
start_(other.start_),
total_transferred_(other.total_transferred_),
handler_(static_cast<WriteHandler&&>(other.handler_))
{
}
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
{
typename boost::asio::detail::dependent_type<Elem,
boost::array<boost::asio::const_buffer, 2> >::type bufs = {{
boost::asio::const_buffer(buffers_[0]),
boost::asio::const_buffer(buffers_[1]) }};
std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
std::size_t n = 0;
switch (start_ = start)
{
case 1:
n = this->check_for_completion(ec, total_transferred_);
for (;;)
{
bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
bufs[1] = boost::asio::buffer(
bufs[1] + (total_transferred_ < buffer_size0
? 0 : total_transferred_ - buffer_size0),
n - boost::asio::buffer_size(bufs[0]));
stream_.async_write_some(bufs, static_cast<write_op&&>(*this));
return; default:
total_transferred_ += bytes_transferred;
if ((!ec && bytes_transferred == 0)
|| (n = this->check_for_completion(ec, total_transferred_)) == 0
|| total_transferred_ == buffer_size0 + buffer_size1)
break;
}
handler_(ec, static_cast<const std::size_t&>(total_transferred_));
}
}
AsyncWriteStream& stream_;
boost::array<Elem, 2> buffers_;
int start_;
std::size_t total_transferred_;
WriteHandler handler_;
};
template <typename AsyncWriteStream, typename Elem,
typename CompletionCondition, typename WriteHandler>
class write_op<AsyncWriteStream, std::array<Elem, 2>,
CompletionCondition, WriteHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
write_op(AsyncWriteStream& stream, const std::array<Elem, 2>& buffers,
CompletionCondition completion_condition, WriteHandler& handler)
;
write_op(const write_op& other)
;
write_op(write_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncWriteStream& stream_;
std::array<Elem, 2> buffers_;
int start_;
std::size_t total_transferred_;
WriteHandler handler_;
};
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition, typename WriteHandler>
void* asio_handler_allocate(std::size_t size,
write_op<AsyncWriteStream, ConstBufferSequence,
CompletionCondition, WriteHandler>* this_handler)
;
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition, typename WriteHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
write_op<AsyncWriteStream, ConstBufferSequence,
CompletionCondition, WriteHandler>* this_handler)
;
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition, typename WriteHandler>
bool asio_handler_is_continuation(
write_op<AsyncWriteStream, ConstBufferSequence,
CompletionCondition, WriteHandler>* this_handler)
;
template <typename Function, typename AsyncWriteStream,
typename ConstBufferSequence, typename CompletionCondition,
typename WriteHandler>
void asio_handler_invoke(Function& function,
write_op<AsyncWriteStream, ConstBufferSequence,
CompletionCondition, WriteHandler>* this_handler)
;
template <typename Function, typename AsyncWriteStream,
typename ConstBufferSequence, typename CompletionCondition,
typename WriteHandler>
void asio_handler_invoke(const Function& function,
write_op<AsyncWriteStream, ConstBufferSequence,
CompletionCondition, WriteHandler>* this_handler)
;
}
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
CompletionCondition completion_condition,
WriteHandler&& handler)
;
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
namespace detail
{
template <typename Allocator, typename WriteHandler>
class write_streambuf_handler
{
public:
write_streambuf_handler(boost::asio::basic_streambuf<Allocator>& streambuf,
WriteHandler& handler)
;
write_streambuf_handler(const write_streambuf_handler& other)
;
write_streambuf_handler(write_streambuf_handler&& other)
;
void operator()(const boost::system::error_code& ec,
const std::size_t bytes_transferred)
;
boost::asio::basic_streambuf<Allocator>& streambuf_;
WriteHandler handler_;
};
template <typename Allocator, typename WriteHandler>
void* asio_handler_allocate(std::size_t size,
write_streambuf_handler<Allocator, WriteHandler>* this_handler)
;
template <typename Allocator, typename WriteHandler>
inline void asio_handler_deallocate(void* pointer, std::size_t size,
write_streambuf_handler<Allocator, WriteHandler>* this_handler)
{
boost_asio_handler_alloc_helpers::deallocate(
pointer, size, this_handler->handler_);
}
template <typename Allocator, typename WriteHandler>
inline bool asio_handler_is_continuation(
write_streambuf_handler<Allocator, WriteHandler>* this_handler)
{
return boost_asio_handler_cont_helpers::is_continuation(
this_handler->handler_);
}
template <typename Function, typename Allocator, typename WriteHandler>
inline void asio_handler_invoke(Function& function,
write_streambuf_handler<Allocator, WriteHandler>* this_handler)
{
boost_asio_handler_invoke_helpers::invoke(
function, this_handler->handler_);
}
template <typename Function, typename Allocator, typename WriteHandler>
inline void asio_handler_invoke(const Function& function,
write_streambuf_handler<Allocator, WriteHandler>* this_handler)
{
boost_asio_handler_invoke_helpers::invoke(
function, this_handler->handler_);
}
}
template <typename AsyncWriteStream, typename Allocator,
typename CompletionCondition, typename WriteHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s,
boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition,
WriteHandler&& handler)
{
typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
detail::async_result_init<
WriteHandler, void (boost::system::error_code, std::size_t)> init(
static_cast<WriteHandler&&>(handler));
async_write(s, b.data(), completion_condition,
detail::write_streambuf_handler<Allocator, typename handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>(
b, init.handler));
return init.result.get();
}
template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s,
boost::asio::basic_streambuf<Allocator>& b,
WriteHandler&& handler)
{
typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
detail::async_result_init<
WriteHandler, void (boost::system::error_code, std::size_t)> init(
static_cast<WriteHandler&&>(handler));
async_write(s, b.data(), transfer_all(),
detail::write_streambuf_handler<Allocator, typename handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>(
b, init.handler));
return init.result.get();
}
}
}
namespace boost {
namespace asio {
template <typename Stream>
class buffered_write_stream
: private noncopyable
{
public:
typedef typename remove_reference<Stream>::type next_layer_type;
typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
static const std::size_t default_buffer_size = 1024;
template <typename Arg>
explicit buffered_write_stream(Arg& a)
: next_layer_(a),
storage_(default_buffer_size)
{
}
template <typename Arg>
buffered_write_stream(Arg& a, std::size_t buffer_size)
: next_layer_(a),
storage_(buffer_size)
{
}
next_layer_type& next_layer()
;
lowest_layer_type& lowest_layer()
;
const lowest_layer_type& lowest_layer() const
;
boost::asio::io_service& get_io_service()
;
void close()
;
boost::system::error_code close(boost::system::error_code& ec)
;
std::size_t flush();
std::size_t flush(boost::system::error_code& ec);
template <typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_flush(WriteHandler&& handler);
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers);
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers,
boost::system::error_code& ec);
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(const ConstBufferSequence& buffers,
WriteHandler&& handler);
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t peek(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t peek(const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
std::size_t in_avail()
;
std::size_t in_avail(boost::system::error_code& ec)
;
private:
template <typename ConstBufferSequence>
std::size_t copy(const ConstBufferSequence& buffers);
Stream next_layer_;
detail::buffered_stream_storage storage_;
};
}
}
#define BOOST_ASIO_IMPL_BUFFERED_WRITE_STREAM_HPP
namespace boost {
namespace asio {
namespace detail
{
template <typename WriteHandler>
class buffered_flush_handler
{
public:
buffered_flush_handler(detail::buffered_stream_storage& storage,
WriteHandler& handler)
;
buffered_flush_handler(const buffered_flush_handler& other)
;
buffered_flush_handler(buffered_flush_handler&& other)
;
void operator()(const boost::system::error_code& ec,
const std::size_t bytes_written)
;
detail::buffered_stream_storage& storage_;
WriteHandler handler_;
};
template <typename WriteHandler>
void* asio_handler_allocate(std::size_t size,
buffered_flush_handler<WriteHandler>* this_handler)
;
template <typename WriteHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
buffered_flush_handler<WriteHandler>* this_handler)
;
template <typename WriteHandler>
bool asio_handler_is_continuation(
buffered_flush_handler<WriteHandler>* this_handler)
;
template <typename Function, typename WriteHandler>
void asio_handler_invoke(Function& function,
buffered_flush_handler<WriteHandler>* this_handler)
;
template <typename Function, typename WriteHandler>
void asio_handler_invoke(const Function& function,
buffered_flush_handler<WriteHandler>* this_handler)
;
}
namespace detail
{
template <typename ConstBufferSequence, typename WriteHandler>
class buffered_write_some_handler
{
public:
buffered_write_some_handler(detail::buffered_stream_storage& storage,
const ConstBufferSequence& buffers, WriteHandler& handler)
;
buffered_write_some_handler(const buffered_write_some_handler& other)
;
buffered_write_some_handler(buffered_write_some_handler&& other)
;
void operator()(const boost::system::error_code& ec, std::size_t)
;
detail::buffered_stream_storage& storage_;
ConstBufferSequence buffers_;
WriteHandler handler_;
};
template <typename ConstBufferSequence, typename WriteHandler>
void* asio_handler_allocate(std::size_t size,
buffered_write_some_handler<
ConstBufferSequence, WriteHandler>* this_handler)
;
template <typename ConstBufferSequence, typename WriteHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
buffered_write_some_handler<
ConstBufferSequence, WriteHandler>* this_handler)
;
template <typename ConstBufferSequence, typename WriteHandler>
bool asio_handler_is_continuation(
buffered_write_some_handler<
ConstBufferSequence, WriteHandler>* this_handler)
;
template <typename Function, typename ConstBufferSequence,
typename WriteHandler>
void asio_handler_invoke(Function& function,
buffered_write_some_handler<
ConstBufferSequence, WriteHandler>* this_handler)
;
template <typename Function, typename ConstBufferSequence,
typename WriteHandler>
void asio_handler_invoke(const Function& function,
buffered_write_some_handler<
ConstBufferSequence, WriteHandler>* this_handler)
;
}
}
}
namespace boost {
namespace asio {
template <typename Stream>
class buffered_stream
: private noncopyable
{
public:
typedef typename remove_reference<Stream>::type next_layer_type;
typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
template <typename Arg>
explicit buffered_stream(Arg& a)
;
template <typename Arg>
explicit buffered_stream(Arg& a, std::size_t read_buffer_size,
std::size_t write_buffer_size)
;
next_layer_type& next_layer()
;
lowest_layer_type& lowest_layer()
;
const lowest_layer_type& lowest_layer() const
;
boost::asio::io_service& get_io_service()
;
void close()
;
boost::system::error_code close(boost::system::error_code& ec)
;
std::size_t flush()
;
std::size_t flush(boost::system::error_code& ec)
;
template <typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_flush(WriteHandler&& handler)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
std::size_t fill()
;
std::size_t fill(boost::system::error_code& ec)
;
template <typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_fill(ReadHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t peek(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t peek(const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
std::size_t in_avail()
;
std::size_t in_avail(boost::system::error_code& ec)
;
private:
typedef buffered_write_stream<Stream> write_stream_type;
write_stream_type inner_stream_impl_;
typedef buffered_read_stream<write_stream_type&> read_stream_type;
read_stream_type stream_impl_;
};
}
}
#define BOOST_ASIO_BUFFERS_ITERATOR_HPP
namespace boost {
namespace asio {
namespace detail
{
template <bool IsMutable>
struct buffers_iterator_types_helper;
template <>
struct buffers_iterator_types_helper<false>
{
typedef const_buffer buffer_type;
template <typename ByteType>
struct byte_type
{
typedef typename add_const<ByteType>::type type;
};
};
template <>
struct buffers_iterator_types_helper<true>
{
typedef mutable_buffer buffer_type;
template <typename ByteType>
struct byte_type
{
typedef ByteType type;
};
};
template <typename BufferSequence, typename ByteType>
struct buffers_iterator_types
{
enum
{
is_mutable = is_convertible<
typename BufferSequence::value_type,
mutable_buffer>::value
};
typedef buffers_iterator_types_helper<is_mutable> helper;
typedef typename helper::buffer_type buffer_type;
typedef typename helper::template byte_type<ByteType>::type byte_type;
};
}
template <typename BufferSequence, typename ByteType = char>
class buffers_iterator
{
private:
typedef typename detail::buffers_iterator_types<
BufferSequence, ByteType>::buffer_type buffer_type;
public:
typedef std::ptrdiff_t difference_type;
typedef ByteType value_type;
typedef typename detail::buffers_iterator_types<
BufferSequence, ByteType>::byte_type* pointer;
typedef typename detail::buffers_iterator_types<
BufferSequence, ByteType>::byte_type& reference;
typedef std::random_access_iterator_tag iterator_category;
buffers_iterator()
;
static buffers_iterator begin(const BufferSequence& buffers)
;
static buffers_iterator end(const BufferSequence& buffers)
;
reference operator*() const
;
pointer operator->() const
;
reference operator[](std::ptrdiff_t difference) const
;
buffers_iterator& operator++()
;
buffers_iterator operator++(int)
;
buffers_iterator& operator--()
;
buffers_iterator operator--(int)
;
buffers_iterator& operator+=(std::ptrdiff_t difference)
;
buffers_iterator& operator-=(std::ptrdiff_t difference)
;
friend buffers_iterator operator+(const buffers_iterator& iter,
std::ptrdiff_t difference)
;
friend buffers_iterator operator+(std::ptrdiff_t difference,
const buffers_iterator& iter)
;
friend buffers_iterator operator-(const buffers_iterator& iter,
std::ptrdiff_t difference)
;
friend std::ptrdiff_t operator-(const buffers_iterator& a,
const buffers_iterator& b)
;
friend bool operator==(const buffers_iterator& a, const buffers_iterator& b)
;
friend bool operator!=(const buffers_iterator& a, const buffers_iterator& b)
;
friend bool operator<(const buffers_iterator& a, const buffers_iterator& b)
;
friend bool operator<=(const buffers_iterator& a, const buffers_iterator& b)
;
friend bool operator>(const buffers_iterator& a, const buffers_iterator& b)
;
friend bool operator>=(const buffers_iterator& a, const buffers_iterator& b)
;
private:
reference dereference() const
;
bool equal(const buffers_iterator& other) const
;
void increment()
;
void decrement()
;
void advance(std::ptrdiff_t n)
;
std::ptrdiff_t distance_to(const buffers_iterator& other) const
;
buffer_type current_buffer_;
std::size_t current_buffer_position_;
typename BufferSequence::const_iterator begin_;
typename BufferSequence::const_iterator current_;
typename BufferSequence::const_iterator end_;
std::size_t position_;
};
template <typename BufferSequence>
buffers_iterator<BufferSequence> buffers_begin(
const BufferSequence& buffers)
;
template <typename BufferSequence>
buffers_iterator<BufferSequence> buffers_end(
const BufferSequence& buffers)
;
}
}
#define BOOST_ASIO_CONNECT_HPP
namespace boost {
namespace asio {
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin);
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, boost::system::error_code& ec);
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end);
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, boost::system::error_code& ec);
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, ConnectCondition connect_condition);
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
ConnectCondition connect_condition, boost::system::error_code& ec);
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
Iterator end, ConnectCondition connect_condition);
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, ConnectCondition connect_condition,
boost::system::error_code& ec);
template <typename Protocol, typename SocketService,
typename Iterator, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, ComposedConnectHandler&& handler);
template <typename Protocol, typename SocketService,
typename Iterator, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end,
ComposedConnectHandler&& handler);
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
ConnectCondition connect_condition,
ComposedConnectHandler&& handler);
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, ConnectCondition connect_condition,
ComposedConnectHandler&& handler);
}
}
#define BOOST_ASIO_IMPL_CONNECT_HPP
namespace boost {
namespace asio {
namespace detail
{
struct default_connect_condition
{
template <typename Iterator>
Iterator operator()(const boost::system::error_code&, Iterator next)
;
};
}
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin)
;
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, boost::system::error_code& ec)
;
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end)
;
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, boost::system::error_code& ec)
;
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, ConnectCondition connect_condition)
;
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, ConnectCondition connect_condition,
boost::system::error_code& ec)
;
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, ConnectCondition connect_condition)
;
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, ConnectCondition connect_condition,
boost::system::error_code& ec)
;
namespace detail
{
template <typename ConnectCondition>
class base_from_connect_condition
{
protected:
explicit base_from_connect_condition(
const ConnectCondition& connect_condition)
;
template <typename Iterator>
void check_condition(const boost::system::error_code& ec,
Iterator& iter, Iterator& end)
;
private:
ConnectCondition connect_condition_;
};
template <>
class base_from_connect_condition<default_connect_condition>
{
protected:
explicit base_from_connect_condition(const default_connect_condition&)
;
template <typename Iterator>
void check_condition(const boost::system::error_code&, Iterator&, Iterator&)
;
};
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
class connect_op : base_from_connect_condition<ConnectCondition>
{
public:
connect_op(basic_socket<Protocol, SocketService>& sock,
const Iterator& begin, const Iterator& end,
const ConnectCondition& connect_condition,
ComposedConnectHandler& handler)
;
connect_op(const connect_op& other)
;
connect_op(connect_op&& other)
;
void operator()(boost::system::error_code ec, int start = 0)
;
basic_socket<Protocol, SocketService>& socket_;
Iterator iter_;
Iterator end_;
int start_;
ComposedConnectHandler handler_;
};
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
void* asio_handler_allocate(std::size_t size,
connect_op<Protocol, SocketService, Iterator,
ConnectCondition, ComposedConnectHandler>* this_handler)
;
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
connect_op<Protocol, SocketService, Iterator,
ConnectCondition, ComposedConnectHandler>* this_handler)
;
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
bool asio_handler_is_continuation(
connect_op<Protocol, SocketService, Iterator,
ConnectCondition, ComposedConnectHandler>* this_handler)
;
template <typename Function, typename Protocol,
typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
void asio_handler_invoke(Function& function,
connect_op<Protocol, SocketService, Iterator,
ConnectCondition, ComposedConnectHandler>* this_handler)
;
template <typename Function, typename Protocol,
typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
void asio_handler_invoke(const Function& function,
connect_op<Protocol, SocketService, Iterator,
ConnectCondition, ComposedConnectHandler>* this_handler)
;
}
template <typename Protocol, typename SocketService,
typename Iterator, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, ComposedConnectHandler&& handler)
;
template <typename Protocol, typename SocketService,
typename Iterator, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end,
ComposedConnectHandler&& handler)
;
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, ConnectCondition connect_condition,
ComposedConnectHandler&& handler)
;
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, ConnectCondition connect_condition,
ComposedConnectHandler&& handler)
;
}
}
#define BOOST_ASIO_COROUTINE_HPP
namespace boost {
namespace asio {
namespace detail {
class coroutine_ref;
}
class coroutine
{
public:
coroutine() ;
bool is_child() const ;
bool is_parent() const ;
bool is_complete() const ;
private:
friend class detail::coroutine_ref;
int value_;
};
namespace detail {
class coroutine_ref
{
public:
coroutine_ref(coroutine& c) ;
coroutine_ref(coroutine* c) ;
~coroutine_ref() ;
operator int() const ;
int& operator=(int v) ;
private:
void operator=(const coroutine_ref&);
int& value_;
bool modified_;
};
}
}
}
#define BOOST_ASIO_CORO_REENTER(c) switch (::boost::asio::detail::coroutine_ref _coro_value = c) case -1: if (_coro_value) { goto terminate_coroutine; terminate_coroutine: _coro_value = -1; goto bail_out_of_coroutine; bail_out_of_coroutine: break; } else case 0:
#define BOOST_ASIO_CORO_YIELD_IMPL(n) for (_coro_value = (n);;) if (_coro_value == 0) { case (n): ; break; } else switch (_coro_value ? 0 : 1) for (;;) case -1: if (_coro_value) goto terminate_coroutine; else for (;;) case 1: if (_coro_value) goto bail_out_of_coroutine; else case 0:
#define BOOST_ASIO_CORO_FORK_IMPL(n) for (_coro_value = -(n);; _coro_value = (n)) if (_coro_value == (n)) { case -(n): ; break; } else
#define BOOST_ASIO_CORO_YIELD BOOST_ASIO_CORO_YIELD_IMPL(__LINE__)
#define BOOST_ASIO_CORO_FORK BOOST_ASIO_CORO_FORK_IMPL(__LINE__)
#define BOOST_ASIO_GENERIC_BASIC_ENDPOINT_HPP
#define BOOST_ASIO_GENERIC_DETAIL_ENDPOINT_HPP
namespace boost {
namespace asio {
namespace generic {
namespace detail {
class endpoint
{
public:
inline endpoint();
inline endpoint(const void* sock_addr,
std::size_t sock_addr_size, int sock_protocol);
endpoint(const endpoint& other)
;
endpoint& operator=(const endpoint& other)
;
int family() const
;
int protocol() const
;
boost::asio::detail::socket_addr_type* data()
;
const boost::asio::detail::socket_addr_type* data() const
;
std::size_t size() const
;
inline void resize(std::size_t size);
std::size_t capacity() const
;
inline friend bool operator==(
const endpoint& e1, const endpoint& e2);
inline friend bool operator<(
const endpoint& e1, const endpoint& e2);
private:
union data_union
{
boost::asio::detail::socket_addr_type base;
boost::asio::detail::sockaddr_storage_type generic;
} data_;
std::size_t size_;
int protocol_;
inline void init(const void* sock_addr,
std::size_t sock_addr_size, int sock_protocol);
};
}
}
}
}
#define BOOST_ASIO_GENERIC_DETAIL_IMPL_ENDPOINT_IPP
namespace boost {
namespace asio {
namespace generic {
namespace detail {
bool operator==(const endpoint& e1, const endpoint& e2)
;
bool operator<(const endpoint& e1, const endpoint& e2)
;
}
}
}
}
namespace boost {
namespace asio {
namespace generic {
template <typename Protocol>
class basic_endpoint
{
public:
typedef Protocol protocol_type;
typedef boost::asio::detail::socket_addr_type data_type;
basic_endpoint()
;
basic_endpoint(const void* socket_address,
std::size_t socket_address_size, int socket_protocol = 0)
;
template <typename Endpoint>
basic_endpoint(const Endpoint& endpoint)
;
basic_endpoint(const basic_endpoint& other)
;
basic_endpoint(basic_endpoint&& other)
;
basic_endpoint& operator=(const basic_endpoint& other)
;
basic_endpoint& operator=(basic_endpoint&& other)
;
protocol_type protocol() const
;
data_type* data()
;
const data_type* data() const
;
std::size_t size() const
;
void resize(std::size_t new_size)
;
std::size_t capacity() const
;
friend bool operator==(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator!=(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator<(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator>(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator<=(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator>=(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
private:
boost::asio::generic::detail::endpoint impl_;
};
}
}
}
#define BOOST_ASIO_GENERIC_DATAGRAM_PROTOCOL_HPP
namespace boost {
namespace asio {
namespace generic {
class datagram_protocol
{
public:
datagram_protocol(int address_family, int socket_protocol)
;
template <typename Protocol>
datagram_protocol(const Protocol& source_protocol)
;
int type() const
;
int protocol() const
;
int family() const
;
friend bool operator==(const datagram_protocol& p1,
const datagram_protocol& p2)
;
friend bool operator!=(const datagram_protocol& p1,
const datagram_protocol& p2)
;
typedef basic_endpoint<datagram_protocol> endpoint;
typedef basic_datagram_socket<datagram_protocol> socket;
private:
int family_;
int protocol_;
};
}
}
}
#define BOOST_ASIO_GENERIC_RAW_PROTOCOL_HPP
namespace boost {
namespace asio {
namespace generic {
class raw_protocol
{
public:
raw_protocol(int address_family, int socket_protocol)
;
template <typename Protocol>
raw_protocol(const Protocol& source_protocol)
;
int type() const
;
int protocol() const
;
int family() const
;
friend bool operator==(const raw_protocol& p1, const raw_protocol& p2)
;
friend bool operator!=(const raw_protocol& p1, const raw_protocol& p2)
;
typedef basic_endpoint<raw_protocol> endpoint;
typedef basic_raw_socket<raw_protocol> socket;
private:
int family_;
int protocol_;
};
}
}
}
#define BOOST_ASIO_GENERIC_SEQ_PACKET_PROTOCOL_HPP
namespace boost {
namespace asio {
namespace generic {
class seq_packet_protocol
{
public:
seq_packet_protocol(int address_family, int socket_protocol)
;
template <typename Protocol>
seq_packet_protocol(const Protocol& source_protocol)
;
int type() const
;
int protocol() const
;
int family() const
;
friend bool operator==(const seq_packet_protocol& p1,
const seq_packet_protocol& p2)
;
friend bool operator!=(const seq_packet_protocol& p1,
const seq_packet_protocol& p2)
;
typedef basic_endpoint<seq_packet_protocol> endpoint;
typedef basic_seq_packet_socket<seq_packet_protocol> socket;
private:
int family_;
int protocol_;
};
}
}
}
#define BOOST_ASIO_GENERIC_STREAM_PROTOCOL_HPP
namespace boost {
namespace asio {
namespace generic {
class stream_protocol
{
public:
stream_protocol(int address_family, int socket_protocol)
;
template <typename Protocol>
stream_protocol(const Protocol& source_protocol)
;
int type() const
;
int protocol() const
;
int family() const
;
friend bool operator==(const stream_protocol& p1, const stream_protocol& p2)
;
friend bool operator!=(const stream_protocol& p1, const stream_protocol& p2)
;
typedef basic_endpoint<stream_protocol> endpoint;
typedef basic_stream_socket<stream_protocol> socket;
typedef basic_socket_iostream<stream_protocol> iostream;
private:
int family_;
int protocol_;
};
}
}
}
#define BOOST_ASIO_IP_ADDRESS_HPP
#define BOOST_ASIO_IP_ADDRESS_V4_HPP
#define BOOST_ASIO_DETAIL_WINSOCK_INIT_HPP
namespace boost {
namespace asio {
namespace ip {
class address_v4
{
public:
typedef boost::asio::detail::array<unsigned char, 4> bytes_type;
address_v4()
;
inline explicit address_v4(const bytes_type& bytes);
inline explicit address_v4(unsigned long addr);
address_v4(const address_v4& other)
;
address_v4(address_v4&& other)
;
address_v4& operator=(const address_v4& other)
;
address_v4& operator=(address_v4&& other)
;
inline bytes_type to_bytes() const;
inline unsigned long to_ulong() const;
inline std::string to_string() const;
inline std::string to_string(boost::system::error_code& ec) const;
inline static address_v4 from_string(const char* str);
inline static address_v4 from_string(
const char* str, boost::system::error_code& ec);
inline static address_v4 from_string(const std::string& str);
inline static address_v4 from_string(
const std::string& str, boost::system::error_code& ec);
inline bool is_loopback() const;
inline bool is_unspecified() const;
inline bool is_class_a() const;
inline bool is_class_b() const;
inline bool is_class_c() const;
inline bool is_multicast() const;
friend bool operator==(const address_v4& a1, const address_v4& a2)
;
friend bool operator!=(const address_v4& a1, const address_v4& a2)
;
friend bool operator<(const address_v4& a1, const address_v4& a2)
;
friend bool operator>(const address_v4& a1, const address_v4& a2)
;
friend bool operator<=(const address_v4& a1, const address_v4& a2)
;
friend bool operator>=(const address_v4& a1, const address_v4& a2)
;
static address_v4 any()
;
static address_v4 loopback()
;
static address_v4 broadcast()
;
inline static address_v4 broadcast(
const address_v4& addr, const address_v4& mask);
inline static address_v4 netmask(const address_v4& addr);
private:
boost::asio::detail::in4_addr_type addr_;
};
template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os, const address_v4& addr);
}
}
}
#define BOOST_ASIO_IP_IMPL_ADDRESS_V4_HPP
namespace boost {
namespace asio {
namespace ip {
template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os, const address_v4& addr)
;
}
}
}
#define BOOST_ASIO_IP_IMPL_ADDRESS_V4_IPP
namespace boost {
namespace asio {
namespace ip {
bool address_v4::is_loopback() const
{
return (to_ulong() & 0xFF000000) == 0x7F000000;
}
bool address_v4::is_unspecified() const
{
return to_ulong() == 0;
}
bool address_v4::is_class_a() const
{
return (to_ulong() & 0x80000000) == 0;
}
bool address_v4::is_class_b() const
{
return (to_ulong() & 0xC0000000) == 0x80000000;
}
bool address_v4::is_class_c() const
{
return (to_ulong() & 0xE0000000) == 0xC0000000;
}
bool address_v4::is_multicast() const
{
return (to_ulong() & 0xF0000000) == 0xE0000000;
}
}
}
}
#define BOOST_ASIO_IP_ADDRESS_V6_HPP
namespace boost {
namespace asio {
namespace ip {
class address_v6
{
public:
typedef boost::asio::detail::array<unsigned char, 16> bytes_type;
inline address_v6();
inline explicit address_v6(const bytes_type& bytes,
unsigned long scope_id = 0);
inline address_v6(const address_v6& other);
inline address_v6(address_v6&& other);
inline address_v6& operator=(const address_v6& other);
inline address_v6& operator=(address_v6&& other);
unsigned long scope_id() const
;
void scope_id(unsigned long id)
;
inline bytes_type to_bytes() const;
inline std::string to_string() const;
inline std::string to_string(boost::system::error_code& ec) const;
inline static address_v6 from_string(const char* str);
inline static address_v6 from_string(
const char* str, boost::system::error_code& ec);
inline static address_v6 from_string(const std::string& str);
inline static address_v6 from_string(
const std::string& str, boost::system::error_code& ec);
inline address_v4 to_v4() const;
inline bool is_loopback() const;
inline bool is_unspecified() const;
inline bool is_link_local() const;
inline bool is_site_local() const;
inline bool is_v4_mapped() const;
inline bool is_v4_compatible() const;
inline bool is_multicast() const;
inline bool is_multicast_global() const;
inline bool is_multicast_link_local() const;
inline bool is_multicast_node_local() const;
inline bool is_multicast_org_local() const;
inline bool is_multicast_site_local() const;
inline friend bool operator==(
const address_v6& a1, const address_v6& a2);
friend bool operator!=(const address_v6& a1, const address_v6& a2)
;
inline friend bool operator<(
const address_v6& a1, const address_v6& a2);
friend bool operator>(const address_v6& a1, const address_v6& a2)
;
friend bool operator<=(const address_v6& a1, const address_v6& a2)
;
friend bool operator>=(const address_v6& a1, const address_v6& a2)
;
static address_v6 any()
;
inline static address_v6 loopback();
inline static address_v6 v4_mapped(const address_v4& addr);
inline static address_v6 v4_compatible(const address_v4& addr);
private:
boost::asio::detail::in6_addr_type addr_;
unsigned long scope_id_;
};
template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os, const address_v6& addr);
}
}
}
#define BOOST_ASIO_IP_IMPL_ADDRESS_V6_HPP
namespace boost {
namespace asio {
namespace ip {
template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os, const address_v6& addr)
;
}
}
}
#define BOOST_ASIO_IP_IMPL_ADDRESS_V6_IPP
namespace boost {
namespace asio {
namespace ip {
bool address_v6::is_loopback() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
&& (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
&& (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
&& (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
&& (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
&& (addr_.__in6_u.__u6_addr8[10] == 0) && (addr_.__in6_u.__u6_addr8[11] == 0)
&& (addr_.__in6_u.__u6_addr8[12] == 0) && (addr_.__in6_u.__u6_addr8[13] == 0)
&& (addr_.__in6_u.__u6_addr8[14] == 0) && (addr_.__in6_u.__u6_addr8[15] == 1));
}
bool address_v6::is_unspecified() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
&& (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
&& (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
&& (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
&& (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
&& (addr_.__in6_u.__u6_addr8[10] == 0) && (addr_.__in6_u.__u6_addr8[11] == 0)
&& (addr_.__in6_u.__u6_addr8[12] == 0) && (addr_.__in6_u.__u6_addr8[13] == 0)
&& (addr_.__in6_u.__u6_addr8[14] == 0) && (addr_.__in6_u.__u6_addr8[15] == 0));
}
bool address_v6::is_link_local() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0xfe) && ((addr_.__in6_u.__u6_addr8[1] & 0xc0) == 0x80));
}
bool address_v6::is_site_local() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0xfe) && ((addr_.__in6_u.__u6_addr8[1] & 0xc0) == 0xc0));
}
bool address_v6::is_v4_mapped() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
&& (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
&& (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
&& (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
&& (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
&& (addr_.__in6_u.__u6_addr8[10] == 0xff) && (addr_.__in6_u.__u6_addr8[11] == 0xff));
}
bool address_v6::is_v4_compatible() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
&& (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
&& (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
&& (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
&& (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
&& (addr_.__in6_u.__u6_addr8[10] == 0) && (addr_.__in6_u.__u6_addr8[11] == 0)
&& !((addr_.__in6_u.__u6_addr8[12] == 0)
&& (addr_.__in6_u.__u6_addr8[13] == 0)
&& (addr_.__in6_u.__u6_addr8[14] == 0)
&& ((addr_.__in6_u.__u6_addr8[15] == 0) || (addr_.__in6_u.__u6_addr8[15] == 1))));
}
bool address_v6::is_multicast() const
{
return (addr_.__in6_u.__u6_addr8[0] == 0xff);
}
bool address_v6::is_multicast_global() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x0e));
}
bool address_v6::is_multicast_link_local() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x02));
}
bool address_v6::is_multicast_node_local() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x01));
}
bool address_v6::is_multicast_org_local() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x08));
}
bool address_v6::is_multicast_site_local() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x05));
}
bool operator==(const address_v6& a1, const address_v6& a2)
;
bool operator<(const address_v6& a1, const address_v6& a2)
;
}
}
}
namespace boost {
namespace asio {
namespace ip {
class address
{
public:
inline address();
inline address(const boost::asio::ip::address_v4& ipv4_address);
inline address(const boost::asio::ip::address_v6& ipv6_address);
inline address(const address& other);
inline address(address&& other);
inline address& operator=(const address& other);
inline address& operator=(address&& other);
inline address& operator=(
const boost::asio::ip::address_v4& ipv4_address);
inline address& operator=(
const boost::asio::ip::address_v6& ipv6_address);
bool is_v4() const
;
bool is_v6() const
;
inline boost::asio::ip::address_v4 to_v4() const;
inline boost::asio::ip::address_v6 to_v6() const;
inline std::string to_string() const;
inline std::string to_string(boost::system::error_code& ec) const;
inline static address from_string(const char* str);
inline static address from_string(
const char* str, boost::system::error_code& ec);
inline static address from_string(const std::string& str);
inline static address from_string(
const std::string& str, boost::system::error_code& ec);
inline bool is_loopback() const;
inline bool is_unspecified() const;
inline bool is_multicast() const;
inline friend bool operator==(const address& a1, const address& a2);
friend bool operator!=(const address& a1, const address& a2)
;
inline friend bool operator<(const address& a1, const address& a2);
friend bool operator>(const address& a1, const address& a2)
;
friend bool operator<=(const address& a1, const address& a2)
;
friend bool operator>=(const address& a1, const address& a2)
;
private:
enum { ipv4, ipv6 } type_;
boost::asio::ip::address_v4 ipv4_address_;
boost::asio::ip::address_v6 ipv6_address_;
};
template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os, const address& addr);
}
}
}
#define BOOST_ASIO_IP_IMPL_ADDRESS_HPP
namespace boost {
namespace asio {
namespace ip {
template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os, const address& addr)
;
}
}
}
#define BOOST_ASIO_IP_IMPL_ADDRESS_IPP
namespace boost {
namespace asio {
namespace ip {
bool address::is_loopback() const
{
return (type_ == ipv4)
? ipv4_address_.is_loopback()
: ipv6_address_.is_loopback();
}
bool address::is_unspecified() const
{
return (type_ == ipv4)
? ipv4_address_.is_unspecified()
: ipv6_address_.is_unspecified();
}
bool address::is_multicast() const
{
return (type_ == ipv4)
? ipv4_address_.is_multicast()
: ipv6_address_.is_multicast();
}
bool operator==(const address& a1, const address& a2)
;
bool operator<(const address& a1, const address& a2)
;
}
}
}
#define BOOST_ASIO_IP_BASIC_ENDPOINT_HPP
#define BOOST_ASIO_IP_DETAIL_ENDPOINT_HPP
namespace boost {
namespace asio {
namespace ip {
namespace detail {
class endpoint
{
public:
inline endpoint();
inline endpoint(int family, unsigned short port_num);
inline endpoint(const boost::asio::ip::address& addr,
unsigned short port_num);
endpoint(const endpoint& other)
;
endpoint& operator=(const endpoint& other)
;
boost::asio::detail::socket_addr_type* data()
;
const boost::asio::detail::socket_addr_type* data() const
;
std::size_t size() const
;
inline void resize(std::size_t new_size);
std::size_t capacity() const
;
inline unsigned short port() const;
inline void port(unsigned short port_num);
inline boost::asio::ip::address address() const;
inline void address(const boost::asio::ip::address& addr);
inline friend bool operator==(
const endpoint& e1, const endpoint& e2);
inline friend bool operator<(
const endpoint& e1, const endpoint& e2);
bool is_v4() const
;
inline std::string to_string(boost::system::error_code& ec) const;
private:
union data_union
{
boost::asio::detail::socket_addr_type base;
boost::asio::detail::sockaddr_in4_type v4;
boost::asio::detail::sockaddr_in6_type v6;
} data_;
};
}
}
}
}
#define BOOST_ASIO_IP_DETAIL_IMPL_ENDPOINT_IPP
namespace boost {
namespace asio {
namespace ip {
namespace detail {
bool operator==(const endpoint& e1, const endpoint& e2)
;
bool operator<(const endpoint& e1, const endpoint& e2)
;
}
}
}
}
namespace boost {
namespace asio {
namespace ip {
template <typename InternetProtocol>
class basic_endpoint
{
public:
typedef InternetProtocol protocol_type;
typedef boost::asio::detail::socket_addr_type data_type;
basic_endpoint()
;
basic_endpoint(const InternetProtocol& internet_protocol,
unsigned short port_num)
;
basic_endpoint(const boost::asio::ip::address& addr, unsigned short port_num)
;
basic_endpoint(const basic_endpoint& other)
;
basic_endpoint(basic_endpoint&& other)
;
basic_endpoint& operator=(const basic_endpoint& other)
;
basic_endpoint& operator=(basic_endpoint&& other)
;
protocol_type protocol() const
;
data_type* data()
;
const data_type* data() const
;
std::size_t size() const
;
void resize(std::size_t new_size)
;
std::size_t capacity() const
;
unsigned short port() const
;
void port(unsigned short port_num)
;
boost::asio::ip::address address() const
;
void address(const boost::asio::ip::address& addr)
;
friend bool operator==(const basic_endpoint<InternetProtocol>& e1,
const basic_endpoint<InternetProtocol>& e2)
;
friend bool operator!=(const basic_endpoint<InternetProtocol>& e1,
const basic_endpoint<InternetProtocol>& e2)
;
friend bool operator<(const basic_endpoint<InternetProtocol>& e1,
const basic_endpoint<InternetProtocol>& e2)
;
friend bool operator>(const basic_endpoint<InternetProtocol>& e1,
const basic_endpoint<InternetProtocol>& e2)
;
friend bool operator<=(const basic_endpoint<InternetProtocol>& e1,
const basic_endpoint<InternetProtocol>& e2)
;
friend bool operator>=(const basic_endpoint<InternetProtocol>& e1,
const basic_endpoint<InternetProtocol>& e2)
;
private:
boost::asio::ip::detail::endpoint impl_;
};
template <typename Elem, typename Traits, typename InternetProtocol>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os,
const basic_endpoint<InternetProtocol>& endpoint);
}
}
}
#define BOOST_ASIO_IP_IMPL_BASIC_ENDPOINT_HPP
namespace boost {
namespace asio {
namespace ip {
template <typename Elem, typename Traits, typename InternetProtocol>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os,
const basic_endpoint<InternetProtocol>& endpoint)
;
}
}
}
#define BOOST_ASIO_IP_BASIC_RESOLVER_HPP
#define BOOST_ASIO_IP_BASIC_RESOLVER_ITERATOR_HPP
#define BOOST_ASIO_IP_BASIC_RESOLVER_ENTRY_HPP
namespace boost {
namespace asio {
namespace ip {
template <typename InternetProtocol>
class basic_resolver_entry
{
public:
typedef InternetProtocol protocol_type;
typedef typename InternetProtocol::endpoint endpoint_type;
basic_resolver_entry()
;
basic_resolver_entry(const endpoint_type& ep,
const std::string& host, const std::string& service)
;
endpoint_type endpoint() const
;
operator endpoint_type() const
;
std::string host_name() const
;
std::string service_name() const
;
private:
endpoint_type endpoint_;
std::string host_name_;
std::string service_name_;
};
}
}
}
namespace boost {
namespace asio {
namespace ip {
template <typename InternetProtocol>
class basic_resolver_iterator
{
public:
typedef std::ptrdiff_t difference_type;
typedef basic_resolver_entry<InternetProtocol> value_type;
typedef const basic_resolver_entry<InternetProtocol>* pointer;
typedef const basic_resolver_entry<InternetProtocol>& reference;
typedef std::forward_iterator_tag iterator_category;
basic_resolver_iterator()
;
static basic_resolver_iterator create(
boost::asio::detail::addrinfo_type* address_info,
const std::string& host_name, const std::string& service_name)
;
static basic_resolver_iterator create(
const typename InternetProtocol::endpoint& endpoint,
const std::string& host_name, const std::string& service_name)
;
template <typename EndpointIterator>
static basic_resolver_iterator create(
EndpointIterator begin, EndpointIterator end,
const std::string& host_name, const std::string& service_name)
;
const basic_resolver_entry<InternetProtocol>& operator*() const
;
const basic_resolver_entry<InternetProtocol>* operator->() const
;
basic_resolver_iterator& operator++()
;
basic_resolver_iterator operator++(int)
;
friend bool operator==(const basic_resolver_iterator& a,
const basic_resolver_iterator& b)
;
friend bool operator!=(const basic_resolver_iterator& a,
const basic_resolver_iterator& b)
;
private:
void increment()
;
bool equal(const basic_resolver_iterator& other) const
;
const basic_resolver_entry<InternetProtocol>& dereference() const
;
typedef std::vector<basic_resolver_entry<InternetProtocol> > values_type;
boost::asio::detail::shared_ptr<values_type> values_;
std::size_t index_;
};
}
}
}
#define BOOST_ASIO_IP_BASIC_RESOLVER_QUERY_HPP
#define BOOST_ASIO_IP_RESOLVER_QUERY_BASE_HPP
namespace boost {
namespace asio {
namespace ip {
class resolver_query_base
{
public:
enum flags
{
canonical_name = 0x0002,
passive = 0x0001,
numeric_host = 0x0004,
numeric_service = 0x0400,
v4_mapped = 0x0008,
all_matching = 0x0010,
address_configured = 0x0020
};
friend flags operator&(flags x, flags y)
;
friend flags operator|(flags x, flags y)
;
friend flags operator^(flags x, flags y)
;
friend flags operator~(flags x)
;
friend flags& operator&=(flags& x, flags y)
;
friend flags& operator|=(flags& x, flags y)
;
friend flags& operator^=(flags& x, flags y)
;
protected:
~resolver_query_base()
;
};
}
}
}
namespace boost {
namespace asio {
namespace ip {
template <typename InternetProtocol>
class basic_resolver_query
: public resolver_query_base
{
public:
typedef InternetProtocol protocol_type;
basic_resolver_query(const std::string& service,
resolver_query_base::flags resolve_flags = passive | address_configured)
;
basic_resolver_query(const protocol_type& protocol,
const std::string& service,
resolver_query_base::flags resolve_flags = passive | address_configured)
;
basic_resolver_query(const std::string& host, const std::string& service,
resolver_query_base::flags resolve_flags = address_configured)
;
basic_resolver_query(const protocol_type& protocol,
const std::string& host, const std::string& service,
resolver_query_base::flags resolve_flags = address_configured)
;
const boost::asio::detail::addrinfo_type& hints() const
;
std::string host_name() const
;
std::string service_name() const
;
private:
boost::asio::detail::addrinfo_type hints_;
std::string host_name_;
std::string service_name_;
};
}
}
}
#define BOOST_ASIO_IP_RESOLVER_SERVICE_HPP
#define BOOST_ASIO_DETAIL_RESOLVER_SERVICE_HPP
#define BOOST_ASIO_DETAIL_RESOLVER_ENDPOINT_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Protocol, typename Handler>
class resolve_endpoint_op : public operation
{
public:
struct ptr { Handler* h; void* v; resolve_endpoint_op* p; ~ptr() ; void reset() ; };
typedef typename Protocol::endpoint endpoint_type;
typedef boost::asio::ip::basic_resolver_iterator<Protocol> iterator_type;
resolve_endpoint_op(socket_ops::weak_cancel_token_type cancel_token,
const endpoint_type& endpoint, io_service_impl& ios, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
socket_ops::weak_cancel_token_type cancel_token_;
endpoint_type endpoint_;
io_service_impl& io_service_impl_;
Handler handler_;
boost::system::error_code ec_;
iterator_type iter_;
};
}
}
}
#define BOOST_ASIO_DETAIL_RESOLVE_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Protocol, typename Handler>
class resolve_op : public operation
{
public:
struct ptr { Handler* h; void* v; resolve_op* p; ~ptr() ; void reset() ; };
typedef boost::asio::ip::basic_resolver_query<Protocol> query_type;
typedef boost::asio::ip::basic_resolver_iterator<Protocol> iterator_type;
resolve_op(socket_ops::weak_cancel_token_type cancel_token,
const query_type& query, io_service_impl& ios, Handler& handler)
;
~resolve_op()
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
socket_ops::weak_cancel_token_type cancel_token_;
query_type query_;
io_service_impl& io_service_impl_;
Handler handler_;
boost::system::error_code ec_;
boost::asio::detail::addrinfo_type* addrinfo_;
};
}
}
}
#define BOOST_ASIO_DETAIL_RESOLVER_SERVICE_BASE_HPP
#define BOOST_ASIO_DETAIL_THREAD_HPP
#define BOOST_ASIO_DETAIL_POSIX_THREAD_HPP
namespace boost {
namespace asio {
namespace detail {
extern "C"
{
inline void* boost_asio_detail_posix_thread_function(void* arg);
}
class posix_thread
: private noncopyable
{
public:
template <typename Function>
posix_thread(Function f, unsigned int = 0)
;
inline ~posix_thread();
inline void join();
private:
friend void* boost_asio_detail_posix_thread_function(void* arg);
class func_base
{
public:
virtual ~func_base() ;
virtual void run() = 0;
};
struct auto_func_base_ptr
{
func_base* ptr;
~auto_func_base_ptr() ;
};
template <typename Function>
class func
: public func_base
{
public:
func(Function f)
;
virtual void run()
;
private:
Function f_;
};
inline void start_thread(func_base* arg);
::pthread_t thread_;
bool joined_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_POSIX_THREAD_IPP
namespace boost {
namespace asio {
namespace detail {
void* boost_asio_detail_posix_thread_function(void* arg)
;
}
}
}
namespace boost {
namespace asio {
namespace detail {
typedef posix_thread thread;
}
}
}
namespace boost {
namespace asio {
namespace detail {
class resolver_service_base
{
public:
typedef socket_ops::shared_cancel_token_type implementation_type;
inline resolver_service_base(boost::asio::io_service& io_service);
inline ~resolver_service_base();
inline void shutdown_service();
inline void fork_service(
boost::asio::io_service::fork_event fork_ev);
inline void construct(implementation_type& impl);
inline void destroy(implementation_type&);
inline void cancel(implementation_type& impl);
protected:
inline void start_resolve_op(operation* op);
class auto_addrinfo
: private boost::asio::detail::noncopyable
{
public:
explicit auto_addrinfo(boost::asio::detail::addrinfo_type* ai)
;
~auto_addrinfo()
;
operator boost::asio::detail::addrinfo_type*()
;
private:
boost::asio::detail::addrinfo_type* ai_;
};
class work_io_service_runner;
inline void start_work_thread();
io_service_impl& io_service_impl_;
private:
boost::asio::detail::mutex mutex_;
boost::asio::detail::scoped_ptr<boost::asio::io_service> work_io_service_;
io_service_impl& work_io_service_impl_;
boost::asio::detail::scoped_ptr<boost::asio::io_service::work> work_;
boost::asio::detail::scoped_ptr<boost::asio::detail::thread> work_thread_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_RESOLVER_SERVICE_BASE_IPP
namespace boost {
namespace asio {
namespace detail {
class resolver_service_base::work_io_service_runner
{
public:
work_io_service_runner(boost::asio::io_service& io_service) ;
void operator()() ;
private:
boost::asio::io_service& io_service_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Protocol>
class resolver_service : public resolver_service_base
{
public:
typedef socket_ops::shared_cancel_token_type implementation_type;
typedef typename Protocol::endpoint endpoint_type;
typedef boost::asio::ip::basic_resolver_query<Protocol> query_type;
typedef boost::asio::ip::basic_resolver_iterator<Protocol> iterator_type;
resolver_service(boost::asio::io_service& io_service)
;
iterator_type resolve(implementation_type&, const query_type& query,
boost::system::error_code& ec)
;
template <typename Handler>
void async_resolve(implementation_type& impl,
const query_type& query, Handler& handler)
;
iterator_type resolve(implementation_type&,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
template <typename Handler>
void async_resolve(implementation_type& impl,
const endpoint_type& endpoint, Handler& handler)
;
};
}
}
}
namespace boost {
namespace asio {
namespace ip {
template <typename InternetProtocol>
class resolver_service
: public boost::asio::detail::service_base<
resolver_service<InternetProtocol> >
{
public:
typedef InternetProtocol protocol_type;
typedef typename InternetProtocol::endpoint endpoint_type;
typedef basic_resolver_query<InternetProtocol> query_type;
typedef basic_resolver_iterator<InternetProtocol> iterator_type;
private:
typedef boost::asio::detail::resolver_service<InternetProtocol>
service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
explicit resolver_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void destroy(implementation_type& impl)
;
void cancel(implementation_type& impl)
;
iterator_type resolve(implementation_type& impl, const query_type& query,
boost::system::error_code& ec)
;
template <typename ResolveHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ResolveHandler, void (boost::system::error_code, iterator_type)>::type>::type
async_resolve(implementation_type& impl, const query_type& query,
ResolveHandler&& handler)
;
iterator_type resolve(implementation_type& impl,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
template <typename ResolveHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ResolveHandler, void (boost::system::error_code, iterator_type)>::type>::type
async_resolve(implementation_type& impl, const endpoint_type& endpoint,
ResolveHandler&& handler)
;
private:
void shutdown_service()
;
void fork_service(boost::asio::io_service::fork_event event)
;
service_impl_type service_impl_;
};
}
}
}
namespace boost {
namespace asio {
namespace ip {
template <typename InternetProtocol,
typename ResolverService = resolver_service<InternetProtocol> >
class basic_resolver
: public basic_io_object<ResolverService>
{
public:
typedef InternetProtocol protocol_type;
typedef typename InternetProtocol::endpoint endpoint_type;
typedef basic_resolver_query<InternetProtocol> query;
typedef basic_resolver_iterator<InternetProtocol> iterator;
explicit basic_resolver(boost::asio::io_service& io_service)
;
void cancel()
;
iterator resolve(const query& q)
;
iterator resolve(const query& q, boost::system::error_code& ec)
;
template <typename ResolveHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ResolveHandler, void (boost::system::error_code, iterator)>::type>::type
async_resolve(const query& q,
ResolveHandler&& handler)
;
iterator resolve(const endpoint_type& e)
;
iterator resolve(const endpoint_type& e, boost::system::error_code& ec)
;
template <typename ResolveHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ResolveHandler, void (boost::system::error_code, iterator)>::type>::type
async_resolve(const endpoint_type& e,
ResolveHandler&& handler)
;
};
}
}
}
#define BOOST_ASIO_IP_HOST_NAME_HPP
namespace boost {
namespace asio {
namespace ip {
inline std::string host_name();
inline std::string host_name(boost::system::error_code& ec);
}
}
}
#define BOOST_ASIO_IP_IMPL_HOST_NAME_IPP
namespace boost {
namespace asio {
namespace ip {
std::string host_name()
;
std::string host_name(boost::system::error_code& ec)
;
}
}
}
#define BOOST_ASIO_IP_ICMP_HPP
namespace boost {
namespace asio {
namespace ip {
class icmp
{
public:
typedef basic_endpoint<icmp> endpoint;
static icmp v4()
;
static icmp v6()
;
int type() const
;
int protocol() const
;
int family() const
;
typedef basic_raw_socket<icmp> socket;
typedef basic_resolver<icmp> resolver;
friend bool operator==(const icmp& p1, const icmp& p2)
;
friend bool operator!=(const icmp& p1, const icmp& p2)
;
private:
explicit icmp(int protocol_id, int protocol_family)
;
int protocol_;
int family_;
};
}
}
}
#define BOOST_ASIO_IP_MULTICAST_HPP
#define BOOST_ASIO_IP_DETAIL_SOCKET_OPTION_HPP
namespace boost {
namespace asio {
namespace ip {
namespace detail {
namespace socket_option {
template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
class multicast_enable_loopback
{
public:
typedef int ipv4_value_type;
typedef int ipv6_value_type;
multicast_enable_loopback()
;
explicit multicast_enable_loopback(bool v)
;
multicast_enable_loopback& operator=(bool v)
;
bool value() const
;
operator bool() const
;
bool operator!() const
;
template <typename Protocol>
int level(const Protocol& protocol) const
;
template <typename Protocol>
int name(const Protocol& protocol) const
;
template <typename Protocol>
void* data(const Protocol& protocol)
;
template <typename Protocol>
const void* data(const Protocol& protocol) const
;
template <typename Protocol>
std::size_t size(const Protocol& protocol) const
;
template <typename Protocol>
void resize(const Protocol& protocol, std::size_t s)
;
private:
ipv4_value_type ipv4_value_;
ipv6_value_type ipv6_value_;
};
template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
class unicast_hops
{
public:
unicast_hops()
;
explicit unicast_hops(int v)
;
unicast_hops& operator=(int v)
;
int value() const
;
template <typename Protocol>
int level(const Protocol& protocol) const
;
template <typename Protocol>
int name(const Protocol& protocol) const
;
template <typename Protocol>
int* data(const Protocol&)
;
template <typename Protocol>
const int* data(const Protocol&) const
;
template <typename Protocol>
std::size_t size(const Protocol&) const
;
template <typename Protocol>
void resize(const Protocol&, std::size_t s)
;
private:
int value_;
};
template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
class multicast_hops
{
public:
typedef unsigned char ipv4_value_type;
typedef int ipv6_value_type;
multicast_hops()
;
explicit multicast_hops(int v)
;
multicast_hops& operator=(int v)
;
int value() const
;
template <typename Protocol>
int level(const Protocol& protocol) const
;
template <typename Protocol>
int name(const Protocol& protocol) const
;
template <typename Protocol>
void* data(const Protocol& protocol)
;
template <typename Protocol>
const void* data(const Protocol& protocol) const
;
template <typename Protocol>
std::size_t size(const Protocol& protocol) const
;
template <typename Protocol>
void resize(const Protocol& protocol, std::size_t s)
;
private:
ipv4_value_type ipv4_value_;
ipv6_value_type ipv6_value_;
};
template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
class multicast_request
{
public:
multicast_request()
;
explicit multicast_request(const boost::asio::ip::address& multicast_address)
;
explicit multicast_request(
const boost::asio::ip::address_v4& multicast_address,
const boost::asio::ip::address_v4& network_interface
= boost::asio::ip::address_v4::any())
;
explicit multicast_request(
const boost::asio::ip::address_v6& multicast_address,
unsigned long network_interface = 0)
;
template <typename Protocol>
int level(const Protocol& protocol) const
;
template <typename Protocol>
int name(const Protocol& protocol) const
;
template <typename Protocol>
const void* data(const Protocol& protocol) const
;
template <typename Protocol>
std::size_t size(const Protocol& protocol) const
;
private:
boost::asio::detail::in4_mreq_type ipv4_value_;
boost::asio::detail::in6_mreq_type ipv6_value_;
};
template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
class network_interface
{
public:
network_interface()
;
explicit network_interface(const boost::asio::ip::address_v4& ipv4_interface)
;
explicit network_interface(unsigned int ipv6_interface)
;
template <typename Protocol>
int level(const Protocol& protocol) const
;
template <typename Protocol>
int name(const Protocol& protocol) const
;
template <typename Protocol>
const void* data(const Protocol& protocol) const
;
template <typename Protocol>
std::size_t size(const Protocol& protocol) const
;
private:
boost::asio::detail::in4_addr_type ipv4_value_;
unsigned int ipv6_value_;
};
}
}
}
}
}
namespace boost {
namespace asio {
namespace ip {
namespace multicast {
typedef boost::asio::ip::detail::socket_option::multicast_request<
IPPROTO_IP,
35,
IPPROTO_IPV6,
20> join_group;
typedef boost::asio::ip::detail::socket_option::multicast_request<
IPPROTO_IP,
36,
IPPROTO_IPV6,
21> leave_group;
typedef boost::asio::ip::detail::socket_option::network_interface<
IPPROTO_IP,
32,
IPPROTO_IPV6,
17> outbound_interface;
typedef boost::asio::ip::detail::socket_option::multicast_hops<
IPPROTO_IP,
33,
IPPROTO_IPV6,
18> hops;
typedef boost::asio::ip::detail::socket_option::multicast_enable_loopback<
IPPROTO_IP,
34,
IPPROTO_IPV6,
19> enable_loopback;
}
}
}
}
#define BOOST_ASIO_IP_TCP_HPP
namespace boost {
namespace asio {
namespace ip {
class tcp
{
public:
typedef basic_endpoint<tcp> endpoint;
static tcp v4()
;
static tcp v6()
;
int type() const
;
int protocol() const
;
int family() const
;
typedef basic_stream_socket<tcp> socket;
typedef basic_socket_acceptor<tcp> acceptor;
typedef basic_resolver<tcp> resolver;
typedef basic_socket_iostream<tcp> iostream;
typedef boost::asio::detail::socket_option::boolean<
IPPROTO_TCP, 1> no_delay;
friend bool operator==(const tcp& p1, const tcp& p2)
;
friend bool operator!=(const tcp& p1, const tcp& p2)
;
private:
explicit tcp(int protocol_family)
;
int family_;
};
}
}
}
#define BOOST_ASIO_IP_UDP_HPP
namespace boost {
namespace asio {
namespace ip {
class udp
{
public:
typedef basic_endpoint<udp> endpoint;
static udp v4()
;
static udp v6()
;
int type() const
;
int protocol() const
;
int family() const
;
typedef basic_datagram_socket<udp> socket;
typedef basic_resolver<udp> resolver;
friend bool operator==(const udp& p1, const udp& p2)
;
friend bool operator!=(const udp& p1, const udp& p2)
;
private:
explicit udp(int protocol_family)
;
int family_;
};
}
}
}
#define BOOST_ASIO_IP_UNICAST_HPP
namespace boost {
namespace asio {
namespace ip {
namespace unicast {
typedef boost::asio::ip::detail::socket_option::unicast_hops<
IPPROTO_IP,
2,
IPPROTO_IPV6,
16> hops;
}
}
}
}
#define BOOST_ASIO_IP_V6_ONLY_HPP
namespace boost {
namespace asio {
namespace ip {
typedef boost::asio::detail::socket_option::boolean<
IPPROTO_IPV6, 26> v6_only;
}
}
}
#define BOOST_ASIO_IS_READ_BUFFERED_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Stream>
char is_read_buffered_helper(buffered_stream<Stream>* s);
template <typename Stream>
char is_read_buffered_helper(buffered_read_stream<Stream>* s);
struct is_read_buffered_big_type { char data[10]; };
is_read_buffered_big_type is_read_buffered_helper(...);
}
template <typename Stream>
class is_read_buffered
{
public:
static const bool value = sizeof(detail::is_read_buffered_helper((Stream*)0)) == 1;
};
}
}
#define BOOST_ASIO_IS_WRITE_BUFFERED_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Stream>
char is_write_buffered_helper(buffered_stream<Stream>* s);
template <typename Stream>
char is_write_buffered_helper(buffered_write_stream<Stream>* s);
struct is_write_buffered_big_type { char data[10]; };
is_write_buffered_big_type is_write_buffered_helper(...);
}
template <typename Stream>
class is_write_buffered
{
public:
static const bool value = sizeof(detail::is_write_buffered_helper((Stream*)0)) == 1;
};
}
}
#define BOOST_ASIO_LOCAL_BASIC_ENDPOINT_HPP
#define BOOST_ASIO_LOCAL_DETAIL_ENDPOINT_HPP
namespace boost {
namespace asio {
namespace local {
namespace detail {
class endpoint
{
public:
inline endpoint();
inline endpoint(const char* path_name);
inline endpoint(const std::string& path_name);
endpoint(const endpoint& other)
;
endpoint& operator=(const endpoint& other)
;
boost::asio::detail::socket_addr_type* data()
;
const boost::asio::detail::socket_addr_type* data() const
;
std::size_t size() const
;
inline void resize(std::size_t size);
std::size_t capacity() const
;
inline std::string path() const;
inline void path(const char* p);
inline void path(const std::string& p);
inline friend bool operator==(
const endpoint& e1, const endpoint& e2);
inline friend bool operator<(
const endpoint& e1, const endpoint& e2);
private:
union data_union
{
boost::asio::detail::socket_addr_type base;
boost::asio::detail::sockaddr_un_type local;
} data_;
std::size_t path_length_;
inline void init(const char* path, std::size_t path_length);
};
}
}
}
}
#define BOOST_ASIO_LOCAL_DETAIL_IMPL_ENDPOINT_IPP
namespace boost {
namespace asio {
namespace local {
namespace detail {
bool operator==(const endpoint& e1, const endpoint& e2)
;
bool operator<(const endpoint& e1, const endpoint& e2)
;
}
}
}
}
namespace boost {
namespace asio {
namespace local {
template <typename Protocol>
class basic_endpoint
{
public:
typedef Protocol protocol_type;
typedef boost::asio::detail::socket_addr_type data_type;
basic_endpoint()
;
basic_endpoint(const char* path_name)
;
basic_endpoint(const std::string& path_name)
;
basic_endpoint(const basic_endpoint& other)
;
basic_endpoint(basic_endpoint&& other)
;
basic_endpoint& operator=(const basic_endpoint& other)
;
basic_endpoint& operator=(basic_endpoint&& other)
;
protocol_type protocol() const
;
data_type* data()
;
const data_type* data() const
;
std::size_t size() const
;
void resize(std::size_t new_size)
;
std::size_t capacity() const
;
std::string path() const
;
void path(const char* p)
;
void path(const std::string& p)
;
friend bool operator==(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator!=(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator<(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator>(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator<=(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator>=(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
private:
boost::asio::local::detail::endpoint impl_;
};
template <typename Elem, typename Traits, typename Protocol>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os,
const basic_endpoint<Protocol>& endpoint)
;
}
}
}
#define BOOST_ASIO_LOCAL_CONNECT_PAIR_HPP
namespace boost {
namespace asio {
namespace local {
template <typename Protocol, typename SocketService1, typename SocketService2>
void connect_pair(
basic_socket<Protocol, SocketService1>& socket1,
basic_socket<Protocol, SocketService2>& socket2);
template <typename Protocol, typename SocketService1, typename SocketService2>
boost::system::error_code connect_pair(
basic_socket<Protocol, SocketService1>& socket1,
basic_socket<Protocol, SocketService2>& socket2,
boost::system::error_code& ec);
template <typename Protocol, typename SocketService1, typename SocketService2>
void connect_pair(
basic_socket<Protocol, SocketService1>& socket1,
basic_socket<Protocol, SocketService2>& socket2)
;
template <typename Protocol, typename SocketService1, typename SocketService2>
boost::system::error_code connect_pair(
basic_socket<Protocol, SocketService1>& socket1,
basic_socket<Protocol, SocketService2>& socket2,
boost::system::error_code& ec)
;
}
}
}
#define BOOST_ASIO_LOCAL_DATAGRAM_PROTOCOL_HPP
namespace boost {
namespace asio {
namespace local {
class datagram_protocol
{
public:
int type() const
;
int protocol() const
;
int family() const
;
typedef basic_endpoint<datagram_protocol> endpoint;
typedef basic_datagram_socket<datagram_protocol> socket;
};
}
}
}
#define BOOST_ASIO_LOCAL_STREAM_PROTOCOL_HPP
namespace boost {
namespace asio {
namespace local {
class stream_protocol
{
public:
int type() const
;
int protocol() const
;
int family() const
;
typedef basic_endpoint<stream_protocol> endpoint;
typedef basic_stream_socket<stream_protocol> socket;
typedef basic_socket_acceptor<stream_protocol> acceptor;
typedef basic_socket_iostream<stream_protocol> iostream;
};
}
}
}
#define BOOST_ASIO_PLACEHOLDERS_HPP
#define BOOST_BIND_ARG_HPP_INCLUDED
#define BOOST_IS_PLACEHOLDER_HPP_INCLUDED
namespace boost
{
template< class T > struct is_placeholder
{
enum _vt { value = 0 };
};
}
namespace boost
{
template< int I > struct arg
{
arg()
;
template< class T > arg( T const & )
;
};
template< int I > bool operator==( arg<I> const &, arg<I> const & )
;
template< int I > struct is_placeholder< arg<I> >
{
enum _vt { value = I };
};
template< int I > struct is_placeholder< arg<I> (*) () >
{
enum _vt { value = I };
};
}
namespace boost {
namespace asio {
namespace placeholders {
boost::arg<1> error()
;
boost::arg<2> bytes_transferred()
;
boost::arg<2> iterator()
;
boost::arg<2> signal_number()
;
}
}
}
#define BOOST_ASIO_POSIX_BASIC_DESCRIPTOR_HPP
#define BOOST_ASIO_POSIX_DESCRIPTOR_BASE_HPP
namespace boost {
namespace asio {
namespace posix {
class descriptor_base
{
public:
typedef boost::asio::detail::io_control::non_blocking_io non_blocking_io;
typedef boost::asio::detail::io_control::bytes_readable bytes_readable;
protected:
~descriptor_base()
;
};
}
}
}
namespace boost {
namespace asio {
namespace posix {
template <typename DescriptorService>
class basic_descriptor
: public basic_io_object<DescriptorService>,
public descriptor_base
{
public:
typedef typename DescriptorService::native_handle_type native_type;
typedef typename DescriptorService::native_handle_type native_handle_type;
typedef basic_descriptor<DescriptorService> lowest_layer_type;
explicit basic_descriptor(boost::asio::io_service& io_service)
;
basic_descriptor(boost::asio::io_service& io_service,
const native_handle_type& native_descriptor)
;
basic_descriptor(basic_descriptor&& other)
;
basic_descriptor& operator=(basic_descriptor&& other)
;
lowest_layer_type& lowest_layer()
;
const lowest_layer_type& lowest_layer() const
;
void assign(const native_handle_type& native_descriptor)
;
boost::system::error_code assign(const native_handle_type& native_descriptor,
boost::system::error_code& ec)
;
bool is_open() const
;
void close()
;
boost::system::error_code close(boost::system::error_code& ec)
;
native_type native()
;
native_handle_type native_handle()
;
native_handle_type release()
;
void cancel()
;
boost::system::error_code cancel(boost::system::error_code& ec)
;
template <typename IoControlCommand>
void io_control(IoControlCommand& command)
;
template <typename IoControlCommand>
boost::system::error_code io_control(IoControlCommand& command,
boost::system::error_code& ec)
;
bool non_blocking() const
;
void non_blocking(bool mode)
;
boost::system::error_code non_blocking(
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking() const
;
void native_non_blocking(bool mode)
;
boost::system::error_code native_non_blocking(
bool mode, boost::system::error_code& ec)
;
protected:
~basic_descriptor()
;
};
}
}
}
#define BOOST_ASIO_POSIX_BASIC_STREAM_DESCRIPTOR_HPP
#define BOOST_ASIO_POSIX_STREAM_DESCRIPTOR_SERVICE_HPP
namespace boost {
namespace asio {
namespace posix {
class stream_descriptor_service
: public boost::asio::detail::service_base<stream_descriptor_service>
{
public:
private:
typedef detail::reactive_descriptor_service service_impl_type;
public:
typedef service_impl_type::implementation_type implementation_type;
typedef service_impl_type::native_handle_type native_type;
typedef service_impl_type::native_handle_type native_handle_type;
explicit stream_descriptor_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
stream_descriptor_service& other_service,
implementation_type& other_impl)
;
void destroy(implementation_type& impl)
;
boost::system::error_code assign(implementation_type& impl,
const native_handle_type& native_descriptor,
boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_type native(implementation_type& impl)
;
native_handle_type native_handle(implementation_type& impl)
;
native_handle_type release(implementation_type& impl)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
template <typename IoControlCommand>
boost::system::error_code io_control(implementation_type& impl,
IoControlCommand& command, boost::system::error_code& ec)
;
bool non_blocking(const implementation_type& impl) const
;
boost::system::error_code non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const implementation_type& impl) const
;
boost::system::error_code native_non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t write_some(implementation_type& impl,
const ConstBufferSequence& buffers, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(implementation_type& impl,
const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t read_some(implementation_type& impl,
const MutableBufferSequence& buffers, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(implementation_type& impl,
const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
}
namespace boost {
namespace asio {
namespace posix {
template <typename StreamDescriptorService = stream_descriptor_service>
class basic_stream_descriptor
: public basic_descriptor<StreamDescriptorService>
{
public:
typedef typename StreamDescriptorService::native_handle_type native_type;
typedef typename StreamDescriptorService::native_handle_type
native_handle_type;
explicit basic_stream_descriptor(boost::asio::io_service& io_service)
;
basic_stream_descriptor(boost::asio::io_service& io_service,
const native_handle_type& native_descriptor)
;
basic_stream_descriptor(basic_stream_descriptor&& other)
;
basic_stream_descriptor& operator=(basic_stream_descriptor&& other)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
};
}
}
}
#define BOOST_ASIO_POSIX_STREAM_DESCRIPTOR_HPP
namespace boost {
namespace asio {
namespace posix {
typedef basic_stream_descriptor<> stream_descriptor;
}
}
}
#define BOOST_ASIO_READ_HPP
namespace boost {
namespace asio {
template <typename SyncReadStream, typename MutableBufferSequence>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers);
template <typename SyncReadStream, typename MutableBufferSequence>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
boost::system::error_code& ec);
template <typename SyncReadStream, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
CompletionCondition completion_condition);
template <typename SyncReadStream, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
CompletionCondition completion_condition, boost::system::error_code& ec);
template <typename SyncReadStream, typename Allocator>
std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b);
template <typename SyncReadStream, typename Allocator>
std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
boost::system::error_code& ec);
template <typename SyncReadStream, typename Allocator,
typename CompletionCondition>
std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition);
template <typename SyncReadStream, typename Allocator,
typename CompletionCondition>
std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition, boost::system::error_code& ec);
template <typename AsyncReadStream, typename MutableBufferSequence,
typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
ReadHandler&& handler);
template <typename AsyncReadStream, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
CompletionCondition completion_condition,
ReadHandler&& handler);
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
ReadHandler&& handler);
template <typename AsyncReadStream, typename Allocator,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition,
ReadHandler&& handler);
}
}
#define BOOST_ASIO_IMPL_READ_HPP
namespace boost {
namespace asio {
template <typename SyncReadStream, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
CompletionCondition completion_condition, boost::system::error_code& ec)
;
template <typename SyncReadStream, typename MutableBufferSequence>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers)
;
template <typename SyncReadStream, typename MutableBufferSequence>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename SyncReadStream, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
CompletionCondition completion_condition)
;
template <typename SyncReadStream, typename Allocator,
typename CompletionCondition>
std::size_t read(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition, boost::system::error_code& ec)
;
template <typename SyncReadStream, typename Allocator>
std::size_t read(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b)
;
template <typename SyncReadStream, typename Allocator>
std::size_t read(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
boost::system::error_code& ec)
;
template <typename SyncReadStream, typename Allocator,
typename CompletionCondition>
std::size_t read(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition)
;
namespace detail
{
template <typename AsyncReadStream, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
class read_op
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_op(AsyncReadStream& stream, const MutableBufferSequence& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_op(const read_op& other)
;
read_op(read_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::asio::detail::consuming_buffers<
mutable_buffer, MutableBufferSequence> buffers_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncReadStream,
typename CompletionCondition, typename ReadHandler>
class read_op<AsyncReadStream, boost::asio::mutable_buffers_1,
CompletionCondition, ReadHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_op(AsyncReadStream& stream,
const boost::asio::mutable_buffers_1& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_op(const read_op& other)
;
read_op(read_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::asio::mutable_buffer buffer_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename Elem,
typename CompletionCondition, typename ReadHandler>
class read_op<AsyncReadStream, boost::array<Elem, 2>,
CompletionCondition, ReadHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_op(AsyncReadStream& stream, const boost::array<Elem, 2>& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_op(const read_op& other)
;
read_op(read_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::array<Elem, 2> buffers_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename Elem,
typename CompletionCondition, typename ReadHandler>
class read_op<AsyncReadStream, std::array<Elem, 2>,
CompletionCondition, ReadHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_op(AsyncReadStream& stream, const std::array<Elem, 2>& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_op(const read_op& other)
;
read_op(read_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
std::array<Elem, 2> buffers_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_op<AsyncReadStream, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_op<AsyncReadStream, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
bool asio_handler_is_continuation(
read_op<AsyncReadStream, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
void asio_handler_invoke(Function& function,
read_op<AsyncReadStream, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_op<AsyncReadStream, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
}
template <typename AsyncReadStream, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
CompletionCondition completion_condition,
ReadHandler&& handler)
;
template <typename AsyncReadStream, typename MutableBufferSequence,
typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
namespace detail
{
template <typename AsyncReadStream, typename Allocator,
typename CompletionCondition, typename ReadHandler>
class read_streambuf_op
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_streambuf_op(AsyncReadStream& stream,
basic_streambuf<Allocator>& streambuf,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_streambuf_op(const read_streambuf_op& other)
;
read_streambuf_op(read_streambuf_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::asio::basic_streambuf<Allocator>& streambuf_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename Allocator,
typename CompletionCondition, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_streambuf_op<AsyncReadStream, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator,
typename CompletionCondition, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_streambuf_op<AsyncReadStream, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator,
typename CompletionCondition, typename ReadHandler>
bool asio_handler_is_continuation(
read_streambuf_op<AsyncReadStream, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream,
typename Allocator, typename CompletionCondition, typename ReadHandler>
void asio_handler_invoke(Function& function,
read_streambuf_op<AsyncReadStream, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream,
typename Allocator, typename CompletionCondition, typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_streambuf_op<AsyncReadStream, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
}
template <typename AsyncReadStream, typename Allocator,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition,
ReadHandler&& handler)
;
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
ReadHandler&& handler)
;
}
}
#define BOOST_ASIO_READ_AT_HPP
namespace boost {
namespace asio {
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers);
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
boost::system::error_code& ec);
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition);
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition, boost::system::error_code& ec);
template <typename SyncRandomAccessReadDevice, typename Allocator>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, basic_streambuf<Allocator>& b);
template <typename SyncRandomAccessReadDevice, typename Allocator>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, basic_streambuf<Allocator>& b,
boost::system::error_code& ec);
template <typename SyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition);
template <typename SyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition, boost::system::error_code& ec);
template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
const MutableBufferSequence& buffers,
ReadHandler&& handler);
template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition,
ReadHandler&& handler);
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
basic_streambuf<Allocator>& b, ReadHandler&& handler);
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d,
uint64_t offset, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition,
ReadHandler&& handler);
}
}
#define BOOST_ASIO_IMPL_READ_AT_HPP
namespace boost {
namespace asio {
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition, boost::system::error_code& ec)
;
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers)
;
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition)
;
template <typename SyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition, boost::system::error_code& ec)
;
template <typename SyncRandomAccessReadDevice, typename Allocator>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, boost::asio::basic_streambuf<Allocator>& b)
;
template <typename SyncRandomAccessReadDevice, typename Allocator>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
boost::system::error_code& ec)
;
template <typename SyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition)
;
namespace detail
{
template <typename AsyncRandomAccessReadDevice,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
class read_at_op
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_at_op(AsyncRandomAccessReadDevice& device,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_at_op(const read_at_op& other)
;
read_at_op(read_at_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncRandomAccessReadDevice& device_;
uint64_t offset_;
boost::asio::detail::consuming_buffers<
mutable_buffer, MutableBufferSequence> buffers_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncRandomAccessReadDevice,
typename CompletionCondition, typename ReadHandler>
class read_at_op<AsyncRandomAccessReadDevice,
boost::asio::mutable_buffers_1, CompletionCondition, ReadHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_at_op(AsyncRandomAccessReadDevice& device,
uint64_t offset, const boost::asio::mutable_buffers_1& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_at_op(const read_at_op& other)
;
read_at_op(read_at_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncRandomAccessReadDevice& device_;
uint64_t offset_;
boost::asio::mutable_buffer buffer_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncRandomAccessReadDevice, typename Elem,
typename CompletionCondition, typename ReadHandler>
class read_at_op<AsyncRandomAccessReadDevice, boost::array<Elem, 2>,
CompletionCondition, ReadHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_at_op(AsyncRandomAccessReadDevice& device,
uint64_t offset, const boost::array<Elem, 2>& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_at_op(const read_at_op& other)
;
read_at_op(read_at_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncRandomAccessReadDevice& device_;
uint64_t offset_;
boost::array<Elem, 2> buffers_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncRandomAccessReadDevice, typename Elem,
typename CompletionCondition, typename ReadHandler>
class read_at_op<AsyncRandomAccessReadDevice, std::array<Elem, 2>,
CompletionCondition, ReadHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_at_op(AsyncRandomAccessReadDevice& device,
uint64_t offset, const std::array<Elem, 2>& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_at_op(const read_at_op& other)
;
read_at_op(read_at_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncRandomAccessReadDevice& device_;
uint64_t offset_;
std::array<Elem, 2> buffers_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncRandomAccessReadDevice,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncRandomAccessReadDevice,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncRandomAccessReadDevice,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
bool asio_handler_is_continuation(
read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncRandomAccessReadDevice,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
void asio_handler_invoke(Function& function,
read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncRandomAccessReadDevice,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncRandomAccessReadDevice,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
read_at_op<AsyncRandomAccessReadDevice,
MutableBufferSequence, CompletionCondition, ReadHandler>
make_read_at_op(AsyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition, ReadHandler handler)
;
}
template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition,
ReadHandler&& handler)
;
template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
namespace detail
{
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition, typename ReadHandler>
class read_at_streambuf_op
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_at_streambuf_op(AsyncRandomAccessReadDevice& device,
uint64_t offset, basic_streambuf<Allocator>& streambuf,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_at_streambuf_op(const read_at_streambuf_op& other)
;
read_at_streambuf_op(read_at_streambuf_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncRandomAccessReadDevice& device_;
uint64_t offset_;
boost::asio::basic_streambuf<Allocator>& streambuf_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition, typename ReadHandler>
bool asio_handler_is_continuation(
read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncRandomAccessReadDevice,
typename Allocator, typename CompletionCondition, typename ReadHandler>
void asio_handler_invoke(Function& function,
read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncRandomAccessReadDevice,
typename Allocator, typename CompletionCondition, typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
}
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d,
uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition,
ReadHandler&& handler)
;
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d,
uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
ReadHandler&& handler)
;
}
}
#define BOOST_ASIO_READ_UNTIL_HPP
#define BOOST_ASIO_DETAIL_REGEX_FWD_HPP
#define BOOST_REGEX_FWD_HPP
#define BOOST_REGEX_CONFIG_HPP
#define BOOST_REGEX_USER_CONFIG <boost/regex/user.hpp>
#define BOOST_RE_VERSION 320
#define BOOST_REGEX_CONFIG_CWCHAR_HPP
#undef __need_mbstate_t
#undef __need_wint_t
namespace std{
extern "C"{
}
}
#define BOOST_REGEX_DECL
#define BOOST_LIB_NAME boost_regex
#undef BOOST_LIB_NAME
#define BOOST_REGEX_CALL
#define BOOST_REGEX_CCALL
#define BOOST_REGEX_USE_CPP_LOCALE
#define BOOST_REGEX_MAX_STATE_COUNT 100000000
#define BOOST_REGEX_NOEH_ASSERT(x)
#define BOOST_REGEX_NON_RECURSIVE
#define BOOST_REGEX_BLOCKSIZE 4096
#define BOOST_REGEX_MAX_BLOCKS 1024
#define BOOST_REGEX_MAX_CACHE_BLOCKS 16
namespace boost{ namespace re_detail{
void* get_mem_block();
void put_mem_block(void*);
}}
#define BOOST_REGEX_FWD_HPP_INCLUDED
namespace boost{
template <class charT>
class cpp_regex_traits;
template <class charT>
struct c_regex_traits;
template <class charT>
class w32_regex_traits;
template <class charT, class implementationT = cpp_regex_traits<charT> >
struct regex_traits;
template <class charT, class traits = regex_traits<charT> >
class basic_regex;
typedef basic_regex<char, regex_traits<char> > regex;
typedef basic_regex<wchar_t, regex_traits<wchar_t> > wregex;
}
#define BOOST_REGEX_V4_MATCH_FLAGS
namespace boost{
namespace regex_constants{
typedef enum _match_flags
{
match_default = 0,
match_not_bol = 1,
match_not_eol = match_not_bol << 1,
match_not_bob = match_not_eol << 1,
match_not_eob = match_not_bob << 1,
match_not_bow = match_not_eob << 1,
match_not_eow = match_not_bow << 1,
match_not_dot_newline = match_not_eow << 1,
match_not_dot_null = match_not_dot_newline << 1,
match_prev_avail = match_not_dot_null << 1,
match_init = match_prev_avail << 1,
match_any = match_init << 1,
match_not_null = match_any << 1,
match_continuous = match_not_null << 1,
match_partial = match_continuous << 1,
match_stop = match_partial << 1,
match_not_initial_null = match_stop,
match_all = match_stop << 1,
match_perl = match_all << 1,
match_posix = match_perl << 1,
match_nosubs = match_posix << 1,
match_extra = match_nosubs << 1,
match_single_line = match_extra << 1,
match_unused1 = match_single_line << 1,
match_unused2 = match_unused1 << 1,
match_unused3 = match_unused2 << 1,
match_max = match_unused3,
format_perl = 0,
format_default = 0,
format_sed = match_max << 1,
format_all = format_sed << 1,
format_no_copy = format_all << 1,
format_first_only = format_no_copy << 1,
format_is_if = format_first_only << 1,
format_literal = format_is_if << 1
} match_flags;
typedef match_flags match_flag_type;
match_flags operator&(match_flags m1, match_flags m2)
;
match_flags operator|(match_flags m1, match_flags m2)
;
match_flags operator^(match_flags m1, match_flags m2)
;
match_flags operator~(match_flags m1)
;
match_flags& operator&=(match_flags& m1, match_flags m2)
;
match_flags& operator|=(match_flags& m1, match_flags m2)
;
match_flags& operator^=(match_flags& m1, match_flags m2)
;
}
using regex_constants::match_flag_type;
using regex_constants::match_default;
using regex_constants::match_not_bol;
using regex_constants::match_not_eol;
using regex_constants::match_not_bob;
using regex_constants::match_not_eob;
using regex_constants::match_not_bow;
using regex_constants::match_not_eow;
using regex_constants::match_not_dot_newline;
using regex_constants::match_not_dot_null;
using regex_constants::match_prev_avail;
using regex_constants::match_any;
using regex_constants::match_not_null;
using regex_constants::match_continuous;
using regex_constants::match_partial;
using regex_constants::match_all;
using regex_constants::match_perl;
using regex_constants::match_posix;
using regex_constants::match_nosubs;
using regex_constants::match_extra;
using regex_constants::match_single_line;
using regex_constants::format_all;
using regex_constants::format_sed;
using regex_constants::format_perl;
using regex_constants::format_default;
using regex_constants::format_no_copy;
using regex_constants::format_first_only;
}
namespace boost {
template <class BidiIterator>
struct sub_match;
template <class BidiIterator, class Allocator>
class match_results;
}
namespace boost {
namespace asio {
namespace detail
{
char (&has_result_type_helper(...))[2];
template <typename T>
char has_result_type_helper(T*, typename T::result_type* = 0);
template <typename T>
struct has_result_type
{
enum { value = (sizeof((has_result_type_helper)((T*)(0))) == 1) };
};
}
template <typename T>
struct is_match_condition
{
enum
{
value = boost::asio::is_function<
typename boost::asio::remove_pointer<T>::type>::value
|| detail::has_result_type<T>::value
};
};
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, char delim);
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, char delim,
boost::system::error_code& ec);
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const std::string& delim);
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const std::string& delim,
boost::system::error_code& ec);
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr);
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
boost::system::error_code& ec);
template <typename SyncReadStream, typename Allocator, typename MatchCondition>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, MatchCondition match_condition,
typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
template <typename SyncReadStream, typename Allocator, typename MatchCondition>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
MatchCondition match_condition, boost::system::error_code& ec,
typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
char delim, ReadHandler&& handler);
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const std::string& delim,
ReadHandler&& handler);
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
ReadHandler&& handler);
template <typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
MatchCondition match_condition, ReadHandler&& handler,
typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
}
}
#define BOOST_ASIO_IMPL_READ_UNTIL_HPP
namespace boost {
namespace asio {
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, char delim)
;
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, char delim,
boost::system::error_code& ec)
;
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const std::string& delim)
;
namespace detail
{
template <typename Iterator1, typename Iterator2>
std::pair<Iterator1, bool> partial_search(
Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2)
;
}
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const std::string& delim,
boost::system::error_code& ec)
;
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr)
;
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
boost::system::error_code& ec)
;
template <typename SyncReadStream, typename Allocator, typename MatchCondition>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
MatchCondition match_condition, boost::system::error_code& ec,
typename enable_if<is_match_condition<MatchCondition>::value>::type*)
;
template <typename SyncReadStream, typename Allocator, typename MatchCondition>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, MatchCondition match_condition,
typename enable_if<is_match_condition<MatchCondition>::value>::type*)
;
namespace detail
{
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
class read_until_delim_op
{
public:
read_until_delim_op(AsyncReadStream& stream,
boost::asio::basic_streambuf<Allocator>& streambuf,
char delim, ReadHandler& handler)
;
read_until_delim_op(const read_until_delim_op& other)
;
read_until_delim_op(read_until_delim_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::asio::basic_streambuf<Allocator>& streambuf_;
char delim_;
int start_;
std::size_t search_position_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_until_delim_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_until_delim_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
bool asio_handler_is_continuation(
read_until_delim_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream, typename Allocator,
typename ReadHandler>
void asio_handler_invoke(Function& function,
read_until_delim_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream, typename Allocator,
typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_until_delim_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
}
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, char delim,
ReadHandler&& handler)
;
namespace detail
{
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
class read_until_delim_string_op
{
public:
read_until_delim_string_op(AsyncReadStream& stream,
boost::asio::basic_streambuf<Allocator>& streambuf,
const std::string& delim, ReadHandler& handler)
;
read_until_delim_string_op(const read_until_delim_string_op& other)
;
read_until_delim_string_op(read_until_delim_string_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::asio::basic_streambuf<Allocator>& streambuf_;
std::string delim_;
int start_;
std::size_t search_position_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_until_delim_string_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_until_delim_string_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
bool asio_handler_is_continuation(
read_until_delim_string_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream,
typename Allocator, typename ReadHandler>
void asio_handler_invoke(Function& function,
read_until_delim_string_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream,
typename Allocator, typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_until_delim_string_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
}
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const std::string& delim,
ReadHandler&& handler)
;
namespace detail
{
template <typename AsyncReadStream, typename Allocator,
typename RegEx, typename ReadHandler>
class read_until_expr_op
{
public:
read_until_expr_op(AsyncReadStream& stream,
boost::asio::basic_streambuf<Allocator>& streambuf,
const boost::regex& expr, ReadHandler& handler)
;
read_until_expr_op(const read_until_expr_op& other)
;
read_until_expr_op(read_until_expr_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::asio::basic_streambuf<Allocator>& streambuf_;
RegEx expr_;
int start_;
std::size_t search_position_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename Allocator,
typename RegEx, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_until_expr_op<AsyncReadStream,
Allocator, RegEx, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator,
typename RegEx, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_until_expr_op<AsyncReadStream,
Allocator, RegEx, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator,
typename RegEx, typename ReadHandler>
bool asio_handler_is_continuation(
read_until_expr_op<AsyncReadStream,
Allocator, RegEx, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream, typename Allocator,
typename RegEx, typename ReadHandler>
void asio_handler_invoke(Function& function,
read_until_expr_op<AsyncReadStream,
Allocator, RegEx, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream, typename Allocator,
typename RegEx, typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_until_expr_op<AsyncReadStream,
Allocator, RegEx, ReadHandler>* this_handler)
;
}
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
ReadHandler&& handler)
;
namespace detail
{
template <typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
class read_until_match_op
{
public:
read_until_match_op(AsyncReadStream& stream,
boost::asio::basic_streambuf<Allocator>& streambuf,
MatchCondition match_condition, ReadHandler& handler)
;
read_until_match_op(const read_until_match_op& other)
;
read_until_match_op(read_until_match_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::asio::basic_streambuf<Allocator>& streambuf_;
MatchCondition match_condition_;
int start_;
std::size_t search_position_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_until_match_op<AsyncReadStream,
Allocator, MatchCondition, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_until_match_op<AsyncReadStream,
Allocator, MatchCondition, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
bool asio_handler_is_continuation(
read_until_match_op<AsyncReadStream,
Allocator, MatchCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
void asio_handler_invoke(Function& function,
read_until_match_op<AsyncReadStream,
Allocator, MatchCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_until_match_op<AsyncReadStream,
Allocator, MatchCondition, ReadHandler>* this_handler)
;
}
template <typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
MatchCondition match_condition, ReadHandler&& handler,
typename enable_if<is_match_condition<MatchCondition>::value>::type*)
;
}
}
#define BOOST_ASIO_SERIAL_PORT_HPP
namespace boost {
namespace asio {
typedef basic_serial_port<> serial_port;
}
}
#define BOOST_ASIO_SIGNAL_SET_HPP
namespace boost {
namespace asio {
typedef basic_signal_set<> signal_set;
}
}
#define BOOST_ASIO_STRAND_HPP
#define BOOST_ASIO_DETAIL_STRAND_SERVICE_HPP
namespace boost {
namespace asio {
namespace detail {
class strand_service
: public boost::asio::detail::service_base<strand_service>
{
private:
struct on_do_complete_exit;
struct on_dispatch_exit;
public:
class strand_impl
: public operation
{
public:
strand_impl();
private:
friend class strand_service;
friend struct on_do_complete_exit;
friend struct on_dispatch_exit;
boost::asio::detail::mutex mutex_;
bool locked_;
op_queue<operation> waiting_queue_;
op_queue<operation> ready_queue_;
};
typedef strand_impl* implementation_type;
inline explicit strand_service(boost::asio::io_service& io_service);
inline void shutdown_service();
inline void construct(implementation_type& impl);
template <typename Handler>
void dispatch(implementation_type& impl, Handler& handler);
template <typename Handler>
void post(implementation_type& impl, Handler& handler);
inline bool running_in_this_thread(
const implementation_type& impl) const;
private:
inline bool do_dispatch(implementation_type& impl, operation* op);
inline void do_post(implementation_type& impl,
operation* op, bool is_continuation);
inline static void do_complete(io_service_impl* owner,
operation* base, const boost::system::error_code& ec,
std::size_t bytes_transferred);
io_service_impl& io_service_;
boost::asio::detail::mutex mutex_;
enum { num_implementations = 193 };
scoped_ptr<strand_impl> implementations_[num_implementations];
std::size_t salt_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_STRAND_SERVICE_HPP
namespace boost {
namespace asio {
namespace detail {
struct strand_service::on_dispatch_exit
{
io_service_impl* io_service_;
strand_impl* impl_;
~on_dispatch_exit()
;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_STRAND_SERVICE_IPP
namespace boost {
namespace asio {
namespace detail {
struct strand_service::on_do_complete_exit
{
io_service_impl* owner_;
strand_impl* impl_;
~on_do_complete_exit()
;
};
bool strand_service::running_in_this_thread(
const implementation_type& impl) const
{
return call_stack<strand_impl>::contains(impl) != 0;
}
bool strand_service::do_dispatch(implementation_type& impl, operation* op)
{
bool can_dispatch = io_service_.can_dispatch();
impl->mutex_.lock();
if (can_dispatch && !impl->locked_)
{
impl->locked_ = true;
impl->mutex_.unlock();
return true;
}
if (impl->locked_)
{
impl->waiting_queue_.push(op);
impl->mutex_.unlock();
}
else
{
impl->locked_ = true;
impl->mutex_.unlock();
impl->ready_queue_.push(op);
io_service_.post_immediate_completion(impl, false);
}
return false;
}
}
}
}
namespace boost {
namespace asio {
class io_service::strand
{
public:
explicit strand(boost::asio::io_service& io_service)
;
~strand()
;
boost::asio::io_service& get_io_service()
;
template <typename CompletionHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<CompletionHandler, void ()>::type>::type
dispatch(CompletionHandler&& handler)
;
template <typename CompletionHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<CompletionHandler, void ()>::type>::type
post(CompletionHandler&& handler)
;
template <typename Handler>
detail::wrapped_handler<strand, Handler, detail::is_continuation_if_running>
wrap(Handler handler)
;
bool running_in_this_thread() const
;
private:
boost::asio::detail::strand_service& service_;
boost::asio::detail::strand_service::implementation_type impl_;
};
typedef boost::asio::io_service::strand strand;
}
}
#define BOOST_ASIO_STREAMBUF_HPP
namespace boost {
namespace asio {
typedef basic_streambuf<> streambuf;
}
}
#define BOOST_ASIO_VERSION_HPP
#define BOOST_ASIO_VERSION 101001
#define BOOST_ASIO_WINDOWS_BASIC_HANDLE_HPP
#define BOOST_ASIO_WINDOWS_BASIC_OBJECT_HANDLE_HPP
#define BOOST_ASIO_WINDOWS_BASIC_RANDOM_ACCESS_HANDLE_HPP
#define BOOST_ASIO_WINDOWS_BASIC_STREAM_HANDLE_HPP
#define BOOST_ASIO_WINDOWS_OBJECT_HANDLE_HPP
#define BOOST_ASIO_WINDOWS_OBJECT_HANDLE_SERVICE_HPP
#define BOOST_ASIO_WINDOWS_OVERLAPPED_PTR_HPP
#define BOOST_ASIO_WINDOWS_RANDOM_ACCESS_HANDLE_HPP
#define BOOST_ASIO_WINDOWS_RANDOM_ACCESS_HANDLE_SERVICE_HPP
#define BOOST_ASIO_WINDOWS_STREAM_HANDLE_HPP
#define BOOST_ASIO_WINDOWS_STREAM_HANDLE_SERVICE_HPP
#define BOOST_ASIO_WRITE_AT_HPP
namespace boost {
namespace asio {
template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
uint64_t offset, const ConstBufferSequence& buffers);
template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
uint64_t offset, const ConstBufferSequence& buffers,
boost::system::error_code& ec);
template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
typename CompletionCondition>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
uint64_t offset, const ConstBufferSequence& buffers,
CompletionCondition completion_condition);
template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
typename CompletionCondition>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
uint64_t offset, const ConstBufferSequence& buffers,
CompletionCondition completion_condition, boost::system::error_code& ec);
template <typename SyncRandomAccessWriteDevice, typename Allocator>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
uint64_t offset, basic_streambuf<Allocator>& b);
template <typename SyncRandomAccessWriteDevice, typename Allocator>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
uint64_t offset, basic_streambuf<Allocator>& b,
boost::system::error_code& ec);
template <typename SyncRandomAccessWriteDevice, typename Allocator,
typename CompletionCondition>
std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
basic_streambuf<Allocator>& b, CompletionCondition completion_condition);
template <typename SyncRandomAccessWriteDevice, typename Allocator,
typename CompletionCondition>
std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
boost::system::error_code& ec);
template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
const ConstBufferSequence& buffers,
WriteHandler&& handler);
template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
typename CompletionCondition, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_at(AsyncRandomAccessWriteDevice& d,
uint64_t offset, const ConstBufferSequence& buffers,
CompletionCondition completion_condition,
WriteHandler&& handler);
template <typename AsyncRandomAccessWriteDevice, typename Allocator,
typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
basic_streambuf<Allocator>& b, WriteHandler&& handler);
template <typename AsyncRandomAccessWriteDevice, typename Allocator,
typename CompletionCondition, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
WriteHandler&& handler);
}
}
int main(int, char**argv)
;
// this should reproduce the crash:
// /usr/lib/creduce/clang_delta --transformation=replace-function-def-with-decl --counter=232 /home/b/src/WebWhois/src/bug/clang_delta_crash_tmp_file23DKB5.cc
#define __cplusplus 201103L
#define __GNUC__ 5
#define __GNUC_MINOR__ 0
#define __GNUC_PATCHLEVEL__ 0
#define __VERSION__ "5.0.0 20141001 (experimental) [fixups revision 12b2b6a:0acec45:61bcd046b7d40b28fc3e140b32d29f170581737d]"
#define __ATOMIC_RELAXED 0
#define __ATOMIC_SEQ_CST 5
#define __ATOMIC_ACQUIRE 2
#define __ATOMIC_RELEASE 3
#define __ATOMIC_ACQ_REL 4
#define __ATOMIC_CONSUME 1
#define __FINITE_MATH_ONLY__ 0
#define _LP64 1
#define __LP64__ 1
#define __SIZEOF_INT__ 4
#define __SIZEOF_LONG__ 8
#define __SIZEOF_LONG_LONG__ 8
#define __SIZEOF_SHORT__ 2
#define __SIZEOF_FLOAT__ 4
#define __SIZEOF_DOUBLE__ 8
#define __SIZEOF_LONG_DOUBLE__ 16
#define __SIZEOF_SIZE_T__ 8
#define __CHAR_BIT__ 8
#define __BIGGEST_ALIGNMENT__ 16
#define __ORDER_LITTLE_ENDIAN__ 1234
#define __ORDER_BIG_ENDIAN__ 4321
#define __ORDER_PDP_ENDIAN__ 3412
#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
#define __FLOAT_WORD_ORDER__ __ORDER_LITTLE_ENDIAN__
#define __SIZEOF_POINTER__ 8
#define __GNUG__ 5
#define __SIZE_TYPE__ long unsigned int
#define __PTRDIFF_TYPE__ long int
#define __WCHAR_TYPE__ int
#define __WINT_TYPE__ unsigned int
#define __INTMAX_TYPE__ long int
#define __UINTMAX_TYPE__ long unsigned int
#define __CHAR16_TYPE__ short unsigned int
#define __CHAR32_TYPE__ unsigned int
#define __SIG_ATOMIC_TYPE__ int
#define __INT8_TYPE__ signed char
#define __INT16_TYPE__ short int
#define __INT32_TYPE__ int
#define __INT64_TYPE__ long int
#define __UINT8_TYPE__ unsigned char
#define __UINT16_TYPE__ short unsigned int
#define __UINT32_TYPE__ unsigned int
#define __UINT64_TYPE__ long unsigned int
#define __INT_LEAST8_TYPE__ signed char
#define __INT_LEAST16_TYPE__ short int
#define __INT_LEAST32_TYPE__ int
#define __INT_LEAST64_TYPE__ long int
#define __UINT_LEAST8_TYPE__ unsigned char
#define __UINT_LEAST16_TYPE__ short unsigned int
#define __UINT_LEAST32_TYPE__ unsigned int
#define __UINT_LEAST64_TYPE__ long unsigned int
#define __INT_FAST8_TYPE__ signed char
#define __INT_FAST16_TYPE__ long int
#define __INT_FAST32_TYPE__ long int
#define __INT_FAST64_TYPE__ long int
#define __UINT_FAST8_TYPE__ unsigned char
#define __UINT_FAST16_TYPE__ long unsigned int
#define __UINT_FAST32_TYPE__ long unsigned int
#define __UINT_FAST64_TYPE__ long unsigned int
#define __INTPTR_TYPE__ long int
#define __UINTPTR_TYPE__ long unsigned int
#define __GXX_WEAK__ 1
#define __DEPRECATED 1
#define __GXX_RTTI 1
#define __GXX_EXPERIMENTAL_CXX0X__ 1
#define __EXCEPTIONS 1
#define __GXX_ABI_VERSION 999999
#define __SCHAR_MAX__ 0x7f
#define __SHRT_MAX__ 0x7fff
#define __INT_MAX__ 0x7fffffff
#define __LONG_MAX__ 0x7fffffffffffffffL
#define __LONG_LONG_MAX__ 0x7fffffffffffffffLL
#define __WCHAR_MAX__ 0x7fffffff
#define __WCHAR_MIN__ (-__WCHAR_MAX__ - 1)
#define __WINT_MAX__ 0xffffffffU
#define __WINT_MIN__ 0U
#define __PTRDIFF_MAX__ 0x7fffffffffffffffL
#define __SIZE_MAX__ 0xffffffffffffffffUL
#define __INTMAX_MAX__ 0x7fffffffffffffffL
#define __INTMAX_C(c) c ## L
#define __UINTMAX_MAX__ 0xffffffffffffffffUL
#define __UINTMAX_C(c) c ## UL
#define __SIG_ATOMIC_MAX__ 0x7fffffff
#define __SIG_ATOMIC_MIN__ (-__SIG_ATOMIC_MAX__ - 1)
#define __INT8_MAX__ 0x7f
#define __INT16_MAX__ 0x7fff
#define __INT32_MAX__ 0x7fffffff
#define __INT64_MAX__ 0x7fffffffffffffffL
#define __UINT8_MAX__ 0xff
#define __UINT16_MAX__ 0xffff
#define __UINT32_MAX__ 0xffffffffU
#define __UINT64_MAX__ 0xffffffffffffffffUL
#define __INT_LEAST8_MAX__ 0x7f
#define __INT8_C(c) c
#define __INT_LEAST16_MAX__ 0x7fff
#define __INT16_C(c) c
#define __INT_LEAST32_MAX__ 0x7fffffff
#define __INT32_C(c) c
#define __INT_LEAST64_MAX__ 0x7fffffffffffffffL
#define __INT64_C(c) c ## L
#define __UINT_LEAST8_MAX__ 0xff
#define __UINT8_C(c) c
#define __UINT_LEAST16_MAX__ 0xffff
#define __UINT16_C(c) c
#define __UINT_LEAST32_MAX__ 0xffffffffU
#define __UINT32_C(c) c ## U
#define __UINT_LEAST64_MAX__ 0xffffffffffffffffUL
#define __UINT64_C(c) c ## UL
#define __INT_FAST8_MAX__ 0x7f
#define __INT_FAST16_MAX__ 0x7fffffffffffffffL
#define __INT_FAST32_MAX__ 0x7fffffffffffffffL
#define __INT_FAST64_MAX__ 0x7fffffffffffffffL
#define __UINT_FAST8_MAX__ 0xff
#define __UINT_FAST16_MAX__ 0xffffffffffffffffUL
#define __UINT_FAST32_MAX__ 0xffffffffffffffffUL
#define __UINT_FAST64_MAX__ 0xffffffffffffffffUL
#define __INTPTR_MAX__ 0x7fffffffffffffffL
#define __UINTPTR_MAX__ 0xffffffffffffffffUL
#define __GCC_IEC_559 2
#define __GCC_IEC_559_COMPLEX 2
#define __FLT_EVAL_METHOD__ 0
#define __DEC_EVAL_METHOD__ 2
#define __FLT_RADIX__ 2
#define __FLT_MANT_DIG__ 24
#define __FLT_DIG__ 6
#define __FLT_MIN_EXP__ (-125)
#define __FLT_MIN_10_EXP__ (-37)
#define __FLT_MAX_EXP__ 128
#define __FLT_MAX_10_EXP__ 38
#define __FLT_DECIMAL_DIG__ 9
#define __FLT_MAX__ 3.40282346638528859812e+38F
#define __FLT_MIN__ 1.17549435082228750797e-38F
#define __FLT_EPSILON__ 1.19209289550781250000e-7F
#define __FLT_DENORM_MIN__ 1.40129846432481707092e-45F
#define __FLT_HAS_DENORM__ 1
#define __FLT_HAS_INFINITY__ 1
#define __FLT_HAS_QUIET_NAN__ 1
#define __DBL_MANT_DIG__ 53
#define __DBL_DIG__ 15
#define __DBL_MIN_EXP__ (-1021)
#define __DBL_MIN_10_EXP__ (-307)
#define __DBL_MAX_EXP__ 1024
#define __DBL_MAX_10_EXP__ 308
#define __DBL_DECIMAL_DIG__ 17
#define __DBL_MAX__ double(1.79769313486231570815e+308L)
#define __DBL_MIN__ double(2.22507385850720138309e-308L)
#define __DBL_EPSILON__ double(2.22044604925031308085e-16L)
#define __DBL_DENORM_MIN__ double(4.94065645841246544177e-324L)
#define __DBL_HAS_DENORM__ 1
#define __DBL_HAS_INFINITY__ 1
#define __DBL_HAS_QUIET_NAN__ 1
#define __LDBL_MANT_DIG__ 64
#define __LDBL_DIG__ 18
#define __LDBL_MIN_EXP__ (-16381)
#define __LDBL_MIN_10_EXP__ (-4931)
#define __LDBL_MAX_EXP__ 16384
#define __LDBL_MAX_10_EXP__ 4932
#define __DECIMAL_DIG__ 21
#define __LDBL_MAX__ 1.18973149535723176502e+4932L
#define __LDBL_MIN__ 3.36210314311209350626e-4932L
#define __LDBL_EPSILON__ 1.08420217248550443401e-19L
#define __LDBL_DENORM_MIN__ 3.64519953188247460253e-4951L
#define __LDBL_HAS_DENORM__ 1
#define __LDBL_HAS_INFINITY__ 1
#define __LDBL_HAS_QUIET_NAN__ 1
#define __DEC32_MANT_DIG__ 7
#define __DEC32_MIN_EXP__ (-94)
#define __DEC32_MAX_EXP__ 97
#define __DEC32_MIN__ 1E-95DF
#define __DEC32_MAX__ 9.999999E96DF
#define __DEC32_EPSILON__ 1E-6DF
#define __DEC32_SUBNORMAL_MIN__ 0.000001E-95DF
#define __DEC64_MANT_DIG__ 16
#define __DEC64_MIN_EXP__ (-382)
#define __DEC64_MAX_EXP__ 385
#define __DEC64_MIN__ 1E-383DD
#define __DEC64_MAX__ 9.999999999999999E384DD
#define __DEC64_EPSILON__ 1E-15DD
#define __DEC64_SUBNORMAL_MIN__ 0.000000000000001E-383DD
#define __DEC128_MANT_DIG__ 34
#define __DEC128_MIN_EXP__ (-6142)
#define __DEC128_MAX_EXP__ 6145
#define __DEC128_MIN__ 1E-6143DL
#define __DEC128_MAX__ 9.999999999999999999999999999999999E6144DL
#define __DEC128_EPSILON__ 1E-33DL
#define __DEC128_SUBNORMAL_MIN__ 0.000000000000000000000000000000001E-6143DL
#define __REGISTER_PREFIX__
#define __USER_LABEL_PREFIX__
#define __GNUC_STDC_INLINE__ 1
#define __NO_INLINE__ 1
#define __STRICT_ANSI__ 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 __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_TEST_AND_SET_TRUEVAL 1
#define __GCC_ATOMIC_POINTER_LOCK_FREE 2
#define __GCC_HAVE_DWARF2_CFI_ASM 1
#define __PRAGMA_REDEFINE_EXTNAME 1
#define __SIZEOF_INT128__ 16
#define __SIZEOF_WCHAR_T__ 4
#define __SIZEOF_WINT_T__ 4
#define __SIZEOF_PTRDIFF_T__ 8
#define __amd64 1
#define __amd64__ 1
#define __x86_64 1
#define __x86_64__ 1
#define __SIZEOF_FLOAT80__ 16
#define __SIZEOF_FLOAT128__ 16
#define __ATOMIC_HLE_ACQUIRE 65536
#define __ATOMIC_HLE_RELEASE 131072
#define __k8 1
#define __k8__ 1
#define __tune_corei7_avx__ 1
#define __tune_sandybridge__ 1
#define __code_model_small__ 1
#define __MMX__ 1
#define __SSE__ 1
#define __SSE2__ 1
#define __FXSR__ 1
#define __SSE_MATH__ 1
#define __SSE2_MATH__ 1
#define __gnu_linux__ 1
#define __linux 1
#define __linux__ 1
#define __unix 1
#define __unix__ 1
#define __ELF__ 1
#define __DECIMAL_BID_FORMAT__ 1
#define _GNU_SOURCE 1
#define NDEBUG 1
#undef DEBUG
#define _STDC_PREDEF_H 1
#define BOOST_ASIO_HPP
#define BOOST_ASIO_ASYNC_RESULT_HPP
#define BOOST_ASIO_DETAIL_CONFIG_HPP
#define BOOST_CONFIG_HPP
#define BOOST_USER_CONFIG <boost/config/user.hpp>
#define BOOST_COMPILER_CONFIG "boost/config/compiler/gcc.hpp"
#define BOOST_GCC (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
#define BOOST_HAS_PRAGMA_ONCE
#define BOOST_HAS_LONG_LONG
#define BOOST_HAS_NRVO
#define BOOST_LIKELY(x) __builtin_expect(x, 1)
#define BOOST_UNLIKELY(x) __builtin_expect(x, 0)
#define BOOST_SYMBOL_EXPORT __attribute__((__visibility__("default")))
#define BOOST_SYMBOL_IMPORT
#define BOOST_SYMBOL_VISIBLE __attribute__((__visibility__("default")))
#define BOOST_HAS_INT128
#define BOOST_HAS_DECLTYPE
#define BOOST_HAS_RVALUE_REFS
#define BOOST_HAS_STATIC_ASSERT
#define BOOST_HAS_VARIADIC_TMPL
#define BOOST_COMPILER "GNU C++ version " __VERSION__
#define _GLIBCXX_CSTDDEF 1
#define _GLIBCXX_CXX_CONFIG_H 1
#define __GLIBCXX__ 20141001
#define _GLIBCXX_PURE __attribute__ ((__pure__))
#define _GLIBCXX_CONST __attribute__ ((__const__))
#define _GLIBCXX_NORETURN __attribute__ ((__noreturn__))
#define _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY 1
#define _GLIBCXX_VISIBILITY(V) __attribute__ ((__visibility__ (#V)))
#define _GLIBCXX_USE_DEPRECATED 1
#define _GLIBCXX_DEPRECATED __attribute__ ((__deprecated__))
#define _GLIBCXX_ABI_TAG_CXX11 __attribute ((__abi_tag__ ("cxx11")))
#define _GLIBCXX_CONSTEXPR constexpr
#define _GLIBCXX_USE_CONSTEXPR constexpr
#define _GLIBCXX_NOEXCEPT noexcept
#define _GLIBCXX_USE_NOEXCEPT noexcept
#define _GLIBCXX_THROW(_EXC)
#define _GLIBCXX_NOTHROW _GLIBCXX_USE_NOEXCEPT
#define _GLIBCXX_THROW_OR_ABORT(_EXC) (throw (_EXC))
#define _GLIBCXX_EXTERN_TEMPLATE 1
namespace std
{
typedef long unsigned int size_t;
typedef long int ptrdiff_t;
typedef decltype(nullptr) nullptr_t;
}
#define _GLIBCXX_INLINE_VERSION 0
#define _GLIBCXX_BEGIN_NAMESPACE_VERSION
#define _GLIBCXX_END_NAMESPACE_VERSION
#define _GLIBCXX_STD_A std
#define _GLIBCXX_STD_C std
#define _GLIBCXX_BEGIN_NAMESPACE_ALGO
#define _GLIBCXX_END_NAMESPACE_ALGO
#define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
#define _GLIBCXX_END_NAMESPACE_CONTAINER
#undef _GLIBCXX_LONG_DOUBLE_COMPAT
#define _GLIBCXX_NAMESPACE_LDBL
#define _GLIBCXX_BEGIN_NAMESPACE_LDBL
#define _GLIBCXX_END_NAMESPACE_LDBL
#define __glibcxx_assert(_Condition)
#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_OS_DEFINES 1
#define __NO_CTYPE 1
#define _FEATURES_H 1
#undef __USE_ISOC11
#undef __USE_ISOC99
#undef __USE_ISOC95
#undef __USE_ISOCXX11
#undef __USE_POSIX
#undef __USE_POSIX2
#undef __USE_POSIX199309
#undef __USE_POSIX199506
#undef __USE_XOPEN
#undef __USE_XOPEN_EXTENDED
#undef __USE_UNIX98
#undef __USE_XOPEN2K
#undef __USE_XOPEN2KXSI
#undef __USE_XOPEN2K8
#undef __USE_XOPEN2K8XSI
#undef __USE_LARGEFILE
#undef __USE_LARGEFILE64
#undef __USE_FILE_OFFSET64
#undef __USE_BSD
#undef __USE_SVID
#undef __USE_MISC
#undef __USE_ATFILE
#undef __USE_GNU
#undef __USE_REENTRANT
#undef __USE_FORTIFY_LEVEL
#undef __KERNEL_STRICT_NAMES
#define __KERNEL_STRICT_NAMES
#define __GNUC_PREREQ(maj,min) ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
#undef _ISOC95_SOURCE
#define _ISOC95_SOURCE 1
#undef _ISOC99_SOURCE
#define _ISOC99_SOURCE 1
#undef _ISOC11_SOURCE
#define _ISOC11_SOURCE 1
#undef _POSIX_SOURCE
#define _POSIX_SOURCE 1
#undef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 200809L
#undef _XOPEN_SOURCE
#define _XOPEN_SOURCE 700
#undef _XOPEN_SOURCE_EXTENDED
#define _XOPEN_SOURCE_EXTENDED 1
#undef _LARGEFILE64_SOURCE
#define _LARGEFILE64_SOURCE 1
#undef _DEFAULT_SOURCE
#define _DEFAULT_SOURCE 1
#undef _BSD_SOURCE
#define _BSD_SOURCE 1
#undef _SVID_SOURCE
#define _SVID_SOURCE 1
#undef _ATFILE_SOURCE
#define _ATFILE_SOURCE 1
#undef _DEFAULT_SOURCE
#define _DEFAULT_SOURCE 1
#undef _BSD_SOURCE
#define _BSD_SOURCE 1
#undef _SVID_SOURCE
#define _SVID_SOURCE 1
#define __USE_ISOC11 1
#define __USE_ISOC99 1
#define __USE_ISOC95 1
#define __USE_ISOCXX11 1
#undef _POSIX_SOURCE
#define _POSIX_SOURCE 1
#undef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 200809L
#define __USE_POSIX 1
#define __USE_POSIX2 1
#define __USE_POSIX199309 1
#define __USE_POSIX199506 1
#define __USE_XOPEN2K 1
#undef __USE_ISOC95
#define __USE_ISOC95 1
#undef __USE_ISOC99
#define __USE_ISOC99 1
#define __USE_XOPEN2K8 1
#undef _ATFILE_SOURCE
#define _ATFILE_SOURCE 1
#define __USE_XOPEN 1
#define __USE_XOPEN_EXTENDED 1
#define __USE_UNIX98 1
#undef _LARGEFILE_SOURCE
#define _LARGEFILE_SOURCE 1
#define __USE_XOPEN2K8 1
#define __USE_XOPEN2K8XSI 1
#define __USE_XOPEN2K 1
#define __USE_XOPEN2KXSI 1
#undef __USE_ISOC95
#define __USE_ISOC95 1
#undef __USE_ISOC99
#define __USE_ISOC99 1
#define __USE_LARGEFILE 1
#define __USE_LARGEFILE64 1
#define __USE_MISC 1
#define __USE_BSD 1
#define __USE_SVID 1
#define __USE_ATFILE 1
#define __USE_GNU 1
#define __USE_FORTIFY_LEVEL 0
#undef __GNU_LIBRARY__
#define __GNU_LIBRARY__ 6
#define __GLIBC__ 2
#define __GLIBC_MINOR__ 19
#define __GLIBC_PREREQ(maj,min) ((__GLIBC__ << 16) + __GLIBC_MINOR__ >= ((maj) << 16) + (min))
#define _SYS_CDEFS_H 1
#undef __P
#undef __PMT
#define __LEAF , __leaf__
#define __LEAF_ATTR __attribute__ ((__leaf__))
#define __THROW throw ()
#define __THROWNL throw ()
#define __NTH(fct) __LEAF_ATTR fct throw ()
#define __P(args) args
#define __PMT(args) args
#define __CONCAT(x,y) x ## y
#define __STRING(x) #x
#define __ptr_t void *
#define __long_double_t long double
#define __BEGIN_DECLS extern "C" {
#define __END_DECLS }
#define __BEGIN_NAMESPACE_STD
#define __END_NAMESPACE_STD
#define __USING_NAMESPACE_STD(name)
#define __BEGIN_NAMESPACE_C99
#define __END_NAMESPACE_C99
#define __USING_NAMESPACE_C99(name)
#define __bos(ptr) __builtin_object_size (ptr, __USE_FORTIFY_LEVEL > 1)
#define __bos0(ptr) __builtin_object_size (ptr, 0)
#define __fortify_function __extern_always_inline __attribute_artificial__
#define __warndecl(name,msg) extern void name (void) __attribute__((__warning__ (msg)))
#define __warnattr(msg) __attribute__((__warning__ (msg)))
#define __errordecl(name,msg) extern void name (void) __attribute__((__error__ (msg)))
#define __flexarr []
#define __REDIRECT(name,proto,alias) name proto __asm__ (__ASMNAME (#alias))
#define __REDIRECT_NTH(name,proto,alias) name proto __THROW __asm__ (__ASMNAME (#alias))
#define __REDIRECT_NTHNL(name,proto,alias) name proto __THROWNL __asm__ (__ASMNAME (#alias))
#define __ASMNAME(cname) __ASMNAME2 (__USER_LABEL_PREFIX__, cname)
#define __ASMNAME2(prefix,cname) __STRING (prefix) cname
#define __attribute_malloc__ __attribute__ ((__malloc__))
#define __attribute_alloc_size__(params) __attribute__ ((__alloc_size__ params))
#define __attribute_pure__ __attribute__ ((__pure__))
#define __attribute_const__ __attribute__ ((__const__))
#define __attribute_used__ __attribute__ ((__used__))
#define __attribute_noinline__ __attribute__ ((__noinline__))
#define __attribute_deprecated__ __attribute__ ((__deprecated__))
#define __attribute_format_arg__(x) __attribute__ ((__format_arg__ (x)))
#define __attribute_format_strfmon__(a,b) __attribute__ ((__format__ (__strfmon__, a, b)))
#define __nonnull(params) __attribute__ ((__nonnull__ params))
#define __attribute_warn_unused_result__ __attribute__ ((__warn_unused_result__))
#define __wur
#define __always_inline __inline __attribute__ ((__always_inline__))
#define __attribute_artificial__ __attribute__ ((__artificial__))
#define __extern_inline extern __inline __attribute__ ((__gnu_inline__))
#define __extern_always_inline extern __always_inline __attribute__ ((__gnu_inline__))
#define __va_arg_pack() __builtin_va_arg_pack ()
#define __va_arg_pack_len() __builtin_va_arg_pack_len ()
#define __restrict_arr
#define __glibc_unlikely(cond) __builtin_expect ((cond), 0)
#define __glibc_likely(cond) __builtin_expect ((cond), 1)
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
#define __LDBL_REDIR1(name,proto,alias) name proto
#define __LDBL_REDIR(name,proto) name proto
#define __LDBL_REDIR1_NTH(name,proto,alias) name proto __THROW
#define __LDBL_REDIR_NTH(name,proto) name proto __THROW
#define __LDBL_REDIR_DECL(name)
#define __REDIRECT_LDBL(name,proto,alias) __REDIRECT (name, proto, alias)
#define __REDIRECT_NTH_LDBL(name,proto,alias) __REDIRECT_NTH (name, proto, alias)
#define __stub_bdflush
#define __stub_chflags
#define __stub_fattach
#define __stub_fchflags
#define __stub_fdetach
#define __stub_getmsg
#define __stub_gtty
#define __stub_lchmod
#define __stub_putmsg
#define __stub_revoke
#define __stub_setlogin
#define __stub_sigreturn
#define __stub_sstk
#define __stub_stty
#undef _GLIBCXX_HAVE_GETS
#define _GLIBCXX_CPU_DEFINES 1
#define _GLIBCXX_PSEUDO_VISIBILITY(V)
#define _GLIBCXX_WEAK_DEFINITION
#define _GLIBCXX_FAST_MATH 0
#define __N(msgid) (msgid)
#undef min
#undef max
#define _GLIBCXX_HAVE_ACOSF 1
#define _GLIBCXX_HAVE_ACOSL 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_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_EXECINFO_H 1
#define _GLIBCXX_HAVE_EXPF 1
#define _GLIBCXX_HAVE_EXPL 1
#define _GLIBCXX_HAVE_FABSF 1
#define _GLIBCXX_HAVE_FABSL 1
#define _GLIBCXX_HAVE_FENV_H 1
#define _GLIBCXX_HAVE_FINITE 1
#define _GLIBCXX_HAVE_FINITEF 1
#define _GLIBCXX_HAVE_FINITEL 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
#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
#define _GLIBCXX_HAVE_ISINF 1
#define _GLIBCXX_HAVE_ISINFF 1
#define _GLIBCXX_HAVE_ISINFL 1
#define _GLIBCXX_HAVE_ISNAN 1
#define _GLIBCXX_HAVE_ISNANF 1
#define _GLIBCXX_HAVE_ISNANL 1
#define _GLIBCXX_HAVE_ISWBLANK 1
#define _GLIBCXX_HAVE_LC_MESSAGES 1
#define _GLIBCXX_HAVE_LDEXPF 1
#define _GLIBCXX_HAVE_LDEXPL 1
#define _GLIBCXX_HAVE_LIBINTL_H 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
#define _GLIBCXX_HAVE_MBSTATE_T 1
#define _GLIBCXX_HAVE_MEMORY_H 1
#define _GLIBCXX_HAVE_MODF 1
#define _GLIBCXX_HAVE_MODFF 1
#define _GLIBCXX_HAVE_MODFL 1
#define _GLIBCXX_HAVE_POLL 1
#define _GLIBCXX_HAVE_POWF 1
#define _GLIBCXX_HAVE_POWL 1
#define _GLIBCXX_HAVE_QUICK_EXIT 1
#define _GLIBCXX_HAVE_SETENV 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_L 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_STRXFRM_L 1
#define _GLIBCXX_HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT 1
#define _GLIBCXX_HAVE_SYS_IOCTL_H 1
#define _GLIBCXX_HAVE_SYS_IPC_H 1
#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_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_UNISTD_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
#define _GLIBCXX_HAVE___CXA_THREAD_ATEXIT_IMPL 1
#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"
#define STDC_HEADERS 1
#define _GLIBCXX_ATOMIC_BUILTINS 1
#define _GLIBCXX_FULLY_DYNAMIC_STRING 0
#define _GLIBCXX_HAS_GTHREADS 1
#define _GLIBCXX_HOSTED 1
#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
#define _GLIBCXX_USE_C99 1
#define _GLIBCXX_USE_C99_COMPLEX 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 1
#define _GLIBCXX_USE_C99_MATH_TR1 1
#define _GLIBCXX_USE_C99_STDINT_TR1 1
#define _GLIBCXX_USE_CLOCK_MONOTONIC 1
#define _GLIBCXX_USE_CLOCK_REALTIME 1
#define _GLIBCXX_USE_DECIMAL_FLOAT 1
#define _GLIBCXX_USE_FLOAT128 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
#define _GLIBCXX_USE_NLS 1
#define _GLIBCXX_USE_RANDOM_TR1 1
#define _GLIBCXX_USE_SCHED_YIELD 1
#define _GLIBCXX_USE_SC_NPROCESSORS_ONLN 1
#define _GLIBCXX_USE_TMPNAM 1
#define _GLIBCXX_USE_WCHAR_T 1
#define _GLIBCXX_VERBOSE 1
#define _GLIBCXX_X86_RDRAND 1
#define _GTHREAD_USE_MUTEX_TIMEDLOCK 1
#define _STDDEF_H
#define _STDDEF_H_
#define _ANSI_STDDEF_H
#define _PTRDIFF_T
#define _T_PTRDIFF_
#define _T_PTRDIFF
#define __PTRDIFF_T
#define _PTRDIFF_T_
#define _BSD_PTRDIFF_T_
#define ___int_ptrdiff_t_h
#define _GCC_PTRDIFF_T
#define _PTRDIFF_T_DECLARED
typedef long int ptrdiff_t;
#undef __need_ptrdiff_t
#define __size_t__
#define __SIZE_T__
#define _SIZE_T
#define _SYS_SIZE_T_H
#define _T_SIZE_
#define _T_SIZE
#define __SIZE_T
#define _SIZE_T_
#define _BSD_SIZE_T_
#define _SIZE_T_DEFINED_
#define _SIZE_T_DEFINED
#define _BSD_SIZE_T_DEFINED_
#define _SIZE_T_DECLARED
#define ___int_size_t_h
#define _GCC_SIZE_T
#define _SIZET_
#define __size_t
typedef long unsigned int size_t;
#undef __need_size_t
#define __wchar_t__
#define __WCHAR_T__
#define _WCHAR_T
#define _T_WCHAR_
#define _T_WCHAR
#define __WCHAR_T
#define _WCHAR_T_
#define _BSD_WCHAR_T_
#define _WCHAR_T_DEFINED_
#define _WCHAR_T_DEFINED
#define _WCHAR_T_H
#define ___int_wchar_t_h
#define __INT_WCHAR_T_H
#define _GCC_WCHAR_T
#define _WCHAR_T_DECLARED
#undef _BSD_WCHAR_T_
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define _GCC_MAX_ALIGN_T
typedef struct {
long long __max_align_ll __attribute__((__aligned__(__alignof__(long long))));
long double __max_align_ld __attribute__((__aligned__(__alignof__(long double))));
} max_align_t;
#define _GXX_NULLPTR_T
typedef decltype(nullptr) nullptr_t;
namespace std
{
using ::max_align_t;
}
#define BOOST_CONFIG_UTILITY
#define BOOST_TR1_NO_RECURSION
#define BOOST_CONFIG_NO_UTILITY_RECURSION
#define _GLIBCXX_UTILITY 1
#define _STL_RELOPS_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
namespace rel_ops
{
template <class _Tp>
bool
operator!=(const _Tp& __x, const _Tp& __y)
;
template <class _Tp>
bool
operator>(const _Tp& __x, const _Tp& __y)
;
template <class _Tp>
bool
operator<=(const _Tp& __x, const _Tp& __y)
;
template <class _Tp>
bool
operator>=(const _Tp& __x, const _Tp& __y)
;
}
}
#define _STL_PAIR_H 1
#define _MOVE_H 1
#define _CONCEPT_CHECK_H 1
#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)
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp>
inline _Tp*
__addressof(_Tp& __r) noexcept
{
return reinterpret_cast<_Tp*>
(&const_cast<char&>(reinterpret_cast<const volatile char&>(__r)));
}
}
#define _GLIBCXX_TYPE_TRAITS 1
namespace std
{
typedef short unsigned int uint_least16_t;
typedef unsigned int uint_least32_t;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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 ;
};
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, 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>
{ };
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<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 { };
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 { };
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_standard_layout
: public integral_constant<bool, __is_standard_layout(_Tp)>
{ };
template<typename _Tp>
struct is_pod
: public integral_constant<bool, __is_pod(_Tp)>
{ };
template<typename _Tp>
struct is_literal_type
: public integral_constant<bool, __is_literal_type(_Tp)>
{ };
template<typename _Tp>
struct is_empty
: public integral_constant<bool, __is_empty(_Tp)>
{ };
template<typename _Tp>
struct is_polymorphic
: public integral_constant<bool, __is_polymorphic(_Tp)>
{ };
template<typename _Tp>
struct is_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>>>::type
{ };
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>>>::type
{ };
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>>::type
{ };
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>>::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
{ };
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>>::type
{ };
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 _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>> 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>
>>>::type
{ };
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>>::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>>::type
{ };
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...>>::type
{ };
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>>::type
{ };
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>
struct is_trivially_destructible
: public __and_<is_destructible<_Tp>, integral_constant<bool,
__has_trivial_destructor(_Tp)>>::type
{ };
template<typename _Tp>
struct has_trivial_default_constructor
: public integral_constant<bool, __has_trivial_constructor(_Tp)>
{ };
template<typename _Tp>
struct has_trivial_copy_constructor
: public integral_constant<bool, __has_trivial_copy(_Tp)>
{ };
template<typename _Tp>
struct has_trivial_copy_assign
: public integral_constant<bool, __has_trivial_assign(_Tp)>
{ };
template<typename _Tp>
struct has_virtual_destructor
: public integral_constant<bool, __has_virtual_destructor(_Tp)>
{ };
template<typename _Tp>
struct alignment_of
: public integral_constant<std::size_t, __alignof__(_Tp)> { };
template<typename>
struct rank
: public integral_constant<std::size_t, 0> { };
template<typename _Tp, std::size_t _Size>
struct rank<_Tp[_Size]>
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
template<typename _Tp>
struct rank<_Tp[]>
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
template<typename, unsigned _Uint>
struct extent
: public integral_constant<std::size_t, 0> { };
template<typename _Tp, unsigned _Uint, std::size_t _Size>
struct extent<_Tp[_Size], _Uint>
: public integral_constant<std::size_t,
_Uint == 0 ? _Size : extent<_Tp,
_Uint - 1>::value>
{ };
template<typename _Tp, unsigned _Uint>
struct extent<_Tp[], _Uint>
: public integral_constant<std::size_t,
_Uint == 0 ? 0 : extent<_Tp,
_Uint - 1>::value>
{ };
template<typename, typename>
struct is_same
: public false_type { };
template<typename _Tp>
struct is_same<_Tp, _Tp>
: public true_type { };
template<typename _Base, typename _Derived>
struct is_base_of
: public integral_constant<bool, __is_base_of(_Base, _Derived)>
{ };
template<typename _From, typename _To,
bool = __or_<is_void<_From>, is_function<_To>,
is_array<_To>>::value>
struct __is_convertible_helper
{ typedef typename is_void<_To>::type type; };
template<typename _From, typename _To>
class __is_convertible_helper<_From, _To, false>
{
template<typename _To1>
static void __test_aux(_To1);
template<typename _From1, typename _To1,
typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
static true_type
__test(int);
template<typename, typename>
static false_type
__test(...);
public:
typedef decltype(__test<_From, _To>(0)) type;
};
template<typename _From, typename _To>
struct is_convertible
: public __is_convertible_helper<_From, _To>::type
{ };
template<typename _Tp>
struct remove_const
{ typedef _Tp type; };
template<typename _Tp>
struct remove_const<_Tp const>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_volatile
{ typedef _Tp type; };
template<typename _Tp>
struct remove_volatile<_Tp volatile>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_cv
{
typedef typename
remove_const<typename remove_volatile<_Tp>::type>::type type;
};
template<typename _Tp>
struct add_const
{ typedef _Tp const type; };
template<typename _Tp>
struct add_volatile
{ typedef _Tp volatile type; };
template<typename _Tp>
struct add_cv
{
typedef typename
add_const<typename add_volatile<_Tp>::type>::type type;
};
template<typename _Tp>
struct remove_reference
{ typedef _Tp type; };
template<typename _Tp>
struct remove_reference<_Tp&>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_reference<_Tp&&>
{ typedef _Tp type; };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __add_lvalue_reference_helper
{ typedef _Tp type; };
template<typename _Tp>
struct __add_lvalue_reference_helper<_Tp, true>
{ typedef _Tp& type; };
template<typename _Tp>
struct add_lvalue_reference
: public __add_lvalue_reference_helper<_Tp>
{ };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __add_rvalue_reference_helper
{ typedef _Tp type; };
template<typename _Tp>
struct __add_rvalue_reference_helper<_Tp, true>
{ typedef _Tp&& type; };
template<typename _Tp>
struct add_rvalue_reference
: public __add_rvalue_reference_helper<_Tp>
{ };
template<typename _Unqualified, bool _IsConst, bool _IsVol>
struct __cv_selector;
template<typename _Unqualified>
struct __cv_selector<_Unqualified, false, false>
{ typedef _Unqualified __type; };
template<typename _Unqualified>
struct __cv_selector<_Unqualified, false, true>
{ typedef volatile _Unqualified __type; };
template<typename _Unqualified>
struct __cv_selector<_Unqualified, true, false>
{ typedef const _Unqualified __type; };
template<typename _Unqualified>
struct __cv_selector<_Unqualified, true, true>
{ typedef const volatile _Unqualified __type; };
template<typename _Qualified, typename _Unqualified,
bool _IsConst = is_const<_Qualified>::value,
bool _IsVol = is_volatile<_Qualified>::value>
class __match_cv_qualifiers
{
typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
public:
typedef typename __match::__type __type;
};
template<typename _Tp>
struct __make_unsigned
{ typedef _Tp __type; };
template<>
struct __make_unsigned<char>
{ typedef unsigned char __type; };
template<>
struct __make_unsigned<signed char>
{ typedef unsigned char __type; };
template<>
struct __make_unsigned<short>
{ typedef unsigned short __type; };
template<>
struct __make_unsigned<int>
{ typedef unsigned int __type; };
template<>
struct __make_unsigned<long>
{ typedef unsigned long __type; };
template<>
struct __make_unsigned<long long>
{ typedef unsigned long long __type; };
template<>
struct __make_unsigned<wchar_t> : __make_unsigned<int>
{ };
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);
typedef conditional<__b2, unsigned int, unsigned long> __cond2;
typedef typename __cond2::type __cond2_type;
typedef conditional<__b1, unsigned short, __cond2_type> __cond1;
typedef typename __cond1::type __cond1_type;
public:
typedef typename conditional<__b0, __smallest, __cond1_type>::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<char16_t> : __make_signed<uint_least16_t>
{ };
template<>
struct __make_signed<char32_t> : __make_signed<uint_least32_t>
{ };
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 signed char __smallest;
static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
static const bool __b1 = sizeof(_Tp) <= sizeof(signed short);
static const bool __b2 = sizeof(_Tp) <= sizeof(signed int);
typedef conditional<__b2, signed int, signed long> __cond2;
typedef typename __cond2::type __cond2_type;
typedef conditional<__b1, signed short, __cond2_type> __cond1;
typedef typename __cond1::type __cond1_type;
public:
typedef typename conditional<__b0, __smallest, __cond1_type>::type __type;
};
template<typename _Tp>
struct make_signed
{ typedef typename __make_signed_selector<_Tp>::__type type; };
template<>
struct make_signed<bool>;
template<typename _Tp>
struct remove_extent
{ typedef _Tp type; };
template<typename _Tp, std::size_t _Size>
struct remove_extent<_Tp[_Size]>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_extent<_Tp[]>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_all_extents
{ typedef _Tp type; };
template<typename _Tp, std::size_t _Size>
struct remove_all_extents<_Tp[_Size]>
{ typedef typename remove_all_extents<_Tp>::type type; };
template<typename _Tp>
struct remove_all_extents<_Tp[]>
{ typedef typename remove_all_extents<_Tp>::type type; };
template<typename _Tp, typename>
struct __remove_pointer_helper
{ typedef _Tp type; };
template<typename _Tp, typename _Up>
struct __remove_pointer_helper<_Tp, _Up*>
{ typedef _Up type; };
template<typename _Tp>
struct remove_pointer
: public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type>
{ };
template<typename _Tp, bool = __or_<__is_referenceable<_Tp>,
is_void<_Tp>>::value>
struct __add_pointer_helper
{ typedef _Tp type; };
template<typename _Tp>
struct __add_pointer_helper<_Tp, true>
{ typedef typename remove_reference<_Tp>::type* type; };
template<typename _Tp>
struct add_pointer
: public __add_pointer_helper<_Tp>
{ };
template<std::size_t _Len>
struct __aligned_storage_msa
{
union __type
{
unsigned char __data[_Len];
struct __attribute__((__aligned__)) { } __align;
};
};
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;
};
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;
struct __result_of_memfun_ref_impl
{
template<typename _Fp, typename _Tp1, typename... _Args>
static __success_type<decltype(
(std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
)> _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 __success_type<decltype(
((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
)> _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 __success_type<decltype(
std::declval<_Tp1>().*std::declval<_Fp>()
)> _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 __success_type<decltype(
(*std::declval<_Tp1>()).*std::declval<_Fp>()
)> _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<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, _Arg>
{ };
template<typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
: public __result_of_memfun<typename decay<_MemPtr>::type, _Arg, _Args...>
{ };
struct __result_of_other_impl
{
template<typename _Fn, typename... _Args>
static __success_type<decltype(
std::declval<_Fn>()(std::declval<_Args>()...)
)> _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 result_of<_Functor(_ArgTypes...)>
: 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
{ };
#define _GLIBCXX_HAS_NESTED_TYPE(_NTYPE) template<typename _Tp> class __has_ ##_NTYPE ##_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::_NTYPE>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_ ##_NTYPE : public __has_ ##_NTYPE ##_helper <typename remove_cv<_Tp>::type>::type { };
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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 { };
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); }
template<typename _Tp>
inline _Tp*
addressof(_Tp& __r) noexcept
{ return std::__addressof(__r); }
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")))
{
template<typename _Tp>
inline void
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 void
swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
noexcept(noexcept(swap(*__a, *__b)))
{
for (size_t __n = 0; __n < _Nm; ++__n)
swap(__a[__n], __b[__n]);
}
}
namespace std __attribute__ ((__visibility__ ("default")))
{
struct piecewise_construct_t { };
constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
template<typename...>
class tuple;
template<std::size_t...>
struct _Index_tuple;
template<class _T1, class _T2>
struct pair
{
typedef _T1 first_type;
typedef _T2 second_type;
_T1 first;
_T2 second;
constexpr pair()
: first(), second() { }
constexpr pair(const _T1& __a, const _T2& __b)
: first(__a), second(__b) { }
template<class _U1, class _U2, class = typename
enable_if<__and_<is_convertible<const _U1&, _T1>,
is_convertible<const _U2&, _T2>>::value>::type>
constexpr pair(const pair<_U1, _U2>& __p)
: first(__p.first), second(__p.second) { }
constexpr pair(const pair&) = default;
constexpr pair(pair&&) = default;
template<class _U1, class = typename
enable_if<is_convertible<_U1, _T1>::value>::type>
constexpr pair(_U1&& __x, const _T2& __y)
: first(std::forward<_U1>(__x)), second(__y) { }
template<class _U2, class = typename
enable_if<is_convertible<_U2, _T2>::value>::type>
constexpr pair(const _T1& __x, _U2&& __y)
: first(__x), second(std::forward<_U2>(__y)) { }
template<class _U1, class _U2, class = typename
enable_if<__and_<is_convertible<_U1, _T1>,
is_convertible<_U2, _T2>>::value>::type>
constexpr pair(_U1&& __x, _U2&& __y)
: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
template<class _U1, class _U2, class = typename
enable_if<__and_<is_convertible<_U1, _T1>,
is_convertible<_U2, _T2>>::value>::type>
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=(const pair& __p)
;
pair&
operator=(pair&& __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<class _U1, class _U2>
pair&
operator=(const pair<_U1, _U2>& __p)
{
first = __p.first;
second = __p.second;
return *this;
}
template<class _U1, class _U2>
pair&
operator=(pair<_U1, _U2>&& __p)
{
first = std::forward<_U1>(__p.first);
second = std::forward<_U2>(__p.second);
return *this;
}
void
swap(pair& __p)
noexcept(noexcept(swap(first, __p.first))
&& noexcept(swap(second, __p.second)))
{
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<class _T1, class _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<class _T1, class _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<class _T1, class _T2>
inline constexpr bool
operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x == __y); }
template<class _T1, class _T2>
inline constexpr bool
operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __y < __x; }
template<class _T1, class _T2>
inline constexpr bool
operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__y < __x); }
template<class _T1, class _T2>
inline constexpr bool
operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x < __y); }
template<class _T1, class _T2>
inline void
swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
template<class _T1, class _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));
}
}
#define _INITIALIZER_LIST
#pragma GCC visibility push(default)
namespace std
{
template<class _E>
class initializer_list
{
public:
typedef _E value_type;
typedef const _E& reference;
typedef const _E& const_reference;
typedef size_t size_type;
typedef const _E* iterator;
typedef const _E* const_iterator;
private:
iterator _M_array;
size_type _M_len;
constexpr initializer_list(const_iterator __a, size_type __l)
: _M_array(__a), _M_len(__l) { }
public:
constexpr initializer_list() noexcept
: _M_array(0), _M_len(0) { }
constexpr size_type
size() const noexcept { return _M_len; }
constexpr const_iterator
begin() const noexcept { return _M_array; }
constexpr const_iterator
end() const noexcept { return begin() + size(); }
};
template<class _Tp>
constexpr const _Tp*
begin(initializer_list<_Tp> __ils) noexcept
{ return __ils.begin(); }
template<class _Tp>
constexpr const _Tp*
end(initializer_list<_Tp> __ils) noexcept
{ return __ils.end(); }
}
#pragma GCC visibility pop
namespace std __attribute__ ((__visibility__ ("default")))
{
template<class _Tp>
class tuple_size;
template<std::size_t _Int, class _Tp>
class tuple_element;
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); }
template<size_t... _Indexes>
struct _Index_tuple
{
typedef _Index_tuple<_Indexes..., sizeof...(_Indexes)> __next;
};
template<size_t _Num>
struct _Build_index_tuple
{
typedef typename _Build_index_tuple<_Num - 1>::__type::__next __type;
};
template<>
struct _Build_index_tuple<0>
{
typedef _Index_tuple<> __type;
};
}
#undef BOOST_TR1_NO_RECURSION
#undef BOOST_CONFIG_NO_UTILITY_RECURSION
#define BOOST_STDLIB_CONFIG "boost/config/stdlib/libstdcpp3.hpp"
#define BOOST_GNU_STDLIB 1
#define BOOST_STDLIB "GNU libstdc++ version " BOOST_STRINGIZE(__GLIBCXX__)
#define BOOST_HAS_THREADS
#define _UNISTD_H 1
extern "C" {
#define _POSIX_VERSION 200809L
#define __POSIX2_THIS_VERSION 200809L
#define _POSIX2_VERSION __POSIX2_THIS_VERSION
#define _POSIX2_C_BIND __POSIX2_THIS_VERSION
#define _POSIX2_C_DEV __POSIX2_THIS_VERSION
#define _POSIX2_SW_DEV __POSIX2_THIS_VERSION
#define _POSIX2_LOCALEDEF __POSIX2_THIS_VERSION
#define _XOPEN_VERSION 700
#define _XOPEN_XCU_VERSION 4
#define _XOPEN_XPG2 1
#define _XOPEN_XPG3 1
#define _XOPEN_XPG4 1
#define _XOPEN_UNIX 1
#define _XOPEN_CRYPT 1
#define _XOPEN_ENH_I18N 1
#define _XOPEN_LEGACY 1
#define _BITS_POSIX_OPT_H 1
#define _POSIX_JOB_CONTROL 1
#define _POSIX_SAVED_IDS 1
#define _POSIX_PRIORITY_SCHEDULING 200809L
#define _POSIX_SYNCHRONIZED_IO 200809L
#define _POSIX_FSYNC 200809L
#define _POSIX_MAPPED_FILES 200809L
#define _POSIX_MEMLOCK 200809L
#define _POSIX_MEMLOCK_RANGE 200809L
#define _POSIX_MEMORY_PROTECTION 200809L
#define _POSIX_CHOWN_RESTRICTED 0
#define _POSIX_VDISABLE '\0'
#define _POSIX_NO_TRUNC 1
#define _XOPEN_REALTIME 1
#define _XOPEN_REALTIME_THREADS 1
#define _XOPEN_SHM 1
#define _POSIX_THREADS 200809L
#define _POSIX_REENTRANT_FUNCTIONS 1
#define _POSIX_THREAD_SAFE_FUNCTIONS 200809L
#define _POSIX_THREAD_PRIORITY_SCHEDULING 200809L
#define _POSIX_THREAD_ATTR_STACKSIZE 200809L
#define _POSIX_THREAD_ATTR_STACKADDR 200809L
#define _POSIX_THREAD_PRIO_INHERIT 200809L
#define _POSIX_THREAD_PRIO_PROTECT 200809L
#define _POSIX_THREAD_ROBUST_PRIO_INHERIT 200809L
#define _POSIX_THREAD_ROBUST_PRIO_PROTECT -1
#define _POSIX_SEMAPHORES 200809L
#define _POSIX_REALTIME_SIGNALS 200809L
#define _POSIX_ASYNCHRONOUS_IO 200809L
#define _POSIX_ASYNC_IO 1
#define _LFS_ASYNCHRONOUS_IO 1
#define _POSIX_PRIORITIZED_IO 200809L
#define _LFS64_ASYNCHRONOUS_IO 1
#define _LFS_LARGEFILE 1
#define _LFS64_LARGEFILE 1
#define _LFS64_STDIO 1
#define _POSIX_SHARED_MEMORY_OBJECTS 200809L
#define _POSIX_CPUTIME 0
#define _POSIX_THREAD_CPUTIME 0
#define _POSIX_REGEXP 1
#define _POSIX_READER_WRITER_LOCKS 200809L
#define _POSIX_SHELL 1
#define _POSIX_TIMEOUTS 200809L
#define _POSIX_SPIN_LOCKS 200809L
#define _POSIX_SPAWN 200809L
#define _POSIX_TIMERS 200809L
#define _POSIX_BARRIERS 200809L
#define _POSIX_MESSAGE_PASSING 200809L
#define _POSIX_THREAD_PROCESS_SHARED 200809L
#define _POSIX_MONOTONIC_CLOCK 0
#define _POSIX_CLOCK_SELECTION 200809L
#define _POSIX_ADVISORY_INFO 200809L
#define _POSIX_IPV6 200809L
#define _POSIX_RAW_SOCKETS 200809L
#define _POSIX2_CHAR_TERM 200809L
#define _POSIX_SPORADIC_SERVER -1
#define _POSIX_THREAD_SPORADIC_SERVER -1
#define _POSIX_TRACE -1
#define _POSIX_TRACE_EVENT_FILTER -1
#define _POSIX_TRACE_INHERIT -1
#define _POSIX_TRACE_LOG -1
#define _POSIX_TYPED_MEMORY_OBJECTS -1
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
#define _POSIX_V7_LPBIG_OFFBIG -1
#define _POSIX_V6_LPBIG_OFFBIG -1
#define _XBS5_LPBIG_OFFBIG -1
#define _POSIX_V7_LP64_OFF64 1
#define _POSIX_V6_LP64_OFF64 1
#define _XBS5_LP64_OFF64 1
#define __ILP32_OFF32_CFLAGS "-m32"
#define __ILP32_OFF32_LDFLAGS "-m32"
#define __ILP32_OFFBIG_CFLAGS "-m32 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64"
#define __ILP32_OFFBIG_LDFLAGS "-m32"
#define __LP64_OFF64_CFLAGS "-m64"
#define __LP64_OFF64_LDFLAGS "-m64"
#define STDIN_FILENO 0
#define STDOUT_FILENO 1
#define STDERR_FILENO 2
#define _BITS_TYPES_H 1
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;
typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;
typedef signed long int __int64_t;
typedef unsigned long int __uint64_t;
typedef long int __quad_t;
typedef unsigned long int __u_quad_t;
#define __S16_TYPE short int
#define __U16_TYPE unsigned short int
#define __S32_TYPE int
#define __U32_TYPE unsigned int
#define __SLONGWORD_TYPE long int
#define __ULONGWORD_TYPE unsigned long int
#define __SQUAD_TYPE long int
#define __UQUAD_TYPE unsigned long int
#define __SWORD_TYPE long int
#define __UWORD_TYPE unsigned long int
#define __SLONG32_TYPE int
#define __ULONG32_TYPE unsigned int
#define __S64_TYPE long int
#define __U64_TYPE unsigned long int
#define __STD_TYPE typedef
#define _BITS_TYPESIZES_H 1
#define __SYSCALL_SLONG_TYPE __SLONGWORD_TYPE
#define __SYSCALL_ULONG_TYPE __ULONGWORD_TYPE
#define __DEV_T_TYPE __UQUAD_TYPE
#define __UID_T_TYPE __U32_TYPE
#define __GID_T_TYPE __U32_TYPE
#define __INO_T_TYPE __SYSCALL_ULONG_TYPE
#define __INO64_T_TYPE __UQUAD_TYPE
#define __MODE_T_TYPE __U32_TYPE
#define __NLINK_T_TYPE __SYSCALL_ULONG_TYPE
#define __FSWORD_T_TYPE __SYSCALL_SLONG_TYPE
#define __OFF_T_TYPE __SYSCALL_SLONG_TYPE
#define __OFF64_T_TYPE __SQUAD_TYPE
#define __PID_T_TYPE __S32_TYPE
#define __RLIM_T_TYPE __SYSCALL_ULONG_TYPE
#define __RLIM64_T_TYPE __UQUAD_TYPE
#define __BLKCNT_T_TYPE __SYSCALL_SLONG_TYPE
#define __BLKCNT64_T_TYPE __SQUAD_TYPE
#define __FSBLKCNT_T_TYPE __SYSCALL_ULONG_TYPE
#define __FSBLKCNT64_T_TYPE __UQUAD_TYPE
#define __FSFILCNT_T_TYPE __SYSCALL_ULONG_TYPE
#define __FSFILCNT64_T_TYPE __UQUAD_TYPE
#define __ID_T_TYPE __U32_TYPE
#define __CLOCK_T_TYPE __SYSCALL_SLONG_TYPE
#define __TIME_T_TYPE __SYSCALL_SLONG_TYPE
#define __USECONDS_T_TYPE __U32_TYPE
#define __SUSECONDS_T_TYPE __SYSCALL_SLONG_TYPE
#define __DADDR_T_TYPE __S32_TYPE
#define __KEY_T_TYPE __S32_TYPE
#define __CLOCKID_T_TYPE __S32_TYPE
#define __TIMER_T_TYPE void *
#define __BLKSIZE_T_TYPE __SYSCALL_SLONG_TYPE
#define __FSID_T_TYPE struct { int __val[2]; }
#define __SSIZE_T_TYPE __SWORD_TYPE
#define __OFF_T_MATCHES_OFF64_T 1
#define __INO_T_MATCHES_INO64_T 1
#define __FD_SETSIZE 1024
typedef unsigned long int __dev_t;
typedef unsigned int __uid_t;
typedef unsigned int __gid_t;
typedef unsigned long int __ino_t;
typedef unsigned long int __ino64_t;
typedef unsigned int __mode_t;
typedef unsigned long int __nlink_t;
typedef long int __off_t;
typedef long int __off64_t;
typedef int __pid_t;
typedef struct { int __val[2]; } __fsid_t;
typedef long int __clock_t;
typedef unsigned long int __rlim_t;
typedef unsigned long int __rlim64_t;
typedef unsigned int __id_t;
typedef long int __time_t;
typedef unsigned int __useconds_t;
typedef long int __suseconds_t;
typedef int __daddr_t;
typedef int __key_t;
typedef int __clockid_t;
typedef void * __timer_t;
typedef long int __blksize_t;
typedef long int __blkcnt_t;
typedef long int __blkcnt64_t;
typedef unsigned long int __fsblkcnt_t;
typedef unsigned long int __fsblkcnt64_t;
typedef unsigned long int __fsfilcnt_t;
typedef unsigned long int __fsfilcnt64_t;
typedef long int __fsword_t;
typedef long int __ssize_t;
typedef long int __syscall_slong_t;
typedef unsigned long int __syscall_ulong_t;
typedef __off64_t __loff_t;
typedef __quad_t *__qaddr_t;
typedef char *__caddr_t;
typedef long int __intptr_t;
typedef unsigned int __socklen_t;
#undef __STD_TYPE
typedef __ssize_t ssize_t;
#define __ssize_t_defined
#define __need_size_t
#define __need_NULL
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
typedef __gid_t gid_t;
#define __gid_t_defined
typedef __uid_t uid_t;
#define __uid_t_defined
typedef __off_t off_t;
#define __off_t_defined
typedef __off64_t off64_t;
#define __off64_t_defined
typedef __useconds_t useconds_t;
#define __useconds_t_defined
typedef __pid_t pid_t;
#define __pid_t_defined
typedef __intptr_t intptr_t;
#define __intptr_t_defined
typedef __socklen_t socklen_t;
#define __socklen_t_defined
#define R_OK 4
#define W_OK 2
#define X_OK 1
#define F_OK 0
extern int access (const char *__name, int __type) throw () __attribute__ ((__nonnull__ (1)));
extern int euidaccess (const char *__name, int __type)
throw () __attribute__ ((__nonnull__ (1)));
extern int eaccess (const char *__name, int __type)
throw () __attribute__ ((__nonnull__ (1)));
extern int faccessat (int __fd, const char *__file, int __type, int __flag)
throw () __attribute__ ((__nonnull__ (2))) ;
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2
#define SEEK_DATA 3
#define SEEK_HOLE 4
#define L_SET SEEK_SET
#define L_INCR SEEK_CUR
#define L_XTND SEEK_END
extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
throw ();
extern int close (int __fd);
extern ssize_t read (int __fd, void *__buf, size_t __nbytes) ;
extern ssize_t write (int __fd, const void *__buf, size_t __n) ;
extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
__off_t __offset) ;
extern ssize_t pwrite (int __fd, const void *__buf, size_t __n,
__off_t __offset) ;
extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
__off64_t __offset) ;
extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n,
__off64_t __offset) ;
extern int pipe (int __pipedes[2]) throw () ;
extern int pipe2 (int __pipedes[2], int __flags) throw () ;
extern unsigned int alarm (unsigned int __seconds) throw ();
extern unsigned int sleep (unsigned int __seconds);
extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
throw ();
extern int usleep (__useconds_t __useconds);
extern int pause (void);
extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int fchown (int __fd, __uid_t __owner, __gid_t __group) throw () ;
extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int fchownat (int __fd, const char *__file, __uid_t __owner,
__gid_t __group, int __flag)
throw () __attribute__ ((__nonnull__ (2))) ;
extern int chdir (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;
extern int fchdir (int __fd) throw () ;
extern char *getcwd (char *__buf, size_t __size) throw () ;
extern char *get_current_dir_name (void) throw ();
extern char *getwd (char *__buf)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) ;
extern int dup (int __fd) throw () ;
extern int dup2 (int __fd, int __fd2) throw ();
extern int dup3 (int __fd, int __fd2, int __flags) throw ();
extern char **__environ;
extern char **environ;
extern int execve (const char *__path, char *const __argv[],
char *const __envp[]) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
throw () __attribute__ ((__nonnull__ (2)));
extern int execv (const char *__path, char *const __argv[])
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execle (const char *__path, const char *__arg, ...)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execl (const char *__path, const char *__arg, ...)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execvp (const char *__file, char *const __argv[])
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execlp (const char *__file, const char *__arg, ...)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execvpe (const char *__file, char *const __argv[],
char *const __envp[])
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int nice (int __inc) throw () ;
extern void _exit (int __status) __attribute__ ((__noreturn__));
enum
{
_PC_LINK_MAX,
#define _PC_LINK_MAX _PC_LINK_MAX
_PC_MAX_CANON,
#define _PC_MAX_CANON _PC_MAX_CANON
_PC_MAX_INPUT,
#define _PC_MAX_INPUT _PC_MAX_INPUT
_PC_NAME_MAX,
#define _PC_NAME_MAX _PC_NAME_MAX
_PC_PATH_MAX,
#define _PC_PATH_MAX _PC_PATH_MAX
_PC_PIPE_BUF,
#define _PC_PIPE_BUF _PC_PIPE_BUF
_PC_CHOWN_RESTRICTED,
#define _PC_CHOWN_RESTRICTED _PC_CHOWN_RESTRICTED
_PC_NO_TRUNC,
#define _PC_NO_TRUNC _PC_NO_TRUNC
_PC_VDISABLE,
#define _PC_VDISABLE _PC_VDISABLE
_PC_SYNC_IO,
#define _PC_SYNC_IO _PC_SYNC_IO
_PC_ASYNC_IO,
#define _PC_ASYNC_IO _PC_ASYNC_IO
_PC_PRIO_IO,
#define _PC_PRIO_IO _PC_PRIO_IO
_PC_SOCK_MAXBUF,
#define _PC_SOCK_MAXBUF _PC_SOCK_MAXBUF
_PC_FILESIZEBITS,
#define _PC_FILESIZEBITS _PC_FILESIZEBITS
_PC_REC_INCR_XFER_SIZE,
#define _PC_REC_INCR_XFER_SIZE _PC_REC_INCR_XFER_SIZE
_PC_REC_MAX_XFER_SIZE,
#define _PC_REC_MAX_XFER_SIZE _PC_REC_MAX_XFER_SIZE
_PC_REC_MIN_XFER_SIZE,
#define _PC_REC_MIN_XFER_SIZE _PC_REC_MIN_XFER_SIZE
_PC_REC_XFER_ALIGN,
#define _PC_REC_XFER_ALIGN _PC_REC_XFER_ALIGN
_PC_ALLOC_SIZE_MIN,
#define _PC_ALLOC_SIZE_MIN _PC_ALLOC_SIZE_MIN
_PC_SYMLINK_MAX,
#define _PC_SYMLINK_MAX _PC_SYMLINK_MAX
_PC_2_SYMLINKS
#define _PC_2_SYMLINKS _PC_2_SYMLINKS
};
enum
{
_SC_ARG_MAX,
#define _SC_ARG_MAX _SC_ARG_MAX
_SC_CHILD_MAX,
#define _SC_CHILD_MAX _SC_CHILD_MAX
_SC_CLK_TCK,
#define _SC_CLK_TCK _SC_CLK_TCK
_SC_NGROUPS_MAX,
#define _SC_NGROUPS_MAX _SC_NGROUPS_MAX
_SC_OPEN_MAX,
#define _SC_OPEN_MAX _SC_OPEN_MAX
_SC_STREAM_MAX,
#define _SC_STREAM_MAX _SC_STREAM_MAX
_SC_TZNAME_MAX,
#define _SC_TZNAME_MAX _SC_TZNAME_MAX
_SC_JOB_CONTROL,
#define _SC_JOB_CONTROL _SC_JOB_CONTROL
_SC_SAVED_IDS,
#define _SC_SAVED_IDS _SC_SAVED_IDS
_SC_REALTIME_SIGNALS,
#define _SC_REALTIME_SIGNALS _SC_REALTIME_SIGNALS
_SC_PRIORITY_SCHEDULING,
#define _SC_PRIORITY_SCHEDULING _SC_PRIORITY_SCHEDULING
_SC_TIMERS,
#define _SC_TIMERS _SC_TIMERS
_SC_ASYNCHRONOUS_IO,
#define _SC_ASYNCHRONOUS_IO _SC_ASYNCHRONOUS_IO
_SC_PRIORITIZED_IO,
#define _SC_PRIORITIZED_IO _SC_PRIORITIZED_IO
_SC_SYNCHRONIZED_IO,
#define _SC_SYNCHRONIZED_IO _SC_SYNCHRONIZED_IO
_SC_FSYNC,
#define _SC_FSYNC _SC_FSYNC
_SC_MAPPED_FILES,
#define _SC_MAPPED_FILES _SC_MAPPED_FILES
_SC_MEMLOCK,
#define _SC_MEMLOCK _SC_MEMLOCK
_SC_MEMLOCK_RANGE,
#define _SC_MEMLOCK_RANGE _SC_MEMLOCK_RANGE
_SC_MEMORY_PROTECTION,
#define _SC_MEMORY_PROTECTION _SC_MEMORY_PROTECTION
_SC_MESSAGE_PASSING,
#define _SC_MESSAGE_PASSING _SC_MESSAGE_PASSING
_SC_SEMAPHORES,
#define _SC_SEMAPHORES _SC_SEMAPHORES
_SC_SHARED_MEMORY_OBJECTS,
#define _SC_SHARED_MEMORY_OBJECTS _SC_SHARED_MEMORY_OBJECTS
_SC_AIO_LISTIO_MAX,
#define _SC_AIO_LISTIO_MAX _SC_AIO_LISTIO_MAX
_SC_AIO_MAX,
#define _SC_AIO_MAX _SC_AIO_MAX
_SC_AIO_PRIO_DELTA_MAX,
#define _SC_AIO_PRIO_DELTA_MAX _SC_AIO_PRIO_DELTA_MAX
_SC_DELAYTIMER_MAX,
#define _SC_DELAYTIMER_MAX _SC_DELAYTIMER_MAX
_SC_MQ_OPEN_MAX,
#define _SC_MQ_OPEN_MAX _SC_MQ_OPEN_MAX
_SC_MQ_PRIO_MAX,
#define _SC_MQ_PRIO_MAX _SC_MQ_PRIO_MAX
_SC_VERSION,
#define _SC_VERSION _SC_VERSION
_SC_PAGESIZE,
#define _SC_PAGESIZE _SC_PAGESIZE
#define _SC_PAGE_SIZE _SC_PAGESIZE
_SC_RTSIG_MAX,
#define _SC_RTSIG_MAX _SC_RTSIG_MAX
_SC_SEM_NSEMS_MAX,
#define _SC_SEM_NSEMS_MAX _SC_SEM_NSEMS_MAX
_SC_SEM_VALUE_MAX,
#define _SC_SEM_VALUE_MAX _SC_SEM_VALUE_MAX
_SC_SIGQUEUE_MAX,
#define _SC_SIGQUEUE_MAX _SC_SIGQUEUE_MAX
_SC_TIMER_MAX,
#define _SC_TIMER_MAX _SC_TIMER_MAX
_SC_BC_BASE_MAX,
#define _SC_BC_BASE_MAX _SC_BC_BASE_MAX
_SC_BC_DIM_MAX,
#define _SC_BC_DIM_MAX _SC_BC_DIM_MAX
_SC_BC_SCALE_MAX,
#define _SC_BC_SCALE_MAX _SC_BC_SCALE_MAX
_SC_BC_STRING_MAX,
#define _SC_BC_STRING_MAX _SC_BC_STRING_MAX
_SC_COLL_WEIGHTS_MAX,
#define _SC_COLL_WEIGHTS_MAX _SC_COLL_WEIGHTS_MAX
_SC_EQUIV_CLASS_MAX,
#define _SC_EQUIV_CLASS_MAX _SC_EQUIV_CLASS_MAX
_SC_EXPR_NEST_MAX,
#define _SC_EXPR_NEST_MAX _SC_EXPR_NEST_MAX
_SC_LINE_MAX,
#define _SC_LINE_MAX _SC_LINE_MAX
_SC_RE_DUP_MAX,
#define _SC_RE_DUP_MAX _SC_RE_DUP_MAX
_SC_CHARCLASS_NAME_MAX,
#define _SC_CHARCLASS_NAME_MAX _SC_CHARCLASS_NAME_MAX
_SC_2_VERSION,
#define _SC_2_VERSION _SC_2_VERSION
_SC_2_C_BIND,
#define _SC_2_C_BIND _SC_2_C_BIND
_SC_2_C_DEV,
#define _SC_2_C_DEV _SC_2_C_DEV
_SC_2_FORT_DEV,
#define _SC_2_FORT_DEV _SC_2_FORT_DEV
_SC_2_FORT_RUN,
#define _SC_2_FORT_RUN _SC_2_FORT_RUN
_SC_2_SW_DEV,
#define _SC_2_SW_DEV _SC_2_SW_DEV
_SC_2_LOCALEDEF,
#define _SC_2_LOCALEDEF _SC_2_LOCALEDEF
_SC_PII,
#define _SC_PII _SC_PII
_SC_PII_XTI,
#define _SC_PII_XTI _SC_PII_XTI
_SC_PII_SOCKET,
#define _SC_PII_SOCKET _SC_PII_SOCKET
_SC_PII_INTERNET,
#define _SC_PII_INTERNET _SC_PII_INTERNET
_SC_PII_OSI,
#define _SC_PII_OSI _SC_PII_OSI
_SC_POLL,
#define _SC_POLL _SC_POLL
_SC_SELECT,
#define _SC_SELECT _SC_SELECT
_SC_UIO_MAXIOV,
#define _SC_UIO_MAXIOV _SC_UIO_MAXIOV
_SC_IOV_MAX = _SC_UIO_MAXIOV,
#define _SC_IOV_MAX _SC_IOV_MAX
_SC_PII_INTERNET_STREAM,
#define _SC_PII_INTERNET_STREAM _SC_PII_INTERNET_STREAM
_SC_PII_INTERNET_DGRAM,
#define _SC_PII_INTERNET_DGRAM _SC_PII_INTERNET_DGRAM
_SC_PII_OSI_COTS,
#define _SC_PII_OSI_COTS _SC_PII_OSI_COTS
_SC_PII_OSI_CLTS,
#define _SC_PII_OSI_CLTS _SC_PII_OSI_CLTS
_SC_PII_OSI_M,
#define _SC_PII_OSI_M _SC_PII_OSI_M
_SC_T_IOV_MAX,
#define _SC_T_IOV_MAX _SC_T_IOV_MAX
_SC_THREADS,
#define _SC_THREADS _SC_THREADS
_SC_THREAD_SAFE_FUNCTIONS,
#define _SC_THREAD_SAFE_FUNCTIONS _SC_THREAD_SAFE_FUNCTIONS
_SC_GETGR_R_SIZE_MAX,
#define _SC_GETGR_R_SIZE_MAX _SC_GETGR_R_SIZE_MAX
_SC_GETPW_R_SIZE_MAX,
#define _SC_GETPW_R_SIZE_MAX _SC_GETPW_R_SIZE_MAX
_SC_LOGIN_NAME_MAX,
#define _SC_LOGIN_NAME_MAX _SC_LOGIN_NAME_MAX
_SC_TTY_NAME_MAX,
#define _SC_TTY_NAME_MAX _SC_TTY_NAME_MAX
_SC_THREAD_DESTRUCTOR_ITERATIONS,
#define _SC_THREAD_DESTRUCTOR_ITERATIONS _SC_THREAD_DESTRUCTOR_ITERATIONS
_SC_THREAD_KEYS_MAX,
#define _SC_THREAD_KEYS_MAX _SC_THREAD_KEYS_MAX
_SC_THREAD_STACK_MIN,
#define _SC_THREAD_STACK_MIN _SC_THREAD_STACK_MIN
_SC_THREAD_THREADS_MAX,
#define _SC_THREAD_THREADS_MAX _SC_THREAD_THREADS_MAX
_SC_THREAD_ATTR_STACKADDR,
#define _SC_THREAD_ATTR_STACKADDR _SC_THREAD_ATTR_STACKADDR
_SC_THREAD_ATTR_STACKSIZE,
#define _SC_THREAD_ATTR_STACKSIZE _SC_THREAD_ATTR_STACKSIZE
_SC_THREAD_PRIORITY_SCHEDULING,
#define _SC_THREAD_PRIORITY_SCHEDULING _SC_THREAD_PRIORITY_SCHEDULING
_SC_THREAD_PRIO_INHERIT,
#define _SC_THREAD_PRIO_INHERIT _SC_THREAD_PRIO_INHERIT
_SC_THREAD_PRIO_PROTECT,
#define _SC_THREAD_PRIO_PROTECT _SC_THREAD_PRIO_PROTECT
_SC_THREAD_PROCESS_SHARED,
#define _SC_THREAD_PROCESS_SHARED _SC_THREAD_PROCESS_SHARED
_SC_NPROCESSORS_CONF,
#define _SC_NPROCESSORS_CONF _SC_NPROCESSORS_CONF
_SC_NPROCESSORS_ONLN,
#define _SC_NPROCESSORS_ONLN _SC_NPROCESSORS_ONLN
_SC_PHYS_PAGES,
#define _SC_PHYS_PAGES _SC_PHYS_PAGES
_SC_AVPHYS_PAGES,
#define _SC_AVPHYS_PAGES _SC_AVPHYS_PAGES
_SC_ATEXIT_MAX,
#define _SC_ATEXIT_MAX _SC_ATEXIT_MAX
_SC_PASS_MAX,
#define _SC_PASS_MAX _SC_PASS_MAX
_SC_XOPEN_VERSION,
#define _SC_XOPEN_VERSION _SC_XOPEN_VERSION
_SC_XOPEN_XCU_VERSION,
#define _SC_XOPEN_XCU_VERSION _SC_XOPEN_XCU_VERSION
_SC_XOPEN_UNIX,
#define _SC_XOPEN_UNIX _SC_XOPEN_UNIX
_SC_XOPEN_CRYPT,
#define _SC_XOPEN_CRYPT _SC_XOPEN_CRYPT
_SC_XOPEN_ENH_I18N,
#define _SC_XOPEN_ENH_I18N _SC_XOPEN_ENH_I18N
_SC_XOPEN_SHM,
#define _SC_XOPEN_SHM _SC_XOPEN_SHM
_SC_2_CHAR_TERM,
#define _SC_2_CHAR_TERM _SC_2_CHAR_TERM
_SC_2_C_VERSION,
#define _SC_2_C_VERSION _SC_2_C_VERSION
_SC_2_UPE,
#define _SC_2_UPE _SC_2_UPE
_SC_XOPEN_XPG2,
#define _SC_XOPEN_XPG2 _SC_XOPEN_XPG2
_SC_XOPEN_XPG3,
#define _SC_XOPEN_XPG3 _SC_XOPEN_XPG3
_SC_XOPEN_XPG4,
#define _SC_XOPEN_XPG4 _SC_XOPEN_XPG4
_SC_CHAR_BIT,
#define _SC_CHAR_BIT _SC_CHAR_BIT
_SC_CHAR_MAX,
#define _SC_CHAR_MAX _SC_CHAR_MAX
_SC_CHAR_MIN,
#define _SC_CHAR_MIN _SC_CHAR_MIN
_SC_INT_MAX,
#define _SC_INT_MAX _SC_INT_MAX
_SC_INT_MIN,
#define _SC_INT_MIN _SC_INT_MIN
_SC_LONG_BIT,
#define _SC_LONG_BIT _SC_LONG_BIT
_SC_WORD_BIT,
#define _SC_WORD_BIT _SC_WORD_BIT
_SC_MB_LEN_MAX,
#define _SC_MB_LEN_MAX _SC_MB_LEN_MAX
_SC_NZERO,
#define _SC_NZERO _SC_NZERO
_SC_SSIZE_MAX,
#define _SC_SSIZE_MAX _SC_SSIZE_MAX
_SC_SCHAR_MAX,
#define _SC_SCHAR_MAX _SC_SCHAR_MAX
_SC_SCHAR_MIN,
#define _SC_SCHAR_MIN _SC_SCHAR_MIN
_SC_SHRT_MAX,
#define _SC_SHRT_MAX _SC_SHRT_MAX
_SC_SHRT_MIN,
#define _SC_SHRT_MIN _SC_SHRT_MIN
_SC_UCHAR_MAX,
#define _SC_UCHAR_MAX _SC_UCHAR_MAX
_SC_UINT_MAX,
#define _SC_UINT_MAX _SC_UINT_MAX
_SC_ULONG_MAX,
#define _SC_ULONG_MAX _SC_ULONG_MAX
_SC_USHRT_MAX,
#define _SC_USHRT_MAX _SC_USHRT_MAX
_SC_NL_ARGMAX,
#define _SC_NL_ARGMAX _SC_NL_ARGMAX
_SC_NL_LANGMAX,
#define _SC_NL_LANGMAX _SC_NL_LANGMAX
_SC_NL_MSGMAX,
#define _SC_NL_MSGMAX _SC_NL_MSGMAX
_SC_NL_NMAX,
#define _SC_NL_NMAX _SC_NL_NMAX
_SC_NL_SETMAX,
#define _SC_NL_SETMAX _SC_NL_SETMAX
_SC_NL_TEXTMAX,
#define _SC_NL_TEXTMAX _SC_NL_TEXTMAX
_SC_XBS5_ILP32_OFF32,
#define _SC_XBS5_ILP32_OFF32 _SC_XBS5_ILP32_OFF32
_SC_XBS5_ILP32_OFFBIG,
#define _SC_XBS5_ILP32_OFFBIG _SC_XBS5_ILP32_OFFBIG
_SC_XBS5_LP64_OFF64,
#define _SC_XBS5_LP64_OFF64 _SC_XBS5_LP64_OFF64
_SC_XBS5_LPBIG_OFFBIG,
#define _SC_XBS5_LPBIG_OFFBIG _SC_XBS5_LPBIG_OFFBIG
_SC_XOPEN_LEGACY,
#define _SC_XOPEN_LEGACY _SC_XOPEN_LEGACY
_SC_XOPEN_REALTIME,
#define _SC_XOPEN_REALTIME _SC_XOPEN_REALTIME
_SC_XOPEN_REALTIME_THREADS,
#define _SC_XOPEN_REALTIME_THREADS _SC_XOPEN_REALTIME_THREADS
_SC_ADVISORY_INFO,
#define _SC_ADVISORY_INFO _SC_ADVISORY_INFO
_SC_BARRIERS,
#define _SC_BARRIERS _SC_BARRIERS
_SC_BASE,
#define _SC_BASE _SC_BASE
_SC_C_LANG_SUPPORT,
#define _SC_C_LANG_SUPPORT _SC_C_LANG_SUPPORT
_SC_C_LANG_SUPPORT_R,
#define _SC_C_LANG_SUPPORT_R _SC_C_LANG_SUPPORT_R
_SC_CLOCK_SELECTION,
#define _SC_CLOCK_SELECTION _SC_CLOCK_SELECTION
_SC_CPUTIME,
#define _SC_CPUTIME _SC_CPUTIME
_SC_THREAD_CPUTIME,
#define _SC_THREAD_CPUTIME _SC_THREAD_CPUTIME
_SC_DEVICE_IO,
#define _SC_DEVICE_IO _SC_DEVICE_IO
_SC_DEVICE_SPECIFIC,
#define _SC_DEVICE_SPECIFIC _SC_DEVICE_SPECIFIC
_SC_DEVICE_SPECIFIC_R,
#define _SC_DEVICE_SPECIFIC_R _SC_DEVICE_SPECIFIC_R
_SC_FD_MGMT,
#define _SC_FD_MGMT _SC_FD_MGMT
_SC_FIFO,
#define _SC_FIFO _SC_FIFO
_SC_PIPE,
#define _SC_PIPE _SC_PIPE
_SC_FILE_ATTRIBUTES,
#define _SC_FILE_ATTRIBUTES _SC_FILE_ATTRIBUTES
_SC_FILE_LOCKING,
#define _SC_FILE_LOCKING _SC_FILE_LOCKING
_SC_FILE_SYSTEM,
#define _SC_FILE_SYSTEM _SC_FILE_SYSTEM
_SC_MONOTONIC_CLOCK,
#define _SC_MONOTONIC_CLOCK _SC_MONOTONIC_CLOCK
_SC_MULTI_PROCESS,
#define _SC_MULTI_PROCESS _SC_MULTI_PROCESS
_SC_SINGLE_PROCESS,
#define _SC_SINGLE_PROCESS _SC_SINGLE_PROCESS
_SC_NETWORKING,
#define _SC_NETWORKING _SC_NETWORKING
_SC_READER_WRITER_LOCKS,
#define _SC_READER_WRITER_LOCKS _SC_READER_WRITER_LOCKS
_SC_SPIN_LOCKS,
#define _SC_SPIN_LOCKS _SC_SPIN_LOCKS
_SC_REGEXP,
#define _SC_REGEXP _SC_REGEXP
_SC_REGEX_VERSION,
#define _SC_REGEX_VERSION _SC_REGEX_VERSION
_SC_SHELL,
#define _SC_SHELL _SC_SHELL
_SC_SIGNALS,
#define _SC_SIGNALS _SC_SIGNALS
_SC_SPAWN,
#define _SC_SPAWN _SC_SPAWN
_SC_SPORADIC_SERVER,
#define _SC_SPORADIC_SERVER _SC_SPORADIC_SERVER
_SC_THREAD_SPORADIC_SERVER,
#define _SC_THREAD_SPORADIC_SERVER _SC_THREAD_SPORADIC_SERVER
_SC_SYSTEM_DATABASE,
#define _SC_SYSTEM_DATABASE _SC_SYSTEM_DATABASE
_SC_SYSTEM_DATABASE_R,
#define _SC_SYSTEM_DATABASE_R _SC_SYSTEM_DATABASE_R
_SC_TIMEOUTS,
#define _SC_TIMEOUTS _SC_TIMEOUTS
_SC_TYPED_MEMORY_OBJECTS,
#define _SC_TYPED_MEMORY_OBJECTS _SC_TYPED_MEMORY_OBJECTS
_SC_USER_GROUPS,
#define _SC_USER_GROUPS _SC_USER_GROUPS
_SC_USER_GROUPS_R,
#define _SC_USER_GROUPS_R _SC_USER_GROUPS_R
_SC_2_PBS,
#define _SC_2_PBS _SC_2_PBS
_SC_2_PBS_ACCOUNTING,
#define _SC_2_PBS_ACCOUNTING _SC_2_PBS_ACCOUNTING
_SC_2_PBS_LOCATE,
#define _SC_2_PBS_LOCATE _SC_2_PBS_LOCATE
_SC_2_PBS_MESSAGE,
#define _SC_2_PBS_MESSAGE _SC_2_PBS_MESSAGE
_SC_2_PBS_TRACK,
#define _SC_2_PBS_TRACK _SC_2_PBS_TRACK
_SC_SYMLOOP_MAX,
#define _SC_SYMLOOP_MAX _SC_SYMLOOP_MAX
_SC_STREAMS,
#define _SC_STREAMS _SC_STREAMS
_SC_2_PBS_CHECKPOINT,
#define _SC_2_PBS_CHECKPOINT _SC_2_PBS_CHECKPOINT
_SC_V6_ILP32_OFF32,
#define _SC_V6_ILP32_OFF32 _SC_V6_ILP32_OFF32
_SC_V6_ILP32_OFFBIG,
#define _SC_V6_ILP32_OFFBIG _SC_V6_ILP32_OFFBIG
_SC_V6_LP64_OFF64,
#define _SC_V6_LP64_OFF64 _SC_V6_LP64_OFF64
_SC_V6_LPBIG_OFFBIG,
#define _SC_V6_LPBIG_OFFBIG _SC_V6_LPBIG_OFFBIG
_SC_HOST_NAME_MAX,
#define _SC_HOST_NAME_MAX _SC_HOST_NAME_MAX
_SC_TRACE,
#define _SC_TRACE _SC_TRACE
_SC_TRACE_EVENT_FILTER,
#define _SC_TRACE_EVENT_FILTER _SC_TRACE_EVENT_FILTER
_SC_TRACE_INHERIT,
#define _SC_TRACE_INHERIT _SC_TRACE_INHERIT
_SC_TRACE_LOG,
#define _SC_TRACE_LOG _SC_TRACE_LOG
_SC_LEVEL1_ICACHE_SIZE,
#define _SC_LEVEL1_ICACHE_SIZE _SC_LEVEL1_ICACHE_SIZE
_SC_LEVEL1_ICACHE_ASSOC,
#define _SC_LEVEL1_ICACHE_ASSOC _SC_LEVEL1_ICACHE_ASSOC
_SC_LEVEL1_ICACHE_LINESIZE,
#define _SC_LEVEL1_ICACHE_LINESIZE _SC_LEVEL1_ICACHE_LINESIZE
_SC_LEVEL1_DCACHE_SIZE,
#define _SC_LEVEL1_DCACHE_SIZE _SC_LEVEL1_DCACHE_SIZE
_SC_LEVEL1_DCACHE_ASSOC,
#define _SC_LEVEL1_DCACHE_ASSOC _SC_LEVEL1_DCACHE_ASSOC
_SC_LEVEL1_DCACHE_LINESIZE,
#define _SC_LEVEL1_DCACHE_LINESIZE _SC_LEVEL1_DCACHE_LINESIZE
_SC_LEVEL2_CACHE_SIZE,
#define _SC_LEVEL2_CACHE_SIZE _SC_LEVEL2_CACHE_SIZE
_SC_LEVEL2_CACHE_ASSOC,
#define _SC_LEVEL2_CACHE_ASSOC _SC_LEVEL2_CACHE_ASSOC
_SC_LEVEL2_CACHE_LINESIZE,
#define _SC_LEVEL2_CACHE_LINESIZE _SC_LEVEL2_CACHE_LINESIZE
_SC_LEVEL3_CACHE_SIZE,
#define _SC_LEVEL3_CACHE_SIZE _SC_LEVEL3_CACHE_SIZE
_SC_LEVEL3_CACHE_ASSOC,
#define _SC_LEVEL3_CACHE_ASSOC _SC_LEVEL3_CACHE_ASSOC
_SC_LEVEL3_CACHE_LINESIZE,
#define _SC_LEVEL3_CACHE_LINESIZE _SC_LEVEL3_CACHE_LINESIZE
_SC_LEVEL4_CACHE_SIZE,
#define _SC_LEVEL4_CACHE_SIZE _SC_LEVEL4_CACHE_SIZE
_SC_LEVEL4_CACHE_ASSOC,
#define _SC_LEVEL4_CACHE_ASSOC _SC_LEVEL4_CACHE_ASSOC
_SC_LEVEL4_CACHE_LINESIZE,
#define _SC_LEVEL4_CACHE_LINESIZE _SC_LEVEL4_CACHE_LINESIZE
_SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
#define _SC_IPV6 _SC_IPV6
_SC_RAW_SOCKETS,
#define _SC_RAW_SOCKETS _SC_RAW_SOCKETS
_SC_V7_ILP32_OFF32,
#define _SC_V7_ILP32_OFF32 _SC_V7_ILP32_OFF32
_SC_V7_ILP32_OFFBIG,
#define _SC_V7_ILP32_OFFBIG _SC_V7_ILP32_OFFBIG
_SC_V7_LP64_OFF64,
#define _SC_V7_LP64_OFF64 _SC_V7_LP64_OFF64
_SC_V7_LPBIG_OFFBIG,
#define _SC_V7_LPBIG_OFFBIG _SC_V7_LPBIG_OFFBIG
_SC_SS_REPL_MAX,
#define _SC_SS_REPL_MAX _SC_SS_REPL_MAX
_SC_TRACE_EVENT_NAME_MAX,
#define _SC_TRACE_EVENT_NAME_MAX _SC_TRACE_EVENT_NAME_MAX
_SC_TRACE_NAME_MAX,
#define _SC_TRACE_NAME_MAX _SC_TRACE_NAME_MAX
_SC_TRACE_SYS_MAX,
#define _SC_TRACE_SYS_MAX _SC_TRACE_SYS_MAX
_SC_TRACE_USER_EVENT_MAX,
#define _SC_TRACE_USER_EVENT_MAX _SC_TRACE_USER_EVENT_MAX
_SC_XOPEN_STREAMS,
#define _SC_XOPEN_STREAMS _SC_XOPEN_STREAMS
_SC_THREAD_ROBUST_PRIO_INHERIT,
#define _SC_THREAD_ROBUST_PRIO_INHERIT _SC_THREAD_ROBUST_PRIO_INHERIT
_SC_THREAD_ROBUST_PRIO_PROTECT
#define _SC_THREAD_ROBUST_PRIO_PROTECT _SC_THREAD_ROBUST_PRIO_PROTECT
};
enum
{
_CS_PATH,
#define _CS_PATH _CS_PATH
_CS_V6_WIDTH_RESTRICTED_ENVS,
#define _CS_V6_WIDTH_RESTRICTED_ENVS _CS_V6_WIDTH_RESTRICTED_ENVS
#define _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS _CS_V6_WIDTH_RESTRICTED_ENVS
_CS_GNU_LIBC_VERSION,
#define _CS_GNU_LIBC_VERSION _CS_GNU_LIBC_VERSION
_CS_GNU_LIBPTHREAD_VERSION,
#define _CS_GNU_LIBPTHREAD_VERSION _CS_GNU_LIBPTHREAD_VERSION
_CS_V5_WIDTH_RESTRICTED_ENVS,
#define _CS_V5_WIDTH_RESTRICTED_ENVS _CS_V5_WIDTH_RESTRICTED_ENVS
#define _CS_POSIX_V5_WIDTH_RESTRICTED_ENVS _CS_V5_WIDTH_RESTRICTED_ENVS
_CS_V7_WIDTH_RESTRICTED_ENVS,
#define _CS_V7_WIDTH_RESTRICTED_ENVS _CS_V7_WIDTH_RESTRICTED_ENVS
#define _CS_POSIX_V7_WIDTH_RESTRICTED_ENVS _CS_V7_WIDTH_RESTRICTED_ENVS
_CS_LFS_CFLAGS = 1000,
#define _CS_LFS_CFLAGS _CS_LFS_CFLAGS
_CS_LFS_LDFLAGS,
#define _CS_LFS_LDFLAGS _CS_LFS_LDFLAGS
_CS_LFS_LIBS,
#define _CS_LFS_LIBS _CS_LFS_LIBS
_CS_LFS_LINTFLAGS,
#define _CS_LFS_LINTFLAGS _CS_LFS_LINTFLAGS
_CS_LFS64_CFLAGS,
#define _CS_LFS64_CFLAGS _CS_LFS64_CFLAGS
_CS_LFS64_LDFLAGS,
#define _CS_LFS64_LDFLAGS _CS_LFS64_LDFLAGS
_CS_LFS64_LIBS,
#define _CS_LFS64_LIBS _CS_LFS64_LIBS
_CS_LFS64_LINTFLAGS,
#define _CS_LFS64_LINTFLAGS _CS_LFS64_LINTFLAGS
_CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
#define _CS_XBS5_ILP32_OFF32_CFLAGS _CS_XBS5_ILP32_OFF32_CFLAGS
_CS_XBS5_ILP32_OFF32_LDFLAGS,
#define _CS_XBS5_ILP32_OFF32_LDFLAGS _CS_XBS5_ILP32_OFF32_LDFLAGS
_CS_XBS5_ILP32_OFF32_LIBS,
#define _CS_XBS5_ILP32_OFF32_LIBS _CS_XBS5_ILP32_OFF32_LIBS
_CS_XBS5_ILP32_OFF32_LINTFLAGS,
#define _CS_XBS5_ILP32_OFF32_LINTFLAGS _CS_XBS5_ILP32_OFF32_LINTFLAGS
_CS_XBS5_ILP32_OFFBIG_CFLAGS,
#define _CS_XBS5_ILP32_OFFBIG_CFLAGS _CS_XBS5_ILP32_OFFBIG_CFLAGS
_CS_XBS5_ILP32_OFFBIG_LDFLAGS,
#define _CS_XBS5_ILP32_OFFBIG_LDFLAGS _CS_XBS5_ILP32_OFFBIG_LDFLAGS
_CS_XBS5_ILP32_OFFBIG_LIBS,
#define _CS_XBS5_ILP32_OFFBIG_LIBS _CS_XBS5_ILP32_OFFBIG_LIBS
_CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
#define _CS_XBS5_ILP32_OFFBIG_LINTFLAGS _CS_XBS5_ILP32_OFFBIG_LINTFLAGS
_CS_XBS5_LP64_OFF64_CFLAGS,
#define _CS_XBS5_LP64_OFF64_CFLAGS _CS_XBS5_LP64_OFF64_CFLAGS
_CS_XBS5_LP64_OFF64_LDFLAGS,
#define _CS_XBS5_LP64_OFF64_LDFLAGS _CS_XBS5_LP64_OFF64_LDFLAGS
_CS_XBS5_LP64_OFF64_LIBS,
#define _CS_XBS5_LP64_OFF64_LIBS _CS_XBS5_LP64_OFF64_LIBS
_CS_XBS5_LP64_OFF64_LINTFLAGS,
#define _CS_XBS5_LP64_OFF64_LINTFLAGS _CS_XBS5_LP64_OFF64_LINTFLAGS
_CS_XBS5_LPBIG_OFFBIG_CFLAGS,
#define _CS_XBS5_LPBIG_OFFBIG_CFLAGS _CS_XBS5_LPBIG_OFFBIG_CFLAGS
_CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
#define _CS_XBS5_LPBIG_OFFBIG_LDFLAGS _CS_XBS5_LPBIG_OFFBIG_LDFLAGS
_CS_XBS5_LPBIG_OFFBIG_LIBS,
#define _CS_XBS5_LPBIG_OFFBIG_LIBS _CS_XBS5_LPBIG_OFFBIG_LIBS
_CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
#define _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
_CS_POSIX_V6_ILP32_OFF32_CFLAGS,
#define _CS_POSIX_V6_ILP32_OFF32_CFLAGS _CS_POSIX_V6_ILP32_OFF32_CFLAGS
_CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
#define _CS_POSIX_V6_ILP32_OFF32_LDFLAGS _CS_POSIX_V6_ILP32_OFF32_LDFLAGS
_CS_POSIX_V6_ILP32_OFF32_LIBS,
#define _CS_POSIX_V6_ILP32_OFF32_LIBS _CS_POSIX_V6_ILP32_OFF32_LIBS
_CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
#define _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS
_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
#define _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS
_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
#define _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS
_CS_POSIX_V6_ILP32_OFFBIG_LIBS,
#define _CS_POSIX_V6_ILP32_OFFBIG_LIBS _CS_POSIX_V6_ILP32_OFFBIG_LIBS
_CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
#define _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS
_CS_POSIX_V6_LP64_OFF64_CFLAGS,
#define _CS_POSIX_V6_LP64_OFF64_CFLAGS _CS_POSIX_V6_LP64_OFF64_CFLAGS
_CS_POSIX_V6_LP64_OFF64_LDFLAGS,
#define _CS_POSIX_V6_LP64_OFF64_LDFLAGS _CS_POSIX_V6_LP64_OFF64_LDFLAGS
_CS_POSIX_V6_LP64_OFF64_LIBS,
#define _CS_POSIX_V6_LP64_OFF64_LIBS _CS_POSIX_V6_LP64_OFF64_LIBS
_CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
#define _CS_POSIX_V6_LP64_OFF64_LINTFLAGS _CS_POSIX_V6_LP64_OFF64_LINTFLAGS
_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
#define _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS
_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
#define _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS
_CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
#define _CS_POSIX_V6_LPBIG_OFFBIG_LIBS _CS_POSIX_V6_LPBIG_OFFBIG_LIBS
_CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,
#define _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS
_CS_POSIX_V7_ILP32_OFF32_CFLAGS,
#define _CS_POSIX_V7_ILP32_OFF32_CFLAGS _CS_POSIX_V7_ILP32_OFF32_CFLAGS
_CS_POSIX_V7_ILP32_OFF32_LDFLAGS,
#define _CS_POSIX_V7_ILP32_OFF32_LDFLAGS _CS_POSIX_V7_ILP32_OFF32_LDFLAGS
_CS_POSIX_V7_ILP32_OFF32_LIBS,
#define _CS_POSIX_V7_ILP32_OFF32_LIBS _CS_POSIX_V7_ILP32_OFF32_LIBS
_CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,
#define _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS
_CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,
#define _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS
_CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,
#define _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS
_CS_POSIX_V7_ILP32_OFFBIG_LIBS,
#define _CS_POSIX_V7_ILP32_OFFBIG_LIBS _CS_POSIX_V7_ILP32_OFFBIG_LIBS
_CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,
#define _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS
_CS_POSIX_V7_LP64_OFF64_CFLAGS,
#define _CS_POSIX_V7_LP64_OFF64_CFLAGS _CS_POSIX_V7_LP64_OFF64_CFLAGS
_CS_POSIX_V7_LP64_OFF64_LDFLAGS,
#define _CS_POSIX_V7_LP64_OFF64_LDFLAGS _CS_POSIX_V7_LP64_OFF64_LDFLAGS
_CS_POSIX_V7_LP64_OFF64_LIBS,
#define _CS_POSIX_V7_LP64_OFF64_LIBS _CS_POSIX_V7_LP64_OFF64_LIBS
_CS_POSIX_V7_LP64_OFF64_LINTFLAGS,
#define _CS_POSIX_V7_LP64_OFF64_LINTFLAGS _CS_POSIX_V7_LP64_OFF64_LINTFLAGS
_CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,
#define _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS
_CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,
#define _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS
_CS_POSIX_V7_LPBIG_OFFBIG_LIBS,
#define _CS_POSIX_V7_LPBIG_OFFBIG_LIBS _CS_POSIX_V7_LPBIG_OFFBIG_LIBS
_CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS,
#define _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS
_CS_V6_ENV,
#define _CS_V6_ENV _CS_V6_ENV
_CS_V7_ENV
#define _CS_V7_ENV _CS_V7_ENV
};
extern long int pathconf (const char *__path, int __name)
throw () __attribute__ ((__nonnull__ (1)));
extern long int fpathconf (int __fd, int __name) throw ();
extern long int sysconf (int __name) throw ();
extern size_t confstr (int __name, char *__buf, size_t __len) throw ();
extern __pid_t getpid (void) throw ();
extern __pid_t getppid (void) throw ();
extern __pid_t getpgrp (void) throw ();
extern __pid_t __getpgid (__pid_t __pid) throw ();
extern __pid_t getpgid (__pid_t __pid) throw ();
extern int setpgid (__pid_t __pid, __pid_t __pgid) throw ();
extern int setpgrp (void) throw ();
extern __pid_t setsid (void) throw ();
extern __pid_t getsid (__pid_t __pid) throw ();
extern __uid_t getuid (void) throw ();
extern __uid_t geteuid (void) throw ();
extern __gid_t getgid (void) throw ();
extern __gid_t getegid (void) throw ();
extern int getgroups (int __size, __gid_t __list[]) throw () ;
extern int group_member (__gid_t __gid) throw ();
extern int setuid (__uid_t __uid) throw () ;
extern int setreuid (__uid_t __ruid, __uid_t __euid) throw () ;
extern int seteuid (__uid_t __uid) throw () ;
extern int setgid (__gid_t __gid) throw () ;
extern int setregid (__gid_t __rgid, __gid_t __egid) throw () ;
extern int setegid (__gid_t __gid) throw () ;
extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
throw ();
extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
throw ();
extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
throw () ;
extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
throw () ;
extern __pid_t fork (void) throw ();
extern __pid_t vfork (void) throw ();
extern char *ttyname (int __fd) throw ();
extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2))) ;
extern int isatty (int __fd) throw ();
extern int ttyslot (void) throw ();
extern int link (const char *__from, const char *__to)
throw () __attribute__ ((__nonnull__ (1, 2))) ;
extern int linkat (int __fromfd, const char *__from, int __tofd,
const char *__to, int __flags)
throw () __attribute__ ((__nonnull__ (2, 4))) ;
extern int symlink (const char *__from, const char *__to)
throw () __attribute__ ((__nonnull__ (1, 2))) ;
extern ssize_t readlink (const char *__restrict __path,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (1, 2))) ;
extern int symlinkat (const char *__from, int __tofd,
const char *__to) throw () __attribute__ ((__nonnull__ (1, 3))) ;
extern ssize_t readlinkat (int __fd, const char *__restrict __path,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (2, 3))) ;
extern int unlink (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
extern int unlinkat (int __fd, const char *__name, int __flag)
throw () __attribute__ ((__nonnull__ (2)));
extern int rmdir (const char *__path) throw () __attribute__ ((__nonnull__ (1)));
extern __pid_t tcgetpgrp (int __fd) throw ();
extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) throw ();
extern char *getlogin (void);
extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)));
extern int setlogin (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
#define __need_getopt
extern "C" {
extern char *optarg;
extern int optind;
extern int opterr;
extern int optopt;
extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
throw ();
}
#undef __need_getopt
extern int gethostname (char *__name, size_t __len) throw () __attribute__ ((__nonnull__ (1)));
extern int sethostname (const char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int sethostid (long int __id) throw () ;
extern int getdomainname (char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int setdomainname (const char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int vhangup (void) throw ();
extern int revoke (const char *__file) throw () __attribute__ ((__nonnull__ (1))) ;
extern int profil (unsigned short int *__sample_buffer, size_t __size,
size_t __offset, unsigned int __scale)
throw () __attribute__ ((__nonnull__ (1)));
extern int acct (const char *__name) throw ();
extern char *getusershell (void) throw ();
extern void endusershell (void) throw ();
extern void setusershell (void) throw ();
extern int daemon (int __nochdir, int __noclose) throw () ;
extern int chroot (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;
extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1)));
extern int fsync (int __fd);
extern int syncfs (int __fd) throw ();
extern long int gethostid (void);
extern void sync (void) throw ();
extern int getpagesize (void) throw () __attribute__ ((__const__));
extern int getdtablesize (void) throw ();
extern int truncate (const char *__file, __off_t __length)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int truncate64 (const char *__file, __off64_t __length)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int ftruncate (int __fd, __off_t __length) throw () ;
extern int ftruncate64 (int __fd, __off64_t __length) throw () ;
extern int brk (void *__addr) throw () ;
extern void *sbrk (intptr_t __delta) throw ();
extern long int syscall (long int __sysno, ...) throw ();
#define F_ULOCK 0
#define F_LOCK 1
#define F_TLOCK 2
#define F_TEST 3
extern int lockf (int __fd, int __cmd, __off_t __len) ;
extern int lockf64 (int __fd, int __cmd, __off64_t __len) ;
#define TEMP_FAILURE_RETRY(expression) (__extension__ ({ long int __result; do __result = (long int) (expression); while (__result == -1L && errno == EINTR); __result; }))
extern int fdatasync (int __fildes);
extern char *crypt (const char *__key, const char *__salt)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void encrypt (char *__glibc_block, int __edflag)
throw () __attribute__ ((__nonnull__ (1)));
extern void swab (const void *__restrict __from, void *__restrict __to,
ssize_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
}
#define BOOST_STD_EXTENSION_NAMESPACE __gnu_cxx
#define BOOST_HAS_SLIST
#define BOOST_HAS_HASH
#define BOOST_SLIST_HEADER <ext/slist>
#define BOOST_HASH_SET_HEADER <backward/hash_set>
#define BOOST_HASH_MAP_HEADER <backward/hash_map>
#define BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG
#define BOOST_HAS_TR1_COMPLEX_OVERLOADS
#define BOOST_NO_CXX11_HDR_THREAD
#define BOOST_NO_CXX11_HDR_TYPE_TRAITS
#define BOOST_NO_CXX11_HDR_CODECVT
#define BOOST_NO_CXX11_ATOMIC_SMART_PTR
#define BOOST_PLATFORM_CONFIG "boost/config/platform/linux.hpp"
#define BOOST_PLATFORM "linux"
#define _GLIBCXX_CSTDLIB 1
#define __need_size_t
#define __need_wchar_t
#define __need_NULL
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
extern "C" {
#define _STDLIB_H 1
#define WNOHANG 1
#define WUNTRACED 2
#define WSTOPPED 2
#define WEXITED 4
#define WCONTINUED 8
#define WNOWAIT 0x01000000
#define __WNOTHREAD 0x20000000
#define __WALL 0x40000000
#define __WCLONE 0x80000000
#define __ENUM_IDTYPE_T 1
#undef P_ALL
#undef P_PID
#undef P_PGID
typedef enum
{
P_ALL,
P_PID,
P_PGID
} idtype_t;
#define __WEXITSTATUS(status) (((status) & 0xff00) >> 8)
#define __WTERMSIG(status) ((status) & 0x7f)
#define __WSTOPSIG(status) __WEXITSTATUS(status)
#define __WIFEXITED(status) (__WTERMSIG(status) == 0)
#define __WIFSIGNALED(status) (((signed char) (((status) & 0x7f) + 1) >> 1) > 0)
#define __WIFSTOPPED(status) (((status) & 0xff) == 0x7f)
#define __WIFCONTINUED(status) ((status) == __W_CONTINUED)
#define __WCOREDUMP(status) ((status) & __WCOREFLAG)
#define __W_EXITCODE(ret,sig) ((ret) << 8 | (sig))
#define __W_STOPCODE(sig) ((sig) << 8 | 0x7f)
#define __W_CONTINUED 0xffff
#define __WCOREFLAG 0x80
#define _ENDIAN_H 1
#define __LITTLE_ENDIAN 1234
#define __BIG_ENDIAN 4321
#define __PDP_ENDIAN 3412
#define __BYTE_ORDER __LITTLE_ENDIAN
#define __FLOAT_WORD_ORDER __BYTE_ORDER
#define LITTLE_ENDIAN __LITTLE_ENDIAN
#define BIG_ENDIAN __BIG_ENDIAN
#define PDP_ENDIAN __PDP_ENDIAN
#define BYTE_ORDER __BYTE_ORDER
#define __LONG_LONG_PAIR(HI,LO) LO, HI
#define _BITS_BYTESWAP_H 1
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
#define __bswap_constant_16(x) ((unsigned short int) ((((x) >> 8) & 0xff) | (((x) & 0xff) << 8)))
#define __bswap_16(x) (__extension__ ({ unsigned short int __v, __x = (unsigned short int) (x); if (__builtin_constant_p (__x)) __v = __bswap_constant_16 (__x); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; }))
#define __bswap_constant_32(x) ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | (((x) & 0x0000ff00) << 8) | (((x) & 0x000000ff) << 24))
static unsigned int
__bswap_32 (unsigned int __bsx)
;
#define __bswap_constant_64(x) (__extension__ ((((x) & 0xff00000000000000ull) >> 56) | (((x) & 0x00ff000000000000ull) >> 40) | (((x) & 0x0000ff0000000000ull) >> 24) | (((x) & 0x000000ff00000000ull) >> 8) | (((x) & 0x00000000ff000000ull) << 8) | (((x) & 0x0000000000ff0000ull) << 24) | (((x) & 0x000000000000ff00ull) << 40) | (((x) & 0x00000000000000ffull) << 56)))
static __uint64_t
__bswap_64 (__uint64_t __bsx)
;
#define htobe16(x) __bswap_16 (x)
#define htole16(x) (x)
#define be16toh(x) __bswap_16 (x)
#define le16toh(x) (x)
#define htobe32(x) __bswap_32 (x)
#define htole32(x) (x)
#define be32toh(x) __bswap_32 (x)
#define le32toh(x) (x)
#define htobe64(x) __bswap_64 (x)
#define htole64(x) (x)
#define be64toh(x) __bswap_64 (x)
#define le64toh(x) (x)
union wait
{
int w_status;
struct
{
unsigned int __w_termsig:7;
unsigned int __w_coredump:1;
unsigned int __w_retcode:8;
unsigned int:16;
} __wait_terminated;
struct
{
unsigned int __w_stopval:8;
unsigned int __w_stopsig:8;
unsigned int:16;
} __wait_stopped;
};
#define w_termsig __wait_terminated.__w_termsig
#define w_coredump __wait_terminated.__w_coredump
#define w_retcode __wait_terminated.__w_retcode
#define w_stopsig __wait_stopped.__w_stopsig
#define w_stopval __wait_stopped.__w_stopval
#define __WAIT_INT(status) (*(int *) &(status))
#define __WAIT_STATUS void *
#define __WAIT_STATUS_DEFN void *
#define WEXITSTATUS(status) __WEXITSTATUS (__WAIT_INT (status))
#define WTERMSIG(status) __WTERMSIG (__WAIT_INT (status))
#define WSTOPSIG(status) __WSTOPSIG (__WAIT_INT (status))
#define WIFEXITED(status) __WIFEXITED (__WAIT_INT (status))
#define WIFSIGNALED(status) __WIFSIGNALED (__WAIT_INT (status))
#define WIFSTOPPED(status) __WIFSTOPPED (__WAIT_INT (status))
#define WIFCONTINUED(status) __WIFCONTINUED (__WAIT_INT (status))
typedef struct
{
int quot;
int rem;
} div_t;
typedef struct
{
long int quot;
long int rem;
} ldiv_t;
#define __ldiv_t_defined 1
__extension__ typedef struct
{
long long int quot;
long long int rem;
} lldiv_t;
#define __lldiv_t_defined 1
#define RAND_MAX 2147483647
#define EXIT_FAILURE 1
#define EXIT_SUCCESS 0
#define MB_CUR_MAX (__ctype_get_mb_cur_max ())
extern size_t __ctype_get_mb_cur_max (void) throw () ;
extern double atof (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern int atoi (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern long int atol (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
__extension__ extern long long int atoll (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern double strtod (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
extern float strtof (const char *__restrict __nptr,
char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1)));
extern long double strtold (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
extern long int strtol (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
extern unsigned long int strtoul (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern long long int strtoq (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern unsigned long long int strtouq (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern long long int strtoll (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern unsigned long long int strtoull (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
#define _XLOCALE_H 1
typedef struct __locale_struct
{
struct __locale_data *__locales[13];
const unsigned short int *__ctype_b;
const int *__ctype_tolower;
const int *__ctype_toupper;
const char *__names[13];
} *__locale_t;
typedef __locale_t locale_t;
extern long int strtol_l (const char *__restrict __nptr,
char **__restrict __endptr, int __base,
__locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4)));
extern unsigned long int strtoul_l (const char *__restrict __nptr,
char **__restrict __endptr,
int __base, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4)));
__extension__
extern long long int strtoll_l (const char *__restrict __nptr,
char **__restrict __endptr, int __base,
__locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4)));
__extension__
extern unsigned long long int strtoull_l (const char *__restrict __nptr,
char **__restrict __endptr,
int __base, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4)));
extern double strtod_l (const char *__restrict __nptr,
char **__restrict __endptr, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern float strtof_l (const char *__restrict __nptr,
char **__restrict __endptr, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern long double strtold_l (const char *__restrict __nptr,
char **__restrict __endptr,
__locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern char *l64a (long int __n) throw () ;
extern long int a64l (const char *__s)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
#define _SYS_TYPES_H 1
extern "C" {
typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;
#define __u_char_defined
typedef __loff_t loff_t;
typedef __ino_t ino_t;
#define __ino_t_defined
typedef __ino64_t ino64_t;
#define __ino64_t_defined
typedef __dev_t dev_t;
#define __dev_t_defined
typedef __mode_t mode_t;
#define __mode_t_defined
typedef __nlink_t nlink_t;
#define __nlink_t_defined
typedef __id_t id_t;
#define __id_t_defined
typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;
#define __daddr_t_defined
typedef __key_t key_t;
#define __key_t_defined
#define __need_clock_t
#define __need_time_t
#define __need_timer_t
#define __need_clockid_t
#define __clock_t_defined 1
typedef __clock_t clock_t;
#undef __need_clock_t
#define __time_t_defined 1
typedef __time_t time_t;
#undef __need_time_t
#define __clockid_t_defined 1
typedef __clockid_t clockid_t;
#undef __clockid_time_t
#define __timer_t_defined 1
typedef __timer_t timer_t;
#undef __need_timer_t
#undef __need_timespec
typedef __suseconds_t suseconds_t;
#define __suseconds_t_defined
#define __need_size_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
#define __intN_t(N,MODE) typedef int int ##N ##_t __attribute__ ((__mode__ (MODE)))
#define __u_intN_t(N,MODE) typedef unsigned int u_int ##N ##_t __attribute__ ((__mode__ (MODE)))
#define __int8_t_defined
typedef int int8_t __attribute__ ((__mode__ (__QI__)));
typedef int int16_t __attribute__ ((__mode__ (__HI__)));
typedef int int32_t __attribute__ ((__mode__ (__SI__)));
typedef int int64_t __attribute__ ((__mode__ (__DI__)));
typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
typedef int register_t __attribute__ ((__mode__ (__word__)));
#define __BIT_TYPES_DEFINED__ 1
#define _SYS_SELECT_H 1
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
#define __FD_ZERO_STOS "stosq"
#define __FD_ZERO(fdsp) do { int __d0, __d1; __asm__ __volatile__ ("cld; rep; " __FD_ZERO_STOS : "=c" (__d0), "=D" (__d1) : "a" (0), "0" (sizeof (fd_set) / sizeof (__fd_mask)), "1" (&__FDS_BITS (fdsp)[0]) : "memory"); } while (0)
#define __FD_SET(d,set) ((void) (__FDS_BITS (set)[__FD_ELT (d)] |= __FD_MASK (d)))
#define __FD_CLR(d,set) ((void) (__FDS_BITS (set)[__FD_ELT (d)] &= ~__FD_MASK (d)))
#define __FD_ISSET(d,set) ((__FDS_BITS (set)[__FD_ELT (d)] & __FD_MASK (d)) != 0)
#define _SIGSET_H_types 1
typedef int __sig_atomic_t;
#define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int)))
typedef struct
{
unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
} __sigset_t;
#define __sigset_t_defined
typedef __sigset_t sigset_t;
#define __need_time_t
#define __need_timespec
#undef __need_clock_t
#undef __need_time_t
#undef __clockid_time_t
#undef __need_timer_t
#define __timespec_defined 1
struct timespec
{
__time_t tv_sec;
__syscall_slong_t tv_nsec;
};
#undef __need_timespec
#define __need_timeval
#define _STRUCT_TIMEVAL 1
struct timeval
{
__time_t tv_sec;
__suseconds_t tv_usec;
};
#undef __need_timeval
typedef long int __fd_mask;
#undef __NFDBITS
#define __NFDBITS (8 * (int) sizeof (__fd_mask))
#define __FD_ELT(d) ((d) / __NFDBITS)
#define __FD_MASK(d) ((__fd_mask) 1 << ((d) % __NFDBITS))
typedef struct
{
__fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
#define __FDS_BITS(set) ((set)->fds_bits)
} fd_set;
#define FD_SETSIZE __FD_SETSIZE
typedef __fd_mask fd_mask;
#define NFDBITS __NFDBITS
#define FD_SET(fd,fdsetp) __FD_SET (fd, fdsetp)
#define FD_CLR(fd,fdsetp) __FD_CLR (fd, fdsetp)
#define FD_ISSET(fd,fdsetp) __FD_ISSET (fd, fdsetp)
#define FD_ZERO(fdsetp) __FD_ZERO (fdsetp)
extern "C" {
extern int select (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
struct timeval *__restrict __timeout);
extern int pselect (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
const struct timespec *__restrict __timeout,
const __sigset_t *__restrict __sigmask);
}
#define _SYS_SYSMACROS_H 1
extern "C" {
__extension__
extern unsigned int gnu_dev_major (unsigned long long int __dev)
throw () __attribute__ ((__const__));
__extension__
extern unsigned int gnu_dev_minor (unsigned long long int __dev)
throw () __attribute__ ((__const__));
__extension__
extern unsigned long long int gnu_dev_makedev (unsigned int __major,
unsigned int __minor)
throw () __attribute__ ((__const__));
}
#define major(dev) gnu_dev_major (dev)
#define minor(dev) gnu_dev_minor (dev)
#define makedev(maj,min) gnu_dev_makedev (maj, min)
typedef __blksize_t blksize_t;
#define __blksize_t_defined
typedef __blkcnt_t blkcnt_t;
#define __blkcnt_t_defined
typedef __fsblkcnt_t fsblkcnt_t;
#define __fsblkcnt_t_defined
typedef __fsfilcnt_t fsfilcnt_t;
#define __fsfilcnt_t_defined
typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;
#define _BITS_PTHREADTYPES_H 1
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
#define __SIZEOF_PTHREAD_ATTR_T 56
#define __SIZEOF_PTHREAD_MUTEX_T 40
#define __SIZEOF_PTHREAD_MUTEXATTR_T 4
#define __SIZEOF_PTHREAD_COND_T 48
#define __SIZEOF_PTHREAD_CONDATTR_T 4
#define __SIZEOF_PTHREAD_RWLOCK_T 56
#define __SIZEOF_PTHREAD_RWLOCKATTR_T 8
#define __SIZEOF_PTHREAD_BARRIER_T 32
#define __SIZEOF_PTHREAD_BARRIERATTR_T 4
typedef unsigned long int pthread_t;
union pthread_attr_t
{
char __size[56];
long int __align;
};
typedef union pthread_attr_t pthread_attr_t;
#define __have_pthread_attr_t 1
typedef struct __pthread_internal_list
{
struct __pthread_internal_list *__prev;
struct __pthread_internal_list *__next;
} __pthread_list_t;
typedef union
{
struct __pthread_mutex_s
{
int __lock;
unsigned int __count;
int __owner;
unsigned int __nusers;
int __kind;
short __spins;
short __elision;
__pthread_list_t __list;
#define __PTHREAD_MUTEX_HAVE_PREV 1
#define __PTHREAD_MUTEX_HAVE_ELISION 1
} __data;
char __size[40];
long int __align;
} pthread_mutex_t;
typedef union
{
char __size[4];
int __align;
} pthread_mutexattr_t;
typedef union
{
struct
{
int __lock;
unsigned int __futex;
__extension__ unsigned long long int __total_seq;
__extension__ unsigned long long int __wakeup_seq;
__extension__ unsigned long long int __woken_seq;
void *__mutex;
unsigned int __nwaiters;
unsigned int __broadcast_seq;
} __data;
char __size[48];
__extension__ long long int __align;
} pthread_cond_t;
typedef union
{
char __size[4];
int __align;
} pthread_condattr_t;
typedef unsigned int pthread_key_t;
typedef int pthread_once_t;
typedef union
{
struct
{
int __lock;
unsigned int __nr_readers;
unsigned int __readers_wakeup;
unsigned int __writer_wakeup;
unsigned int __nr_readers_queued;
unsigned int __nr_writers_queued;
int __writer;
int __shared;
unsigned long int __pad1;
unsigned long int __pad2;
unsigned int __flags;
#define __PTHREAD_RWLOCK_INT_FLAGS_SHARED 1
} __data;
char __size[56];
long int __align;
} pthread_rwlock_t;
typedef union
{
char __size[8];
long int __align;
} pthread_rwlockattr_t;
typedef volatile int pthread_spinlock_t;
typedef union
{
char __size[32];
long int __align;
} pthread_barrier_t;
typedef union
{
char __size[4];
int __align;
} pthread_barrierattr_t;
}
extern long int random (void) throw ();
extern void srandom (unsigned int __seed) throw ();
extern char *initstate (unsigned int __seed, char *__statebuf,
size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));
extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));
struct random_data
{
int32_t *fptr;
int32_t *rptr;
int32_t *state;
int rand_type;
int rand_deg;
int rand_sep;
int32_t *end_ptr;
};
extern int random_r (struct random_data *__restrict __buf,
int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int srandom_r (unsigned int __seed, struct random_data *__buf)
throw () __attribute__ ((__nonnull__ (2)));
extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
size_t __statelen,
struct random_data *__restrict __buf)
throw () __attribute__ ((__nonnull__ (2, 4)));
extern int setstate_r (char *__restrict __statebuf,
struct random_data *__restrict __buf)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int rand (void) throw ();
extern void srand (unsigned int __seed) throw ();
extern int rand_r (unsigned int *__seed) throw ();
extern double drand48 (void) throw ();
extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));
extern long int lrand48 (void) throw ();
extern long int nrand48 (unsigned short int __xsubi[3])
throw () __attribute__ ((__nonnull__ (1)));
extern long int mrand48 (void) throw ();
extern long int jrand48 (unsigned short int __xsubi[3])
throw () __attribute__ ((__nonnull__ (1)));
extern void srand48 (long int __seedval) throw ();
extern unsigned short int *seed48 (unsigned short int __seed16v[3])
throw () __attribute__ ((__nonnull__ (1)));
extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));
struct drand48_data
{
unsigned short int __x[3];
unsigned short int __old_x[3];
unsigned short int __c;
unsigned short int __init;
__extension__ unsigned long long int __a;
};
extern int drand48_r (struct drand48_data *__restrict __buffer,
double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int erand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int lrand48_r (struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int nrand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int mrand48_r (struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int jrand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
throw () __attribute__ ((__nonnull__ (2)));
extern int seed48_r (unsigned short int __seed16v[3],
struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int lcong48_r (unsigned short int __param[7],
struct drand48_data *__buffer)
throw () __attribute__ ((__nonnull__ (1, 2)));
#define __malloc_and_calloc_defined
extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
extern void *calloc (size_t __nmemb, size_t __size)
throw () __attribute__ ((__malloc__)) ;
extern void *realloc (void *__ptr, size_t __size)
throw () __attribute__ ((__warn_unused_result__));
extern void free (void *__ptr) throw ();
extern void cfree (void *__ptr) throw ();
#define _ALLOCA_H 1
#define __need_size_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
extern "C" {
#undef alloca
extern void *alloca (size_t __size) throw ();
#define alloca(size) __builtin_alloca (size)
}
extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
throw () __attribute__ ((__nonnull__ (1))) ;
extern void *aligned_alloc (size_t __alignment, size_t __size)
throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) ;
extern void abort (void) throw () __attribute__ ((__noreturn__));
extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));
extern "C++" int at_quick_exit (void (*__func) (void))
throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));
extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
throw () __attribute__ ((__nonnull__ (1)));
extern void exit (int __status) throw () __attribute__ ((__noreturn__));
extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__));
extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));
extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ;
extern char *secure_getenv (const char *__name)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));
extern int setenv (const char *__name, const char *__value, int __replace)
throw () __attribute__ ((__nonnull__ (2)));
extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
extern int clearenv (void) throw ();
extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
extern int mkstemps64 (char *__template, int __suffixlen)
__attribute__ ((__nonnull__ (1))) ;
extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
extern int mkostemps (char *__template, int __suffixlen, int __flags)
__attribute__ ((__nonnull__ (1))) ;
extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
__attribute__ ((__nonnull__ (1))) ;
extern int system (const char *__command) ;
extern char *canonicalize_file_name (const char *__name)
throw () __attribute__ ((__nonnull__ (1))) ;
extern char *realpath (const char *__restrict __name,
char *__restrict __resolved) throw () ;
#define __COMPAR_FN_T
typedef int (*__compar_fn_t) (const void *, const void *);
typedef __compar_fn_t comparison_fn_t;
typedef int (*__compar_d_fn_t) (const void *, const void *, void *);
extern void *bsearch (const void *__key, const void *__base,
size_t __nmemb, size_t __size, __compar_fn_t __compar)
__attribute__ ((__nonnull__ (1, 2, 5))) ;
extern void qsort (void *__base, size_t __nmemb, size_t __size,
__compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
__compar_d_fn_t __compar, void *__arg)
__attribute__ ((__nonnull__ (1, 4)));
extern int abs (int __x) throw () __attribute__ ((__const__)) ;
extern long int labs (long int __x) throw () __attribute__ ((__const__)) ;
__extension__ extern long long int llabs (long long int __x)
throw () __attribute__ ((__const__)) ;
extern div_t div (int __numer, int __denom)
throw () __attribute__ ((__const__)) ;
extern ldiv_t ldiv (long int __numer, long int __denom)
throw () __attribute__ ((__const__)) ;
__extension__ extern lldiv_t lldiv (long long int __numer,
long long int __denom)
throw () __attribute__ ((__const__)) ;
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *gcvt (double __value, int __ndigit, char *__buf)
throw () __attribute__ ((__nonnull__ (3))) ;
extern char *qecvt (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign)
throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qfcvt (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign)
throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qgcvt (long double __value, int __ndigit, char *__buf)
throw () __attribute__ ((__nonnull__ (3))) ;
extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign, char *__restrict __buf,
size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign, char *__restrict __buf,
size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qecvt_r (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qfcvt_r (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int mblen (const char *__s, size_t __n) throw ();
extern int mbtowc (wchar_t *__restrict __pwc,
const char *__restrict __s, size_t __n) throw ();
extern int wctomb (char *__s, wchar_t __wchar) throw ();
extern size_t mbstowcs (wchar_t *__restrict __pwcs,
const char *__restrict __s, size_t __n) throw ();
extern size_t wcstombs (char *__restrict __s,
const wchar_t *__restrict __pwcs, size_t __n)
throw ();
extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) ;
extern int getsubopt (char **__restrict __optionp,
char *const *__restrict __tokens,
char **__restrict __valuep)
throw () __attribute__ ((__nonnull__ (1, 2, 3))) ;
extern void setkey (const char *__key) throw () __attribute__ ((__nonnull__ (1)));
extern int posix_openpt (int __oflag) ;
extern int grantpt (int __fd) throw ();
extern int unlockpt (int __fd) throw ();
extern char *ptsname (int __fd) throw () ;
extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2)));
extern int getpt (void);
extern int getloadavg (double __loadavg[], int __nelem)
throw () __attribute__ ((__nonnull__ (1)));
#undef __need_malloc_and_calloc
}
#undef abort
#undef abs
#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
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::div_t;
using ::ldiv_t;
using ::abort;
using ::abs;
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;
long
abs(long __i) ;
ldiv_t
div(long __i, long __j) ;
long long
abs(long long __x) ;
}
#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;
lldiv_t
div(long long __n, long long __d)
;
using ::lldiv;
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;
}
#define BOOST_HAS_STDINT_H
#define BOOST_HAS_GETTIMEOFDAY
#define BOOST_HAS_NANOSLEEP
#define BOOST_HAS_UNISTD_H
#define BOOST_HAS_NL_TYPES_H
#define BOOST_HAS_STDINT_H
#define BOOST_HAS_DIRENT_H
#define BOOST_HAS_SIGACTION
#define BOOST_HAS_PTHREADS
#define BOOST_HAS_NANOSLEEP
#define BOOST_HAS_CLOCK_GETTIME
#define BOOST_HAS_SCHED_YIELD
#define BOOST_HAS_GETTIMEOFDAY
#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
#define BOOST_HAS_LOG1P
#define BOOST_HAS_EXPM1
#define BOOST_HAS_PTHREAD_YIELD
#define BOOST_CONFIG_SUFFIX_HPP
#define BOOST_NO_MS_INT64_NUMERIC_LIMITS
#define BOOST_MSVC6_MEMBER_TEMPLATES
#define BOOST_HAS_PARTIAL_STD_ALLOCATOR
#define BOOST_PREVENT_MACRO_SUBSTITUTION
#define BOOST_USING_STD_MIN() using std::min
#define BOOST_USING_STD_MAX() using std::max
#define BOOST_STATIC_CONSTANT(type,assignment) static const type assignment
#define BOOST_USE_FACET(Type,loc) std::use_facet< Type >(loc)
#define BOOST_HAS_FACET(Type,loc) std::has_facet< Type >(loc)
#define BOOST_NESTED_TEMPLATE template
#define BOOST_UNREACHABLE_RETURN(x)
#define BOOST_DEDUCED_TYPENAME typename
#define BOOST_CTOR_TYPENAME typename
namespace boost{
__extension__ typedef long long long_long_type;
__extension__ typedef unsigned long long ulong_long_type;
}
namespace boost{
__extension__ typedef __int128 int128_type;
__extension__ typedef unsigned __int128 uint128_type;
}
#define BOOST_EXPLICIT_TEMPLATE_TYPE(t)
#define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
#define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t,v)
#define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t,v)
#define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t)
#define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
#define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t,v)
#define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t,v)
#define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X)
#define BOOST_DO_STRINGIZE(X) #X
#define BOOST_JOIN(X,Y) BOOST_DO_JOIN( X, Y )
#define BOOST_DO_JOIN(X,Y) BOOST_DO_JOIN2(X,Y)
#define BOOST_DO_JOIN2(X,Y) X ##Y
#define BOOST_GPU_ENABLED
#define BOOST_FORCEINLINE inline __attribute__ ((__always_inline__))
#define BOOST_NOINLINE __attribute__ ((__noinline__))
#define BOOST_ALIGNMENT(x) alignas(x)
#define BOOST_DEFAULTED_FUNCTION(fun,body) fun = default;
#define BOOST_DELETED_FUNCTION(fun) fun = delete;
#define BOOST_NO_0X_HDR_CODECVT
#define BOOST_NO_0X_HDR_THREAD
#define BOOST_NO_0X_HDR_TYPE_TRAITS
#define BOOST_NOEXCEPT noexcept
#define BOOST_NOEXCEPT_OR_NOTHROW noexcept
#define BOOST_NOEXCEPT_IF(Predicate) noexcept((Predicate))
#define BOOST_NOEXCEPT_EXPR(Expression) noexcept((Expression))
#define BOOST_FALLTHROUGH ((void)0)
#define BOOST_CONSTEXPR constexpr
#define BOOST_CONSTEXPR_OR_CONST constexpr
#define BOOST_STATIC_CONSTEXPR static BOOST_CONSTEXPR_OR_CONST
#define BOOST_VERSION_HPP
#define BOOST_VERSION 105500
#define BOOST_LIB_VERSION "1_55"
#define BOOST_ASIO_HAS_BOOST_CONFIG 1
#define BOOST_ASIO_HEADER_ONLY 1
#define BOOST_ASIO_DECL inline
#define BOOST_ASIO_HAS_MOVE 1
#define BOOST_ASIO_MOVE_ARG(type) type&&
#define BOOST_ASIO_MOVE_CAST(type) static_cast<type&&>
#define BOOST_ASIO_MOVE_CAST2(type1,type2) static_cast<type1, type2&&>
#define BOOST_ASIO_HAS_VARIADIC_TEMPLATES 1
#define BOOST_ASIO_HAS_CONSTEXPR 1
#define BOOST_ASIO_CONSTEXPR constexpr
#define BOOST_ASIO_HAS_STD_SYSTEM_ERROR 1
#define BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT BOOST_NOEXCEPT
#define BOOST_ASIO_HAS_STD_ARRAY 1
#define BOOST_ASIO_HAS_STD_SHARED_PTR 1
#define BOOST_ASIO_HAS_STD_ATOMIC 1
#define BOOST_ASIO_HAS_STD_CHRONO 1
#define BOOST_ASIO_HAS_BOOST_CHRONO 1
#define BOOST_ASIO_HAS_BOOST_DATE_TIME 1
#define BOOST_ASIO_HAS_STD_ADDRESSOF 1
#define BOOST_ASIO_HAS_STD_FUNCTION 1
#define BOOST_ASIO_HAS_STD_TYPE_TRAITS 1
#define BOOST_ASIO_HAS_CSTDINT 1
#define BOOST_ASIO_HAS_STD_THREAD 1
#define BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR 1
#define LINUX_VERSION_CODE 200707
#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
#define BOOST_ASIO_HAS_EPOLL 1
#define BOOST_ASIO_HAS_EVENTFD 1
#define BOOST_ASIO_HAS_TIMERFD 1
#define BOOST_ASIO_HAS_SERIAL_PORT 1
#define BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR 1
#define BOOST_ASIO_HAS_LOCAL_SOCKETS 1
#define BOOST_ASIO_HAS_SIGACTION 1
#define BOOST_ASIO_HAS_SIGNAL 1
#define BOOST_ASIO_HAS_THREADS 1
#define BOOST_ASIO_HAS_PTHREADS 1
#define BOOST_ASIO_PREVENT_MACRO_SUBSTITUTION
#define BOOST_ASIO_STATIC_CONSTANT(type,assignment) BOOST_STATIC_CONSTANT(type, assignment)
#define BOOST_ASIO_HAS_BOOST_ARRAY 1
#define BOOST_ASIO_HAS_BOOST_ASSERT 1
#define BOOST_ASIO_HAS_BOOST_LIMITS 1
#define BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION 1
#define BOOST_ASIO_HAS_BOOST_REGEX 1
#define BOOST_ASIO_HAS_BOOST_BIND 1
#define BOOST_ASIO_HAS_BOOST_WORKAROUND 1
#define BOOST_ASIO_HAS_HANDLER_HOOKS 1
#define BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION 1
#define BOOST_ASIO_THREAD_KEYWORD __thread
#define BOOST_ASIO_HAS_SSIZE_T 1
#define BOOST_ASIO_HANDLER_TYPE_HPP
namespace boost {
namespace asio {
template <typename Handler, typename Signature>
struct handler_type
{
typedef Handler type;
};
template <typename Handler, typename Signature>
struct handler_type<const Handler, Signature>
: handler_type<Handler, Signature> {};
template <typename Handler, typename Signature>
struct handler_type<volatile Handler, Signature>
: handler_type<Handler, Signature> {};
template <typename Handler, typename Signature>
struct handler_type<const volatile Handler, Signature>
: handler_type<Handler, Signature> {};
template <typename Handler, typename Signature>
struct handler_type<const Handler&, Signature>
: handler_type<Handler, Signature> {};
template <typename Handler, typename Signature>
struct handler_type<volatile Handler&, Signature>
: handler_type<Handler, Signature> {};
template <typename Handler, typename Signature>
struct handler_type<const volatile Handler&, Signature>
: handler_type<Handler, Signature> {};
template <typename Handler, typename Signature>
struct handler_type<Handler&, Signature>
: handler_type<Handler, Signature> {};
template <typename Handler, typename Signature>
struct handler_type<Handler&&, Signature>
: handler_type<Handler, Signature> {};
template <typename ReturnType, typename Signature>
struct handler_type<ReturnType(), Signature>
: handler_type<ReturnType(*)(), Signature> {};
template <typename ReturnType, typename Arg1, typename Signature>
struct handler_type<ReturnType(Arg1), Signature>
: handler_type<ReturnType(*)(Arg1), Signature> {};
template <typename ReturnType, typename Arg1, typename Arg2, typename Signature>
struct handler_type<ReturnType(Arg1, Arg2), Signature>
: handler_type<ReturnType(*)(Arg1, Arg2), Signature> {};
template <typename ReturnType, typename Arg1, typename Arg2, typename Arg3,
typename Signature>
struct handler_type<ReturnType(Arg1, Arg2, Arg3), Signature>
: handler_type<ReturnType(*)(Arg1, Arg2, Arg3), Signature> {};
template <typename ReturnType, typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Signature>
struct handler_type<ReturnType(Arg1, Arg2, Arg3, Arg4), Signature>
: handler_type<ReturnType(*)(Arg1, Arg2, Arg3, Arg4), Signature> {};
template <typename ReturnType, typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5, typename Signature>
struct handler_type<ReturnType(Arg1, Arg2, Arg3, Arg4, Arg5), Signature>
: handler_type<ReturnType(*)(Arg1, Arg2, Arg3, Arg4, Arg5), Signature> {};
}
}
#define BOOST_ASIO_HANDLER_TYPE(h,sig) typename handler_type<h, sig>::type
namespace boost {
namespace asio {
template <typename Handler>
class async_result
{
public:
typedef void type;
explicit async_result(Handler&)
;
type get()
;
};
namespace detail {
template <typename Handler, typename Signature>
struct async_result_init
{
explicit async_result_init(Handler&& orig_handler)
;
typename handler_type<Handler, Signature>::type handler;
async_result<typename handler_type<Handler, Signature>::type> result;
};
template <typename Handler, typename Signature>
struct async_result_type_helper
{
typedef typename async_result<
typename handler_type<Handler, Signature>::type
>::type type;
};
}
}
}
#define BOOST_ASIO_INITFN_RESULT_TYPE(h,sig) typename ::boost::asio::async_result< typename ::boost::asio::handler_type<h, sig>::type>::type
#define BOOST_ASIO_BASIC_DATAGRAM_SOCKET_HPP
#define BOOST_ASIO_BASIC_SOCKET_HPP
#define BOOST_ASIO_BASIC_IO_OBJECT_HPP
#define BOOST_ASIO_IO_SERVICE_HPP
#define _GLIBCXX_STDEXCEPT 1
#define __EXCEPTION__
#pragma GCC visibility push(default)
#define _GLIBCXX_ATOMIC_LOCK_FREE_H 1
#define ATOMIC_BOOL_LOCK_FREE __GCC_ATOMIC_BOOL_LOCK_FREE
#define ATOMIC_CHAR_LOCK_FREE __GCC_ATOMIC_CHAR_LOCK_FREE
#define ATOMIC_WCHAR_T_LOCK_FREE __GCC_ATOMIC_WCHAR_T_LOCK_FREE
#define ATOMIC_CHAR16_T_LOCK_FREE __GCC_ATOMIC_CHAR16_T_LOCK_FREE
#define ATOMIC_CHAR32_T_LOCK_FREE __GCC_ATOMIC_CHAR32_T_LOCK_FREE
#define ATOMIC_SHORT_LOCK_FREE __GCC_ATOMIC_SHORT_LOCK_FREE
#define ATOMIC_INT_LOCK_FREE __GCC_ATOMIC_INT_LOCK_FREE
#define ATOMIC_LONG_LOCK_FREE __GCC_ATOMIC_LONG_LOCK_FREE
#define ATOMIC_LLONG_LOCK_FREE __GCC_ATOMIC_LLONG_LOCK_FREE
#define ATOMIC_POINTER_LOCK_FREE __GCC_ATOMIC_POINTER_LOCK_FREE
extern "C++" {
namespace std
{
class exception
{
public:
exception() noexcept { }
virtual ~exception() noexcept;
virtual const char* what() const noexcept;
};
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__));
bool uncaught_exception() noexcept __attribute__ ((__pure__));
}
namespace __gnu_cxx
{
void __verbose_terminate_handler();
}
}
#pragma GCC visibility pop
#define _EXCEPTION_PTR_H
#pragma GCC visibility push(default)
#define _EXCEPTION_DEFINES_H 1
#define __try try
#define __catch(X) catch(X)
#define __throw_exception_again throw
extern "C++" {
namespace std
{
class type_info;
namespace __exception_ptr
{
class exception_ptr;
}
using __exception_ptr::exception_ptr;
exception_ptr current_exception() noexcept;
void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__));
namespace __exception_ptr
{
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);
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; }
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;
explicit operator bool() const
;
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__));
void
swap(exception_ptr& __lhs, exception_ptr& __rhs)
;
}
template<typename _Ex>
exception_ptr
make_exception_ptr(_Ex __ex) noexcept
{
try
{
throw __ex;
}
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
#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)
;
explicit _Nested_exception(_Except&& __ex)
;
};
template<typename _Tp,
bool __with_nested = !__is_base_of(nested_exception, _Tp)>
struct _Throw_with_nested_impl
{
template<typename _Up>
static void _S_throw(_Up&& __t)
;
};
template<typename _Tp>
struct _Throw_with_nested_impl<_Tp, false>
{
template<typename _Up>
static void _S_throw(_Up&& __t)
;
};
template<typename _Tp, bool = __is_class(_Tp)>
struct _Throw_with_nested_helper : _Throw_with_nested_impl<_Tp>
{ };
template<typename _Tp>
struct _Throw_with_nested_helper<_Tp, false>
: _Throw_with_nested_impl<_Tp, false>
{ };
template<typename _Tp>
struct _Throw_with_nested_helper<_Tp&, false>
: _Throw_with_nested_helper<_Tp>
{ };
template<typename _Tp>
struct _Throw_with_nested_helper<_Tp&&, false>
: _Throw_with_nested_helper<_Tp>
{ };
template<typename _Tp>
[[noreturn]]
inline void
throw_with_nested(_Tp&& __t)
{
_Throw_with_nested_helper<_Tp>::_S_throw(static_cast<_Tp&&>(__t));
}
template<typename _Tp, bool = __is_polymorphic(_Tp)>
struct _Rethrow_if_nested_impl
{
static void _S_rethrow(const _Tp& __t)
{
if (auto __tp = dynamic_cast<const nested_exception*>(&__t))
__tp->rethrow_nested();
}
};
template<typename _Tp>
struct _Rethrow_if_nested_impl<_Tp, false>
{
static void _S_rethrow(const _Tp&) { }
};
template<typename _Ex>
void
rethrow_if_nested(const _Ex& __ex)
;
}
}
#pragma GCC visibility pop
#define _GLIBCXX_STRING 1
#define _STRINGFWD_H 1
#define _MEMORYFWD_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename>
class allocator;
template<>
class allocator<void>;
template<typename, typename>
struct uses_allocator;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<class _CharT>
struct char_traits;
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_string;
template<> struct char_traits<char>;
typedef basic_string<char> string;
template<> struct char_traits<wchar_t>;
typedef basic_string<wchar_t> wstring;
template<> struct char_traits<char16_t>;
template<> struct char_traits<char32_t>;
typedef basic_string<char16_t> u16string;
typedef basic_string<char32_t> u32string;
}
#define _CHAR_TRAITS_H 1
#define _STL_ALGOBASE_H 1
#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__));
}
#define _CPP_TYPE_TRAITS_H 1
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
template<typename _Iterator, typename _Container>
class __normal_iterator;
}
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;
};
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_normal_iterator
{
enum { __value = 0 };
typedef __false_type __type;
};
template<typename _Iterator, typename _Container>
struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
_Container> >
{
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>
class move_iterator;
template<typename _Iterator>
struct __is_move_iterator< move_iterator<_Iterator> >
{
enum { __value = 1 };
typedef __true_type __type;
};
}
#define _EXT_TYPE_TRAITS 1
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>
bool
__is_null_pointer(_Type* __ptr)
;
template<typename _Type>
bool
__is_null_pointer(_Type)
;
bool
__is_null_pointer(std::nullptr_t)
;
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;
};
}
#define _EXT_NUMERIC_TRAITS 1
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 : 64) * 643L / 2136);
static const bool __is_signed = true;
static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18);
static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
};
template<typename _Value>
const int __numeric_traits_floating<_Value>::__max_digits10;
template<typename _Value>
const bool __numeric_traits_floating<_Value>::__is_signed;
template<typename _Value>
const int __numeric_traits_floating<_Value>::__digits10;
template<typename _Value>
const int __numeric_traits_floating<_Value>::__max_exponent10;
template<typename _Value>
struct __numeric_traits
: public __conditional_type<std::__is_integer<_Value>::__value,
__numeric_traits_integer<_Value>,
__numeric_traits_floating<_Value> >::__type
{ };
}
#undef __glibcxx_floating
#undef __glibcxx_max_digits10
#undef __glibcxx_digits10
#undef __glibcxx_max_exponent10
#define _STL_ITERATOR_BASE_TYPES_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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 { };
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;
};
template<typename _Tp> class __has_iterator_category_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::iterator_category>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_iterator_category : public __has_iterator_category_helper <typename remove_cv<_Tp>::type>::type { };
template<typename _Iterator,
bool = __has_iterator_category<_Iterator>::value>
struct __iterator_traits { };
template<typename _Iterator>
struct __iterator_traits<_Iterator, true>
{
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> { };
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>
typename iterator_traits<_Iter>::iterator_category
__iterator_category(const _Iter&)
;
template<typename _Iterator, bool _HasBase>
struct _Iter_base
{
typedef _Iterator iterator_type;
static iterator_type _S_base(_Iterator __it)
;
};
template<typename _Iterator>
struct _Iter_base<_Iterator, true>
{
typedef typename _Iterator::iterator_type iterator_type;
static iterator_type _S_base(_Iterator __it)
;
};
template<typename _InIter>
using _RequireInputIter = typename
enable_if<is_convertible<typename
iterator_traits<_InIter>::iterator_category,
input_iterator_tag>::value>::type;
}
#define _STL_ITERATOR_BASE_FUNCS_H 1
#define _GLIBCXX_DEBUG_MACRO_SWITCH_H 1
namespace std
{
namespace __debug { }
}
namespace __gnu_debug
{
using namespace std::__debug;
}
#define _GLIBCXX_DEBUG_ASSERT(_Condition)
#define _GLIBCXX_DEBUG_PEDASSERT(_Condition)
#define _GLIBCXX_DEBUG_ONLY(_Statement) ;
#define __glibcxx_requires_cond(_Cond,_Msg)
#define __glibcxx_requires_valid_range(_First,_Last)
#define __glibcxx_requires_non_empty_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_nonempty()
#define __glibcxx_requires_string(_String)
#define __glibcxx_requires_string_len(_String,_Len)
#define __glibcxx_requires_subscript(_N)
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _InputIterator>
typename iterator_traits<_InputIterator>::difference_type
__distance(_InputIterator __first, _InputIterator __last,
input_iterator_tag)
;
template<typename _RandomAccessIterator>
typename iterator_traits<_RandomAccessIterator>::difference_type
__distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
random_access_iterator_tag)
;
template<typename _InputIterator>
typename iterator_traits<_InputIterator>::difference_type
distance(_InputIterator __first, _InputIterator __last)
;
template<typename _InputIterator, typename _Distance>
void
__advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
;
template<typename _BidirectionalIterator, typename _Distance>
void
__advance(_BidirectionalIterator& __i, _Distance __n,
bidirectional_iterator_tag)
;
template<typename _RandomAccessIterator, typename _Distance>
void
__advance(_RandomAccessIterator& __i, _Distance __n,
random_access_iterator_tag)
;
template<typename _InputIterator, typename _Distance>
void
advance(_InputIterator& __i, _Distance __n)
;
template<typename _ForwardIterator>
_ForwardIterator
next(_ForwardIterator __x, typename
iterator_traits<_ForwardIterator>::difference_type __n = 1)
;
template<typename _BidirectionalIterator>
_BidirectionalIterator
prev(_BidirectionalIterator __x, typename
iterator_traits<_BidirectionalIterator>::difference_type __n = 1)
;
}
#define _STL_ITERATOR_H 1
#define _PTR_TRAITS_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp> class __has_element_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::element_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_element_type : public __has_element_type_helper <typename remove_cv<_Tp>::type>::type { };
template<typename _Tp> class __has_difference_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::difference_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_difference_type : public __has_difference_type_helper <typename remove_cv<_Tp>::type>::type { };
template<typename _Tp, bool = __has_element_type<_Tp>::value>
struct __ptrtr_elt_type;
template<typename _Tp>
struct __ptrtr_elt_type<_Tp, true>
{
typedef typename _Tp::element_type __type;
};
template<template<typename, typename...> class _SomePtr, typename _Tp,
typename... _Args>
struct __ptrtr_elt_type<_SomePtr<_Tp, _Args...>, false>
{
typedef _Tp __type;
};
template<typename _Tp, bool = __has_difference_type<_Tp>::value>
struct __ptrtr_diff_type
{
typedef typename _Tp::difference_type __type;
};
template<typename _Tp>
struct __ptrtr_diff_type<_Tp, false>
{
typedef ptrdiff_t __type;
};
template<typename _Ptr, typename _Up>
class __ptrtr_rebind_helper
{
template<typename _Ptr2, typename _Up2>
static constexpr true_type
_S_chk(typename _Ptr2::template rebind<_Up2>*);
template<typename, typename>
static constexpr false_type
_S_chk(...);
public:
using __type = decltype(_S_chk<_Ptr, _Up>(nullptr));
};
template<typename _Tp, typename _Up,
bool = __ptrtr_rebind_helper<_Tp, _Up>::__type::value>
struct __ptrtr_rebind;
template<typename _Tp, typename _Up>
struct __ptrtr_rebind<_Tp, _Up, true>
{
typedef typename _Tp::template rebind<_Up> __type;
};
template<template<typename, typename...> class _SomePtr, typename _Up,
typename _Tp, typename... _Args>
struct __ptrtr_rebind<_SomePtr<_Tp, _Args...>, _Up, false>
{
typedef _SomePtr<_Up, _Args...> __type;
};
template<typename _Tp, typename = typename remove_cv<_Tp>::type>
struct __ptrtr_not_void
{
typedef _Tp __type;
};
template<typename _Tp>
struct __ptrtr_not_void<_Tp, void>
{
struct __type { };
};
template<typename _Ptr>
class __ptrtr_pointer_to
{
typedef typename __ptrtr_elt_type<_Ptr>::__type __orig_type;
typedef typename __ptrtr_not_void<__orig_type>::__type __element_type;
public:
static _Ptr pointer_to(__element_type& __e)
;
};
template<typename _Ptr>
struct pointer_traits : __ptrtr_pointer_to<_Ptr>
{
typedef _Ptr pointer;
typedef typename __ptrtr_elt_type<_Ptr>::__type element_type;
typedef typename __ptrtr_diff_type<_Ptr>::__type difference_type;
template<typename _Up>
using rebind = typename __ptrtr_rebind<_Ptr, _Up>::__type;
};
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(typename __ptrtr_not_void<element_type>::__type& __r) noexcept
{ return std::addressof(__r); }
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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;
reverse_iterator() ;
explicit
reverse_iterator(iterator_type __x) ;
reverse_iterator(const reverse_iterator& __x) ;
template<typename _Iter>
reverse_iterator(const reverse_iterator<_Iter>& __x) ;
iterator_type
base() const
;
reference
operator*() const
;
pointer
operator->() const
;
reverse_iterator&
operator++()
;
reverse_iterator
operator++(int)
;
reverse_iterator&
operator--()
;
reverse_iterator
operator--(int)
;
reverse_iterator
operator+(difference_type __n) const
;
reverse_iterator&
operator+=(difference_type __n)
;
reverse_iterator
operator-(difference_type __n) const
;
reverse_iterator&
operator-=(difference_type __n)
;
reference
operator[](difference_type __n) const
;
};
template<typename _Iterator>
bool
operator==(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
bool
operator<(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
bool
operator!=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
bool
operator>(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
bool
operator<=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
bool
operator>=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
typename reverse_iterator<_Iterator>::difference_type
operator-(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
reverse_iterator<_Iterator>
operator+(typename reverse_iterator<_Iterator>::difference_type __n,
const reverse_iterator<_Iterator>& __x)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator==(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator<(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator!=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator>(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator<=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator>=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
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 _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) ;
back_insert_iterator&
operator=(const typename _Container::value_type& __value)
;
back_insert_iterator&
operator=(typename _Container::value_type&& __value)
;
back_insert_iterator&
operator*()
;
back_insert_iterator&
operator++()
;
back_insert_iterator
operator++(int)
;
};
template<typename _Container>
back_insert_iterator<_Container>
back_inserter(_Container& __x)
;
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) ;
front_insert_iterator&
operator=(const typename _Container::value_type& __value)
;
front_insert_iterator&
operator=(typename _Container::value_type&& __value)
;
front_insert_iterator&
operator*()
;
front_insert_iterator&
operator++()
;
front_insert_iterator
operator++(int)
;
};
template<typename _Container>
front_insert_iterator<_Container>
front_inserter(_Container& __x)
;
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) ;
insert_iterator&
operator=(const typename _Container::value_type& __value)
;
insert_iterator&
operator=(typename _Container::value_type&& __value)
;
insert_iterator&
operator*()
;
insert_iterator&
operator++()
;
insert_iterator&
operator++(int)
;
};
template<typename _Container, typename _Iterator>
insert_iterator<_Container>
inserter(_Container& __x, _Iterator __i)
;
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
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; }
};
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>
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() ;
explicit
move_iterator(iterator_type __i) ;
template<typename _Iter>
move_iterator(const move_iterator<_Iter>& __i) ;
iterator_type
base() const
;
reference
operator*() const
;
pointer
operator->() const
;
move_iterator&
operator++()
;
move_iterator
operator++(int)
;
move_iterator&
operator--()
;
move_iterator
operator--(int)
;
move_iterator
operator+(difference_type __n) const
;
move_iterator&
operator+=(difference_type __n)
;
move_iterator
operator-(difference_type __n) const
;
move_iterator&
operator-=(difference_type __n)
;
reference
operator[](difference_type __n) const
;
};
template<typename _IteratorL, typename _IteratorR>
bool
operator==(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
;
template<typename _Iterator>
bool
operator==(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator!=(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
;
template<typename _Iterator>
bool
operator!=(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator<(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
;
template<typename _Iterator>
bool
operator<(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator<=(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
;
template<typename _Iterator>
bool
operator<=(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator>(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
;
template<typename _Iterator>
bool
operator>(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator>=(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
;
template<typename _Iterator>
bool
operator>=(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __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 auto
operator-(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
-> decltype(__x.base() - __y.base())
{ return __x.base() - __y.base(); }
template<typename _Iterator>
move_iterator<_Iterator>
operator+(typename move_iterator<_Iterator>::difference_type __n,
const move_iterator<_Iterator>& __x)
;
template<typename _Iterator>
move_iterator<_Iterator>
make_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); }
}
#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)
#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
;
};
_Iter_less_iter
__iter_less_iter()
;
struct _Iter_less_val
{
template<typename _Iterator, typename _Value>
bool
operator()(_Iterator __it, _Value& __val) const
;
};
_Iter_less_val
__iter_less_val()
;
_Iter_less_val
__iter_comp_val(_Iter_less_iter)
;
struct _Val_less_iter
{
template<typename _Value, typename _Iterator>
bool
operator()(_Value& __val, _Iterator __it) const
;
};
_Val_less_iter
__val_less_iter()
;
_Val_less_iter
__val_comp_iter(_Iter_less_iter)
;
struct _Iter_equal_to_iter
{
template<typename _Iterator1, typename _Iterator2>
bool
operator()(_Iterator1 __it1, _Iterator2 __it2) const
;
};
_Iter_equal_to_iter
__iter_equal_to_iter()
;
struct _Iter_equal_to_val
{
template<typename _Iterator, typename _Value>
bool
operator()(_Iterator __it, _Value& __val) const
;
};
_Iter_equal_to_val
__iter_equal_to_val()
;
_Iter_equal_to_val
__iter_comp_val(_Iter_equal_to_iter)
;
template<typename _Compare>
struct _Iter_comp_iter
{
_Compare _M_comp;
_Iter_comp_iter(_Compare __comp)
;
template<typename _Iterator1, typename _Iterator2>
bool
operator()(_Iterator1 __it1, _Iterator2 __it2)
;
};
template<typename _Compare>
_Iter_comp_iter<_Compare>
__iter_comp_iter(_Compare __comp)
;
template<typename _Compare>
struct _Iter_comp_val
{
_Compare _M_comp;
_Iter_comp_val(_Compare __comp)
;
template<typename _Iterator, typename _Value>
bool
operator()(_Iterator __it, _Value& __val)
;
};
template<typename _Compare>
_Iter_comp_val<_Compare>
__iter_comp_val(_Compare __comp)
;
template<typename _Compare>
_Iter_comp_val<_Compare>
__iter_comp_val(_Iter_comp_iter<_Compare> __comp)
;
template<typename _Compare>
struct _Val_comp_iter
{
_Compare _M_comp;
_Val_comp_iter(_Compare __comp)
;
template<typename _Value, typename _Iterator>
bool
operator()(_Value& __val, _Iterator __it)
;
};
template<typename _Compare>
_Val_comp_iter<_Compare>
__val_comp_iter(_Compare __comp)
;
template<typename _Compare>
_Val_comp_iter<_Compare>
__val_comp_iter(_Iter_comp_iter<_Compare> __comp)
;
template<typename _Value>
struct _Iter_equals_val
{
_Value& _M_value;
_Iter_equals_val(_Value& __value)
;
template<typename _Iterator>
bool
operator()(_Iterator __it)
;
};
template<typename _Value>
_Iter_equals_val<_Value>
__iter_equals_val(_Value& __val)
;
template<typename _Iterator1>
struct _Iter_equals_iter
{
typename std::iterator_traits<_Iterator1>::reference _M_ref;
_Iter_equals_iter(_Iterator1 __it1)
;
template<typename _Iterator2>
bool
operator()(_Iterator2 __it2)
;
};
template<typename _Iterator>
_Iter_equals_iter<_Iterator>
__iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
;
template<typename _Predicate>
struct _Iter_pred
{
_Predicate _M_pred;
_Iter_pred(_Predicate __pred)
;
template<typename _Iterator>
bool
operator()(_Iterator __it)
;
};
template<typename _Predicate>
_Iter_pred<_Predicate>
__pred_iter(_Predicate __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)
;
template<typename _Iterator>
bool
operator()(_Iterator __it)
;
};
template<typename _Compare, typename _Value>
_Iter_comp_to_val<_Compare, _Value>
__iter_comp_val(_Compare __comp, _Value &__val)
;
template<typename _Compare, typename _Iterator1>
struct _Iter_comp_to_iter
{
_Compare _M_comp;
typename std::iterator_traits<_Iterator1>::reference _M_ref;
_Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
;
template<typename _Iterator2>
bool
operator()(_Iterator2 __it2)
;
};
template<typename _Compare, typename _Iterator>
_Iter_comp_to_iter<_Compare, _Iterator>
__iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
;
template<typename _Predicate>
struct _Iter_negate
{
_Predicate _M_pred;
_Iter_negate(_Predicate __pred)
;
template<typename _Iterator>
bool
operator()(_Iterator __it)
;
};
template<typename _Predicate>
_Iter_negate<_Predicate>
__negate(_Iter_pred<_Predicate> __pred)
;
}
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _ForwardIterator1, typename _ForwardIterator2>
void
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
;
template<typename _ForwardIterator1, typename _ForwardIterator2>
_ForwardIterator2
swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2)
;
template<typename _Tp>
const _Tp&
min(const _Tp& __a, const _Tp& __b)
;
template<typename _Tp>
const _Tp&
max(const _Tp& __a, const _Tp& __b)
;
template<typename _Tp, typename _Compare>
const _Tp&
min(const _Tp& __a, const _Tp& __b, _Compare __comp)
;
template<typename _Tp, typename _Compare>
const _Tp&
max(const _Tp& __a, const _Tp& __b, _Compare __comp)
;
template<typename _Iterator>
struct _Niter_base
: _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value>
{ };
template<typename _Iterator>
typename _Niter_base<_Iterator>::iterator_type
__niter_base(_Iterator __it)
;
template<typename _Iterator>
struct _Miter_base
: _Iter_base<_Iterator, __is_move_iterator<_Iterator>::__value>
{ };
template<typename _Iterator>
typename _Miter_base<_Iterator>::iterator_type
__miter_base(_Iterator __it)
;
template<bool, bool, typename>
struct __copy_move
{
template<typename _II, typename _OI>
static _OI
__copy_m(_II __first, _II __last, _OI __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)
;
};
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)
;
};
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)
;
};
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)
;
};
template<bool _IsMove, typename _II, typename _OI>
_OI
__copy_move_a(_II __first, _II __last, _OI __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>
_OI
__copy_move_a2(_II __first, _II __last, _OI __result)
;
template<typename _II, typename _OI>
_OI
copy(_II __first, _II __last, _OI __result)
;
template<typename _II, typename _OI>
_OI
move(_II __first, _II __last, _OI __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)
;
};
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)
;
};
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)
;
};
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)
;
};
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)
;
};
template<bool _IsMove, typename _BI1, typename _BI2>
_BI2
__copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
;
template<bool _IsMove, typename _BI1, typename _BI2>
_BI2
__copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
;
template<typename _BI1, typename _BI2>
_BI2
copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
;
template<typename _BI1, typename _BI2>
_BI2
move_backward(_BI1 __first, _BI1 __last, _BI2 __result)
;
#define _GLIBCXX_MOVE_BACKWARD3(_Tp,_Up,_Vp) std::move_backward(_Tp, _Up, _Vp)
template<typename _ForwardIterator, typename _Tp>
typename
__gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
__fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __value)
;
template<typename _ForwardIterator, typename _Tp>
typename
__gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
__fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __value)
;
template<typename _Tp>
typename
__gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
__fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)
;
template<typename _ForwardIterator, typename _Tp>
void
fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
;
template<typename _OutputIterator, typename _Size, typename _Tp>
typename
__gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
;
template<typename _OutputIterator, typename _Size, typename _Tp>
typename
__gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
;
template<typename _Size, typename _Tp>
typename
__gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
__fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
;
template<typename _OI, typename _Size, typename _Tp>
_OI
fill_n(_OI __first, _Size __n, const _Tp& __value)
;
template<bool _BoolType>
struct __equal
{
template<typename _II1, typename _II2>
static bool
equal(_II1 __first1, _II1 __last1, _II2 __first2)
;
};
template<>
struct __equal<true>
{
template<typename _Tp>
static bool
equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
;
};
template<typename _II1, typename _II2>
bool
__equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
;
template<typename, typename>
struct __lc_rai
{
template<typename _II1, typename _II2>
static _II1
__newlast1(_II1, _II1 __last1, _II2, _II2)
;
template<typename _II>
static bool
__cnd2(_II __first, _II __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)
;
template<typename _RAI>
static bool
__cnd2(_RAI, _RAI)
;
};
template<typename _II1, typename _II2, typename _Compare>
bool
__lexicographical_compare_impl(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2,
_Compare __comp)
;
template<bool _BoolType>
struct __lexicographical_compare
{
template<typename _II1, typename _II2>
static bool __lc(_II1, _II1, _II2, _II2);
};
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)
;
};
template<typename _II1, typename _II2>
bool
__lexicographical_compare_aux(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
_ForwardIterator
__lower_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
;
template<typename _ForwardIterator, typename _Tp>
_ForwardIterator
lower_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __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); }
template<typename _II1, typename _II2>
bool
equal(_II1 __first1, _II1 __last1, _II2 __first2)
;
template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
bool
equal(_IIter1 __first1, _IIter1 __last1,
_IIter2 __first2, _BinaryPredicate __binary_pred)
;
template<typename _II1, typename _II2>
bool
lexicographical_compare(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2)
;
template<typename _II1, typename _II2, typename _Compare>
bool
lexicographical_compare(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2, _Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _BinaryPredicate>
pair<_InputIterator1, _InputIterator2>
__mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _BinaryPredicate __binary_pred)
;
template<typename _InputIterator1, typename _InputIterator2>
pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _BinaryPredicate>
pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _BinaryPredicate __binary_pred)
;
}
#define _GLIBCXX_POSTYPES_H 1
#define _WCHAR_H 1
#define __need___FILE
#define __need_FILE
struct _IO_FILE;
typedef struct _IO_FILE FILE;
#define __FILE_defined 1
#undef __need_FILE
typedef struct _IO_FILE __FILE;
#define ____FILE_defined 1
#undef __need___FILE
#define __need___va_list
#undef __need___va_list
#define __GNUC_VA_LIST
typedef __builtin_va_list __gnuc_va_list;
#define _BITS_WCHAR_H 1
#define __WCHAR_MAX __WCHAR_MAX__
#define __WCHAR_MIN __WCHAR_MIN__
#define __need_size_t
#define __need_wchar_t
#define __need_NULL
#undef __need_wint_t
#define __need_wint_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#define _WINT_T
typedef unsigned int wint_t;
#undef __need_wint_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define __CORRECT_ISO_CPP_WCHAR_H_PROTO
#define ____mbstate_t_defined 1
typedef struct
{
int __count;
union
{
unsigned int __wch;
char __wchb[4];
} __value;
} __mbstate_t;
#undef __need_mbstate_t
typedef __mbstate_t mbstate_t;
#define __mbstate_t_defined 1
#define WCHAR_MIN __WCHAR_MIN
#define WCHAR_MAX __WCHAR_MAX
#define WEOF (0xffffffffu)
extern "C" {
struct tm;
extern wchar_t *wcscpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src) throw ();
extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw ();
extern wchar_t *wcscat (wchar_t *__restrict __dest,
const wchar_t *__restrict __src) throw ();
extern wchar_t *wcsncat (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw ();
extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
throw () __attribute__ ((__pure__));
extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw () __attribute__ ((__pure__));
extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw ();
extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2,
size_t __n) throw ();
extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
__locale_t __loc) throw ();
extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
size_t __n, __locale_t __loc) throw ();
extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw ();
extern size_t wcsxfrm (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n) throw ();
extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2,
__locale_t __loc) throw ();
extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2,
size_t __n, __locale_t __loc) throw ();
extern wchar_t *wcsdup (const wchar_t *__s) throw () __attribute__ ((__malloc__));
extern "C++" wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcschr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcschr") __attribute__ ((__pure__));
extern "C++" wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcsrchr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcsrchr") __attribute__ ((__pure__));
extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc)
throw () __attribute__ ((__pure__));
extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject)
throw () __attribute__ ((__pure__));
extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept)
throw () __attribute__ ((__pure__));
extern "C++" wchar_t *wcspbrk (wchar_t *__wcs, const wchar_t *__accept)
throw () __asm ("wcspbrk") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcspbrk (const wchar_t *__wcs,
const wchar_t *__accept)
throw () __asm ("wcspbrk") __attribute__ ((__pure__));
extern "C++" wchar_t *wcsstr (wchar_t *__haystack, const wchar_t *__needle)
throw () __asm ("wcsstr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcsstr (const wchar_t *__haystack,
const wchar_t *__needle)
throw () __asm ("wcsstr") __attribute__ ((__pure__));
extern wchar_t *wcstok (wchar_t *__restrict __s,
const wchar_t *__restrict __delim,
wchar_t **__restrict __ptr) throw ();
extern size_t wcslen (const wchar_t *__s) throw () __attribute__ ((__pure__));
extern "C++" wchar_t *wcswcs (wchar_t *__haystack, const wchar_t *__needle)
throw () __asm ("wcswcs") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcswcs (const wchar_t *__haystack,
const wchar_t *__needle)
throw () __asm ("wcswcs") __attribute__ ((__pure__));
extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
throw () __attribute__ ((__pure__));
extern "C++" wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n)
throw () __asm ("wmemchr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wmemchr (const wchar_t *__s, wchar_t __c,
size_t __n)
throw () __asm ("wmemchr") __attribute__ ((__pure__));
extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw () __attribute__ ((__pure__));
extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n) throw ();
extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw ();
extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();
extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n)
throw ();
extern wint_t btowc (int __c) throw ();
extern int wctob (wint_t __c) throw ();
extern int mbsinit (const mbstate_t *__ps) throw () __attribute__ ((__pure__));
extern size_t mbrtowc (wchar_t *__restrict __pwc,
const char *__restrict __s, size_t __n,
mbstate_t *__restrict __p) throw ();
extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
mbstate_t *__restrict __ps) throw ();
extern size_t __mbrlen (const char *__restrict __s, size_t __n,
mbstate_t *__restrict __ps) throw ();
extern size_t mbrlen (const char *__restrict __s, size_t __n,
mbstate_t *__restrict __ps) throw ();
extern size_t mbsrtowcs (wchar_t *__restrict __dst,
const char **__restrict __src, size_t __len,
mbstate_t *__restrict __ps) throw ();
extern size_t wcsrtombs (char *__restrict __dst,
const wchar_t **__restrict __src, size_t __len,
mbstate_t *__restrict __ps) throw ();
extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
const char **__restrict __src, size_t __nmc,
size_t __len, mbstate_t *__restrict __ps) throw ();
extern size_t wcsnrtombs (char *__restrict __dst,
const wchar_t **__restrict __src,
size_t __nwc, size_t __len,
mbstate_t *__restrict __ps) throw ();
extern int wcwidth (wchar_t __c) throw ();
extern int wcswidth (const wchar_t *__s, size_t __n) throw ();
extern double wcstod (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern float wcstof (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern long double wcstold (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern long int wcstol (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base) throw ();
extern unsigned long int wcstoul (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
__extension__
extern long long int wcstoll (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
__extension__
extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base) throw ();
__extension__
extern long long int wcstoq (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
__extension__
extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base) throw ();
extern long int wcstol_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base,
__locale_t __loc) throw ();
extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, __locale_t __loc) throw ();
__extension__
extern long long int wcstoll_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, __locale_t __loc) throw ();
__extension__
extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, __locale_t __loc)
throw ();
extern double wcstod_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, __locale_t __loc)
throw ();
extern float wcstof_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, __locale_t __loc)
throw ();
extern long double wcstold_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
__locale_t __loc) throw ();
extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src) throw ();
extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw ();
extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();
extern int fwide (__FILE *__fp, int __mode) throw ();
extern int fwprintf (__FILE *__restrict __stream,
const wchar_t *__restrict __format, ...)
;
extern int wprintf (const wchar_t *__restrict __format, ...)
;
extern int swprintf (wchar_t *__restrict __s, size_t __n,
const wchar_t *__restrict __format, ...)
throw () ;
extern int vfwprintf (__FILE *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vwprintf (const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vswprintf (wchar_t *__restrict __s, size_t __n,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
throw () ;
extern int fwscanf (__FILE *__restrict __stream,
const wchar_t *__restrict __format, ...)
;
extern int wscanf (const wchar_t *__restrict __format, ...)
;
extern int swscanf (const wchar_t *__restrict __s,
const wchar_t *__restrict __format, ...)
throw () ;
extern int vfwscanf (__FILE *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vwscanf (const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vswscanf (const wchar_t *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
throw () ;
extern wint_t fgetwc (__FILE *__stream);
extern wint_t getwc (__FILE *__stream);
extern wint_t getwchar (void);
extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
extern wint_t putwc (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar (wchar_t __wc);
extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
__FILE *__restrict __stream);
extern int fputws (const wchar_t *__restrict __ws,
__FILE *__restrict __stream);
extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
extern wint_t getwc_unlocked (__FILE *__stream);
extern wint_t getwchar_unlocked (void);
extern wint_t fgetwc_unlocked (__FILE *__stream);
extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar_unlocked (wchar_t __wc);
extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
__FILE *__restrict __stream);
extern int fputws_unlocked (const wchar_t *__restrict __ws,
__FILE *__restrict __stream);
extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
const wchar_t *__restrict __format,
const struct tm *__restrict __tp) throw ();
extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
const wchar_t *__restrict __format,
const struct tm *__restrict __tp,
__locale_t __loc) throw ();
}
#undef __need_mbstate_t
#undef __need_wint_t
#define _GLIBCXX_CWCHAR 1
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;
}
#undef wcstold
#undef wcstoll
#undef wcstoull
namespace __gnu_cxx
{
using ::wcstold;
using ::wcstoll;
using ::wcstoull;
}
namespace std
{
using ::__gnu_cxx::wcstold;
using ::__gnu_cxx::wcstoll;
using ::__gnu_cxx::wcstoull;
}
namespace std
{
using std::wcstof;
using std::vfwscanf;
using std::vswscanf;
using std::vwscanf;
using std::wcstold;
using std::wcstoll;
using std::wcstoull;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
typedef long streamoff;
typedef ptrdiff_t streamsize;
template<typename _StateT>
class fpos
{
private:
streamoff _M_off;
_StateT _M_state;
public:
fpos() ;
fpos(streamoff __off) ;
operator streamoff() const ;
void
state(_StateT __st)
;
_StateT
state() const
;
fpos&
operator+=(streamoff __off)
;
fpos&
operator-=(streamoff __off)
;
fpos
operator+(streamoff __off) const
;
fpos
operator-(streamoff __off) const
;
streamoff
operator-(const fpos& __other) const
;
};
template<typename _StateT>
bool
operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
;
template<typename _StateT>
bool
operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
;
typedef fpos<mbstate_t> streampos;
typedef fpos<mbstate_t> wstreampos;
typedef fpos<mbstate_t> u16streampos;
typedef fpos<mbstate_t> u32streampos;
}
#undef __need_mbstate_t
#undef __need_wint_t
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
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;
};
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)
;
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()); }
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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)
{ 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)
{ 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)
{ return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n)); }
static char_type*
copy(char_type* __s1, const char_type* __s2, size_t __n)
{ return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n)); }
static char_type*
assign(char_type* __s, size_t __n, char_type __a)
{ return static_cast<char_type*>(__builtin_memset(__s, __a, __n)); }
static constexpr char_type
to_char_type(const int_type& __c) noexcept
{ return static_cast<char_type>(__c); }
static constexpr int_type
to_int_type(const char_type& __c) noexcept
{ return static_cast<int_type>(static_cast<unsigned char>(__c)); }
static constexpr bool
eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
{ return __c1 == __c2; }
static constexpr int_type
eof() noexcept
{ return static_cast<int_type>(-1); }
static constexpr int_type
not_eof(const int_type& __c) noexcept
{ return (__c == eof()) ? 0 : __c; }
};
template<>
struct char_traits<wchar_t>
{
typedef wchar_t char_type;
typedef wint_t int_type;
typedef streamoff off_type;
typedef wstreampos pos_type;
typedef mbstate_t state_type;
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)
{ 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)
{ return wmemchr(__s, __a, __n); }
static char_type*
move(char_type* __s1, const char_type* __s2, size_t __n)
{ return wmemmove(__s1, __s2, __n); }
static char_type*
copy(char_type* __s1, const char_type* __s2, size_t __n)
{ return wmemcpy(__s1, __s2, __n); }
static char_type*
assign(char_type* __s, size_t __n, char_type __a)
{ return wmemset(__s, __a, __n); }
static constexpr char_type
to_char_type(const int_type& __c) noexcept
{ return char_type(__c); }
static constexpr int_type
to_int_type(const char_type& __c) noexcept
{ return int_type(__c); }
static constexpr bool
eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
{ return __c1 == __c2; }
static constexpr int_type
eof() noexcept
{ return static_cast<int_type>((0xffffffffu)); }
static constexpr int_type
not_eof(const int_type& __c) noexcept
{ return eq_int_type(__c, eof()) ? 0 : __c; }
};
}
#define _GLIBCXX_CSTDINT 1
#undef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS
#undef __STDC_CONSTANT_MACROS
#define __STDC_CONSTANT_MACROS
#define _STDINT_H 1
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
typedef unsigned char uint8_t;
typedef unsigned short int uint16_t;
typedef unsigned int uint32_t;
#define __uint32_t_defined
typedef unsigned long int uint64_t;
typedef signed char int_least8_t;
typedef short int int_least16_t;
typedef int int_least32_t;
typedef long int int_least64_t;
typedef unsigned char uint_least8_t;
typedef unsigned short int uint_least16_t;
typedef unsigned int uint_least32_t;
typedef unsigned long int uint_least64_t;
typedef signed char int_fast8_t;
typedef long int int_fast16_t;
typedef long int int_fast32_t;
typedef long int int_fast64_t;
typedef unsigned char uint_fast8_t;
typedef unsigned long int uint_fast16_t;
typedef unsigned long int uint_fast32_t;
typedef unsigned long int uint_fast64_t;
typedef unsigned long int uintptr_t;
typedef long int intmax_t;
typedef unsigned long int uintmax_t;
#define __INT64_C(c) c ## L
#define __UINT64_C(c) c ## UL
#define INT8_MIN (-128)
#define INT16_MIN (-32767-1)
#define INT32_MIN (-2147483647-1)
#define INT64_MIN (-__INT64_C(9223372036854775807)-1)
#define INT8_MAX (127)
#define INT16_MAX (32767)
#define INT32_MAX (2147483647)
#define INT64_MAX (__INT64_C(9223372036854775807))
#define UINT8_MAX (255)
#define UINT16_MAX (65535)
#define UINT32_MAX (4294967295U)
#define UINT64_MAX (__UINT64_C(18446744073709551615))
#define INT_LEAST8_MIN (-128)
#define INT_LEAST16_MIN (-32767-1)
#define INT_LEAST32_MIN (-2147483647-1)
#define INT_LEAST64_MIN (-__INT64_C(9223372036854775807)-1)
#define INT_LEAST8_MAX (127)
#define INT_LEAST16_MAX (32767)
#define INT_LEAST32_MAX (2147483647)
#define INT_LEAST64_MAX (__INT64_C(9223372036854775807))
#define UINT_LEAST8_MAX (255)
#define UINT_LEAST16_MAX (65535)
#define UINT_LEAST32_MAX (4294967295U)
#define UINT_LEAST64_MAX (__UINT64_C(18446744073709551615))
#define INT_FAST8_MIN (-128)
#define INT_FAST16_MIN (-9223372036854775807L-1)
#define INT_FAST32_MIN (-9223372036854775807L-1)
#define INT_FAST64_MIN (-__INT64_C(9223372036854775807)-1)
#define INT_FAST8_MAX (127)
#define INT_FAST16_MAX (9223372036854775807L)
#define INT_FAST32_MAX (9223372036854775807L)
#define INT_FAST64_MAX (__INT64_C(9223372036854775807))
#define UINT_FAST8_MAX (255)
#define UINT_FAST16_MAX (18446744073709551615UL)
#define UINT_FAST32_MAX (18446744073709551615UL)
#define UINT_FAST64_MAX (__UINT64_C(18446744073709551615))
#define INTPTR_MIN (-9223372036854775807L-1)
#define INTPTR_MAX (9223372036854775807L)
#define UINTPTR_MAX (18446744073709551615UL)
#define INTMAX_MIN (-__INT64_C(9223372036854775807)-1)
#define INTMAX_MAX (__INT64_C(9223372036854775807))
#define UINTMAX_MAX (__UINT64_C(18446744073709551615))
#define PTRDIFF_MIN (-9223372036854775807L-1)
#define PTRDIFF_MAX (9223372036854775807L)
#define SIG_ATOMIC_MIN (-2147483647-1)
#define SIG_ATOMIC_MAX (2147483647)
#define SIZE_MAX (18446744073709551615UL)
#define WINT_MIN (0u)
#define WINT_MAX (4294967295u)
#define INT8_C(c) c
#define INT16_C(c) c
#define INT32_C(c) c
#define INT64_C(c) c ## L
#define UINT8_C(c) c
#define UINT16_C(c) c
#define UINT32_C(c) c ## U
#define UINT64_C(c) c ## UL
#define INTMAX_C(c) c ## L
#define UINTMAX_C(c) c ## UL
#define _GCC_WRAP_STDINT_H
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;
}
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)
{
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)
{
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)
{
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)
{
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; }
};
}
#define _ALLOCATOR_H 1
#define _GLIBCXX_CXX_ALLOCATOR_H 1
#define _MT_ALLOCATOR_H 1
#define _NEW
#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 { };
extern const nothrow_t nothrow;
typedef void (*new_handler)();
new_handler set_new_handler(new_handler) throw();
new_handler get_new_handler() noexcept;
}
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__));
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 { }
}
#pragma GCC visibility pop
#define _GLIBCXX_ATOMICITY_H 1
#define _GLIBCXX_GCC_GTHR_H
#pragma GCC visibility push(default)
#define _GLIBCXX_GTHREAD_USE_WEAK 1
#define _GLIBCXX_GCC_GTHR_POSIX_H
#define __GTHREADS 1
#define __GTHREADS_CXX0X 1
#define _PTHREAD_H 1
#define _SCHED_H 1
#define __need_size_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define __need_time_t
#define __need_timespec
#undef __need_clock_t
#undef __need_time_t
#undef __clockid_time_t
#undef __need_timer_t
#undef __need_timespec
#define SCHED_OTHER 0
#define SCHED_FIFO 1
#define SCHED_RR 2
#define SCHED_BATCH 3
#define SCHED_IDLE 5
#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_NEWUTS 0x04000000
#define CLONE_NEWIPC 0x08000000
#define CLONE_NEWUSER 0x10000000
#define CLONE_NEWPID 0x20000000
#define CLONE_NEWNET 0x40000000
#define CLONE_IO 0x80000000
struct sched_param
{
int __sched_priority;
};
extern "C" {
extern int clone (int (*__fn) (void *__arg), void *__child_stack,
int __flags, void *__arg, ...) throw ();
extern int unshare (int __flags) throw ();
extern int sched_getcpu (void) throw ();
extern int setns (int __fd, int __nstype) throw ();
}
#define __defined_schedparam 1
struct __sched_param
{
int __sched_priority;
};
#undef __need_schedparam
#define __cpu_set_t_defined
#define __CPU_SETSIZE 1024
#define __NCPUBITS (8 * sizeof (__cpu_mask))
typedef unsigned long int __cpu_mask;
#define __CPUELT(cpu) ((cpu) / __NCPUBITS)
#define __CPUMASK(cpu) ((__cpu_mask) 1 << ((cpu) % __NCPUBITS))
typedef struct
{
__cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
} cpu_set_t;
#define __CPU_ZERO_S(setsize,cpusetp) do __builtin_memset (cpusetp, '\0', setsize); while (0)
#define __CPU_SET_S(cpu,setsize,cpusetp) (__extension__ ({ size_t __cpu = (cpu); __cpu / 8 < (setsize) ? (((__cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] |= __CPUMASK (__cpu)) : 0; }))
#define __CPU_CLR_S(cpu,setsize,cpusetp) (__extension__ ({ size_t __cpu = (cpu); __cpu / 8 < (setsize) ? (((__cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] &= ~__CPUMASK (__cpu)) : 0; }))
#define __CPU_ISSET_S(cpu,setsize,cpusetp) (__extension__ ({ size_t __cpu = (cpu); __cpu / 8 < (setsize) ? ((((const __cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] & __CPUMASK (__cpu))) != 0 : 0; }))
#define __CPU_COUNT_S(setsize,cpusetp) __sched_cpucount (setsize, cpusetp)
#define __CPU_EQUAL_S(setsize,cpusetp1,cpusetp2) (__builtin_memcmp (cpusetp1, cpusetp2, setsize) == 0)
#define __CPU_OP_S(setsize,destset,srcset1,srcset2,op) (__extension__ ({ cpu_set_t *__dest = (destset); const __cpu_mask *__arr1 = (srcset1)->__bits; const __cpu_mask *__arr2 = (srcset2)->__bits; size_t __imax = (setsize) / sizeof (__cpu_mask); size_t __i; for (__i = 0; __i < __imax; ++__i) ((__cpu_mask *) __dest->__bits)[__i] = __arr1[__i] op __arr2[__i]; __dest; }))
#define __CPU_ALLOC_SIZE(count) ((((count) + __NCPUBITS - 1) / __NCPUBITS) * sizeof (__cpu_mask))
#define __CPU_ALLOC(count) __sched_cpualloc (count)
#define __CPU_FREE(cpuset) __sched_cpufree (cpuset)
extern "C" {
extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
throw ();
extern cpu_set_t *__sched_cpualloc (size_t __count) throw () ;
extern void __sched_cpufree (cpu_set_t *__set) throw ();
}
#define sched_priority __sched_priority
extern "C" {
extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
throw ();
extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();
extern int sched_setscheduler (__pid_t __pid, int __policy,
const struct sched_param *__param) throw ();
extern int sched_getscheduler (__pid_t __pid) throw ();
extern int sched_yield (void) throw ();
extern int sched_get_priority_max (int __algorithm) throw ();
extern int sched_get_priority_min (int __algorithm) throw ();
extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();
#define CPU_SETSIZE __CPU_SETSIZE
#define CPU_SET(cpu,cpusetp) __CPU_SET_S (cpu, sizeof (cpu_set_t), cpusetp)
#define CPU_CLR(cpu,cpusetp) __CPU_CLR_S (cpu, sizeof (cpu_set_t), cpusetp)
#define CPU_ISSET(cpu,cpusetp) __CPU_ISSET_S (cpu, sizeof (cpu_set_t), cpusetp)
#define CPU_ZERO(cpusetp) __CPU_ZERO_S (sizeof (cpu_set_t), cpusetp)
#define CPU_COUNT(cpusetp) __CPU_COUNT_S (sizeof (cpu_set_t), cpusetp)
#define CPU_SET_S(cpu,setsize,cpusetp) __CPU_SET_S (cpu, setsize, cpusetp)
#define CPU_CLR_S(cpu,setsize,cpusetp) __CPU_CLR_S (cpu, setsize, cpusetp)
#define CPU_ISSET_S(cpu,setsize,cpusetp) __CPU_ISSET_S (cpu, setsize, cpusetp)
#define CPU_ZERO_S(setsize,cpusetp) __CPU_ZERO_S (setsize, cpusetp)
#define CPU_COUNT_S(setsize,cpusetp) __CPU_COUNT_S (setsize, cpusetp)
#define CPU_EQUAL(cpusetp1,cpusetp2) __CPU_EQUAL_S (sizeof (cpu_set_t), cpusetp1, cpusetp2)
#define CPU_EQUAL_S(setsize,cpusetp1,cpusetp2) __CPU_EQUAL_S (setsize, cpusetp1, cpusetp2)
#define CPU_AND(destset,srcset1,srcset2) __CPU_OP_S (sizeof (cpu_set_t), destset, srcset1, srcset2, &)
#define CPU_OR(destset,srcset1,srcset2) __CPU_OP_S (sizeof (cpu_set_t), destset, srcset1, srcset2, |)
#define CPU_XOR(destset,srcset1,srcset2) __CPU_OP_S (sizeof (cpu_set_t), destset, srcset1, srcset2, ^)
#define CPU_AND_S(setsize,destset,srcset1,srcset2) __CPU_OP_S (setsize, destset, srcset1, srcset2, &)
#define CPU_OR_S(setsize,destset,srcset1,srcset2) __CPU_OP_S (setsize, destset, srcset1, srcset2, |)
#define CPU_XOR_S(setsize,destset,srcset1,srcset2) __CPU_OP_S (setsize, destset, srcset1, srcset2, ^)
#define CPU_ALLOC_SIZE(count) __CPU_ALLOC_SIZE (count)
#define CPU_ALLOC(count) __CPU_ALLOC (count)
#define CPU_FREE(cpuset) __CPU_FREE (cpuset)
extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
const cpu_set_t *__cpuset) throw ();
extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
cpu_set_t *__cpuset) throw ();
}
#define _TIME_H 1
extern "C" {
#define __need_size_t
#define __need_NULL
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define _BITS_TIME_H 1
#define CLOCKS_PER_SEC 1000000l
#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 TIMER_ABSTIME 1
#define _BITS_TIMEX_H 1
struct timex
{
unsigned int modes;
__syscall_slong_t offset;
__syscall_slong_t freq;
__syscall_slong_t maxerror;
__syscall_slong_t esterror;
int status;
__syscall_slong_t constant;
__syscall_slong_t precision;
__syscall_slong_t tolerance;
struct timeval time;
__syscall_slong_t tick;
__syscall_slong_t ppsfreq;
__syscall_slong_t jitter;
int shift;
__syscall_slong_t stabil;
__syscall_slong_t jitcnt;
__syscall_slong_t calcnt;
__syscall_slong_t errcnt;
__syscall_slong_t stbcnt;
int tai;
int :32; int :32; int :32; int :32;
int :32; int :32; int :32; int :32;
int :32; int :32; int :32;
};
#define ADJ_OFFSET 0x0001
#define ADJ_FREQUENCY 0x0002
#define ADJ_MAXERROR 0x0004
#define ADJ_ESTERROR 0x0008
#define ADJ_STATUS 0x0010
#define ADJ_TIMECONST 0x0020
#define ADJ_TAI 0x0080
#define ADJ_MICRO 0x1000
#define ADJ_NANO 0x2000
#define ADJ_TICK 0x4000
#define ADJ_OFFSET_SINGLESHOT 0x8001
#define ADJ_OFFSET_SS_READ 0xa001
#define MOD_OFFSET ADJ_OFFSET
#define MOD_FREQUENCY ADJ_FREQUENCY
#define MOD_MAXERROR ADJ_MAXERROR
#define MOD_ESTERROR ADJ_ESTERROR
#define MOD_STATUS ADJ_STATUS
#define MOD_TIMECONST ADJ_TIMECONST
#define MOD_CLKB ADJ_TICK
#define MOD_CLKA ADJ_OFFSET_SINGLESHOT
#define MOD_TAI ADJ_TAI
#define MOD_MICRO ADJ_MICRO
#define MOD_NANO ADJ_NANO
#define STA_PLL 0x0001
#define STA_PPSFREQ 0x0002
#define STA_PPSTIME 0x0004
#define STA_FLL 0x0008
#define STA_INS 0x0010
#define STA_DEL 0x0020
#define STA_UNSYNC 0x0040
#define STA_FREQHOLD 0x0080
#define STA_PPSSIGNAL 0x0100
#define STA_PPSJITTER 0x0200
#define STA_PPSWANDER 0x0400
#define STA_PPSERROR 0x0800
#define STA_CLOCKERR 0x1000
#define STA_NANO 0x2000
#define STA_MODE 0x4000
#define STA_CLK 0x8000
#define STA_RONLY (STA_PPSSIGNAL | STA_PPSJITTER | STA_PPSWANDER | STA_PPSERROR | STA_CLOCKERR | STA_NANO | STA_MODE | STA_CLK)
extern "C" {
extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw ();
}
#undef __need_timeval
#undef __need_clock_t
#undef __need_time_t
#undef __clockid_time_t
#undef __need_timer_t
#undef __need_timespec
struct tm
{
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
long int tm_gmtoff;
const char *tm_zone;
};
struct itimerspec
{
struct timespec it_interval;
struct timespec it_value;
};
struct sigevent;
#define TIME_UTC 1
extern clock_t clock (void) throw ();
extern time_t time (time_t *__timer) throw ();
extern double difftime (time_t __time1, time_t __time0)
throw () __attribute__ ((__const__));
extern time_t mktime (struct tm *__tp) throw ();
extern size_t strftime (char *__restrict __s, size_t __maxsize,
const char *__restrict __format,
const struct tm *__restrict __tp) throw ();
extern char *strptime (const char *__restrict __s,
const char *__restrict __fmt, struct tm *__tp)
throw ();
extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
const char *__restrict __format,
const struct tm *__restrict __tp,
__locale_t __loc) throw ();
extern char *strptime_l (const char *__restrict __s,
const char *__restrict __fmt, struct tm *__tp,
__locale_t __loc) throw ();
extern struct tm *gmtime (const time_t *__timer) throw ();
extern struct tm *localtime (const time_t *__timer) throw ();
extern struct tm *gmtime_r (const time_t *__restrict __timer,
struct tm *__restrict __tp) throw ();
extern struct tm *localtime_r (const time_t *__restrict __timer,
struct tm *__restrict __tp) throw ();
extern char *asctime (const struct tm *__tp) throw ();
extern char *ctime (const time_t *__timer) throw ();
extern char *asctime_r (const struct tm *__restrict __tp,
char *__restrict __buf) throw ();
extern char *ctime_r (const time_t *__restrict __timer,
char *__restrict __buf) throw ();
extern char *__tzname[2];
extern int __daylight;
extern long int __timezone;
extern char *tzname[2];
extern void tzset (void) throw ();
extern int daylight;
extern long int timezone;
extern int stime (const time_t *__when) throw ();
#define __isleap(year) ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
extern time_t timegm (struct tm *__tp) throw ();
extern time_t timelocal (struct tm *__tp) throw ();
extern int dysize (int __year) throw () __attribute__ ((__const__));
extern int nanosleep (const struct timespec *__requested_time,
struct timespec *__remaining);
extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();
extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();
extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
throw ();
extern int clock_nanosleep (clockid_t __clock_id, int __flags,
const struct timespec *__req,
struct timespec *__rem);
extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();
extern int timer_create (clockid_t __clock_id,
struct sigevent *__restrict __evp,
timer_t *__restrict __timerid) throw ();
extern int timer_delete (timer_t __timerid) throw ();
extern int timer_settime (timer_t __timerid, int __flags,
const struct itimerspec *__restrict __value,
struct itimerspec *__restrict __ovalue) throw ();
extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
throw ();
extern int timer_getoverrun (timer_t __timerid) throw ();
extern int timespec_get (struct timespec *__ts, int __base)
throw () __attribute__ ((__nonnull__ (1)));
extern int getdate_err;
extern struct tm *getdate (const char *__string);
extern int getdate_r (const char *__restrict __string,
struct tm *__restrict __resbufp);
}
#define _BITS_SETJMP_H 1
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
typedef long int __jmp_buf[8];
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
enum
{
PTHREAD_CREATE_JOINABLE,
#define PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_JOINABLE
PTHREAD_CREATE_DETACHED
#define PTHREAD_CREATE_DETACHED PTHREAD_CREATE_DETACHED
};
enum
{
PTHREAD_MUTEX_TIMED_NP,
PTHREAD_MUTEX_RECURSIVE_NP,
PTHREAD_MUTEX_ERRORCHECK_NP,
PTHREAD_MUTEX_ADAPTIVE_NP
,
PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
, PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP
};
enum
{
PTHREAD_MUTEX_STALLED,
PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED,
PTHREAD_MUTEX_ROBUST,
PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST
};
enum
{
PTHREAD_PRIO_NONE,
PTHREAD_PRIO_INHERIT,
PTHREAD_PRIO_PROTECT
};
#define __PTHREAD_SPINS 0, 0
#define PTHREAD_MUTEX_INITIALIZER { { 0, 0, 0, 0, 0, __PTHREAD_SPINS, { 0, 0 } } }
#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP { { 0, 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, __PTHREAD_SPINS, { 0, 0 } } }
#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP { { 0, 0, 0, 0, PTHREAD_MUTEX_ERRORCHECK_NP, __PTHREAD_SPINS, { 0, 0 } } }
#define PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP { { 0, 0, 0, 0, PTHREAD_MUTEX_ADAPTIVE_NP, __PTHREAD_SPINS, { 0, 0 } } }
#define PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP { { 0, 0, 0, 0, PTHREAD_MUTEX_ADAPTIVE_NP, __PTHREAD_SPINS, { 0, 0 } } }
enum
{
PTHREAD_RWLOCK_PREFER_READER_NP,
PTHREAD_RWLOCK_PREFER_WRITER_NP,
PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP
};
#define PTHREAD_RWLOCK_INITIALIZER { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }
#define PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP } }
enum
{
PTHREAD_INHERIT_SCHED,
#define PTHREAD_INHERIT_SCHED PTHREAD_INHERIT_SCHED
PTHREAD_EXPLICIT_SCHED
#define PTHREAD_EXPLICIT_SCHED PTHREAD_EXPLICIT_SCHED
};
enum
{
PTHREAD_SCOPE_SYSTEM,
#define PTHREAD_SCOPE_SYSTEM PTHREAD_SCOPE_SYSTEM
PTHREAD_SCOPE_PROCESS
#define PTHREAD_SCOPE_PROCESS PTHREAD_SCOPE_PROCESS
};
enum
{
PTHREAD_PROCESS_PRIVATE,
#define PTHREAD_PROCESS_PRIVATE PTHREAD_PROCESS_PRIVATE
PTHREAD_PROCESS_SHARED
#define PTHREAD_PROCESS_SHARED PTHREAD_PROCESS_SHARED
};
#define PTHREAD_COND_INITIALIZER { { 0, 0, 0, 0, 0, (void *) 0, 0, 0 } }
struct _pthread_cleanup_buffer
{
void (*__routine) (void *);
void *__arg;
int __canceltype;
struct _pthread_cleanup_buffer *__prev;
};
enum
{
PTHREAD_CANCEL_ENABLE,
#define PTHREAD_CANCEL_ENABLE PTHREAD_CANCEL_ENABLE
PTHREAD_CANCEL_DISABLE
#define PTHREAD_CANCEL_DISABLE PTHREAD_CANCEL_DISABLE
};
enum
{
PTHREAD_CANCEL_DEFERRED,
#define PTHREAD_CANCEL_DEFERRED PTHREAD_CANCEL_DEFERRED
PTHREAD_CANCEL_ASYNCHRONOUS
#define PTHREAD_CANCEL_ASYNCHRONOUS PTHREAD_CANCEL_ASYNCHRONOUS
};
#define PTHREAD_CANCELED ((void *) -1)
#define PTHREAD_ONCE_INIT 0
#define PTHREAD_BARRIER_SERIAL_THREAD -1
extern "C" {
extern int pthread_create (pthread_t *__restrict __newthread,
const pthread_attr_t *__restrict __attr,
void *(*__start_routine) (void *),
void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3)));
extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));
extern int pthread_join (pthread_t __th, void **__thread_return);
extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();
extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
const struct timespec *__abstime);
extern int pthread_detach (pthread_t __th) throw ();
extern pthread_t pthread_self (void) throw () __attribute__ ((__const__));
extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
throw () __attribute__ ((__const__));
extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_destroy (pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
int *__detachstate)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
int __detachstate)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
size_t *__guardsize)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
size_t __guardsize)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
struct sched_param *__restrict __param)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
const struct sched_param *__restrict
__param) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
__attr, int *__restrict __policy)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
__attr, int *__restrict __inherit)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
int __inherit)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
int *__restrict __scope)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
__attr, void **__restrict __stackaddr)
throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));
extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
void *__stackaddr)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));
extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
__attr, size_t *__restrict __stacksize)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
size_t __stacksize)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
void **__restrict __stackaddr,
size_t *__restrict __stacksize)
throw () __attribute__ ((__nonnull__ (1, 2, 3)));
extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
size_t __stacksize) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
size_t __cpusetsize,
const cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
size_t __cpusetsize,
cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern int pthread_getattr_default_np (pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_setattr_default_np (const pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (2)));
extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
const struct sched_param *__param)
throw () __attribute__ ((__nonnull__ (3)));
extern int pthread_getschedparam (pthread_t __target_thread,
int *__restrict __policy,
struct sched_param *__restrict __param)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
throw ();
extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
size_t __buflen)
throw () __attribute__ ((__nonnull__ (2)));
extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
throw () __attribute__ ((__nonnull__ (2)));
extern int pthread_getconcurrency (void) throw ();
extern int pthread_setconcurrency (int __level) throw ();
extern int pthread_yield (void) throw ();
extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
const cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (3)));
extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (3)));
extern int pthread_once (pthread_once_t *__once_control,
void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_setcancelstate (int __state, int *__oldstate);
extern int pthread_setcanceltype (int __type, int *__oldtype);
extern int pthread_cancel (pthread_t __th);
extern void pthread_testcancel (void);
typedef struct
{
struct
{
__jmp_buf __cancel_jmp_buf;
int __mask_was_saved;
} __cancel_jmp_buf[1];
void *__pad[4];
} __pthread_unwind_buf_t __attribute__ ((__aligned__));
#define __cleanup_fct_attribute
struct __pthread_cleanup_frame
{
void (*__cancel_routine) (void *);
void *__cancel_arg;
int __do_it;
int __cancel_type;
};
class __pthread_cleanup_class
{
void (*__cancel_routine) (void *);
void *__cancel_arg;
int __do_it;
int __cancel_type;
public:
__pthread_cleanup_class (void (*__fct) (void *), void *__arg) ;
~__pthread_cleanup_class () ;
void __setdoit (int __newval) ;
void __defer () ;
void __restore () const ;
};
#define pthread_cleanup_push(routine,arg) do { __pthread_cleanup_class __clframe (routine, arg)
#define pthread_cleanup_pop(execute) __clframe.__setdoit (execute); } while (0)
#define pthread_cleanup_push_defer_np(routine,arg) do { __pthread_cleanup_class __clframe (routine, arg); __clframe.__defer ()
#define pthread_cleanup_pop_restore_np(execute) __clframe.__restore (); __clframe.__setdoit (execute); } while (0)
struct __jmp_buf_tag;
extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();
extern int pthread_mutex_init (pthread_mutex_t *__mutex,
const pthread_mutexattr_t *__mutexattr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
const struct timespec *__restrict
__abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
__restrict __mutex,
int *__restrict __prioceiling)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
int __prioceiling,
int *__restrict __old_ceiling)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
__attr, int *__restrict __kind)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
__restrict __attr,
int *__restrict __protocol)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
int __protocol)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
__restrict __attr,
int *__restrict __prioceiling)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
int __prioceiling)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
int *__robustness)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
int *__robustness)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
int __robustness)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
int __robustness)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
const pthread_rwlockattr_t *__restrict
__attr) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
const struct timespec *__restrict
__abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
const struct timespec *__restrict
__abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
__restrict __attr,
int *__restrict __pref)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
int __pref) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
const pthread_condattr_t *__restrict __cond_attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_destroy (pthread_cond_t *__cond)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_signal (pthread_cond_t *__cond)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_broadcast (pthread_cond_t *__cond)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
pthread_mutex_t *__restrict __mutex)
__attribute__ ((__nonnull__ (1, 2)));
extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
pthread_mutex_t *__restrict __mutex,
const struct timespec *__restrict __abstime)
__attribute__ ((__nonnull__ (1, 2, 3)));
extern int pthread_condattr_init (pthread_condattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_condattr_getpshared (const pthread_condattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
int __pshared) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_condattr_getclock (const pthread_condattr_t *
__restrict __attr,
__clockid_t *__restrict __clock_id)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
__clockid_t __clock_id)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_lock (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
const pthread_barrierattr_t *__restrict
__attr, unsigned int __count)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_key_create (pthread_key_t *__key,
void (*__destr_function) (void *))
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_key_delete (pthread_key_t __key) throw ();
extern void *pthread_getspecific (pthread_key_t __key) throw ();
extern int pthread_setspecific (pthread_key_t __key,
const void *__pointer) throw () ;
extern int pthread_getcpuclockid (pthread_t __thread_id,
__clockid_t *__clock_id)
throw () __attribute__ ((__nonnull__ (2)));
extern int pthread_atfork (void (*__prepare) (void),
void (*__parent) (void),
void (*__child) (void)) throw ();
}
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 PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
#define __GTHREAD_COND_INIT PTHREAD_COND_INITIALIZER
#define __GTHREAD_TIME_INIT {0,0}
#define __gthrw_pragma(pragma)
#define __gthrw2(name,name2,type) static __typeof(type) name __attribute__ ((__weakref__(#name2))); __gthrw_pragma(weak type)
#define __gthrw_(name) __gthrw_ ## name
#define __gthrw(name) __gthrw2(__gthrw_ ## name,name,name)
static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once")));
static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific")));
static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific")));
static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create")));
static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join")));
static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal")));
static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self")));
static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach")));
static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel")));
static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield")));
static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock")));
static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock")));
static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock")));
static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock")));
static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init")));
static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy")));
static __typeof(pthread_cond_init) __gthrw_pthread_cond_init __attribute__ ((__weakref__("pthread_cond_init")));
static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast")));
static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal")));
static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait")));
static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait")));
static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy")));
static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create")));
static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete")));
static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init")));
static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype")));
static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy")));
static __typeof(pthread_key_create) __gthrw___pthread_key_create __attribute__ ((__weakref__("__pthread_key_create")));
#define GTHR_ACTIVE_PROXY __gthrw_(__pthread_key_create)
static int
__gthread_active_p (void)
;
static int
__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
void *__args)
;
static int
__gthread_join (__gthread_t __threadid, void **__value_ptr)
;
static int
__gthread_detach (__gthread_t __threadid)
;
static int
__gthread_equal (__gthread_t __t1, __gthread_t __t2)
;
static __gthread_t
__gthread_self (void)
;
static int
__gthread_yield (void)
;
static int
__gthread_once (__gthread_once_t *__once, void (*__func) (void))
;
static int
__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
;
static int
__gthread_key_delete (__gthread_key_t __key)
;
static void *
__gthread_getspecific (__gthread_key_t __key)
;
static int
__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
;
static void
__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
;
static int
__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
;
static int
__gthread_mutex_lock (__gthread_mutex_t *__mutex)
;
static int
__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
;
static int
__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
const __gthread_time_t *__abs_timeout)
;
static int
__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
;
static int
__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
;
static int
__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
;
static int
__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
const __gthread_time_t *__abs_timeout)
;
static int
__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
;
static int
__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
;
static int
__gthread_cond_broadcast (__gthread_cond_t *__cond)
;
static int
__gthread_cond_signal (__gthread_cond_t *__cond)
;
static int
__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
;
static int
__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
const __gthread_time_t *__abs_timeout)
;
static int
__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
__gthread_recursive_mutex_t *__mutex)
;
static int
__gthread_cond_destroy (__gthread_cond_t* __cond)
;
#pragma GCC visibility pop
#define _GLIBCXX_ATOMIC_WORD_H 1
typedef int _Atomic_word;
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
static _Atomic_word
__exchange_and_add(volatile _Atomic_word* __mem, int __val)
;
static void
__atomic_add(volatile _Atomic_word* __mem, int __val)
;
static _Atomic_word
__exchange_and_add_single(_Atomic_word* __mem, int __val)
;
static void
__atomic_add_single(_Atomic_word* __mem, int __val)
;
static _Atomic_word
__attribute__ ((__unused__))
__exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
;
static void
__attribute__ ((__unused__))
__atomic_add_dispatch(_Atomic_word* __mem, int __val)
;
}
#define _GLIBCXX_READ_MEM_BARRIER __asm __volatile ("":::"memory")
#define _GLIBCXX_WRITE_MEM_BARRIER __asm __volatile ("":::"memory")
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
using std::size_t;
using std::ptrdiff_t;
typedef void (*__destroy_handler)(void*);
struct __pool_base
{
typedef unsigned short int _Binmap_type;
struct _Tune
{
enum { _S_align = 8 };
enum { _S_max_bytes = 128 };
enum { _S_min_bin = 8 };
enum { _S_chunk_size = 4096 - 4 * sizeof(void*) };
enum { _S_max_threads = 4096 };
enum { _S_freelist_headroom = 10 };
size_t _M_align;
size_t _M_max_bytes;
size_t _M_min_bin;
size_t _M_chunk_size;
size_t _M_max_threads;
size_t _M_freelist_headroom;
bool _M_force_new;
explicit
_Tune()
;
explicit
_Tune(size_t __align, size_t __maxb, size_t __minbin, size_t __chunk,
size_t __maxthreads, size_t __headroom, bool __force)
;
};
struct _Block_address
{
void* _M_initial;
_Block_address* _M_next;
};
const _Tune&
_M_get_options() const
;
void
_M_set_options(_Tune __t)
;
bool
_M_check_threshold(size_t __bytes)
;
size_t
_M_get_binmap(size_t __bytes)
;
size_t
_M_get_align()
;
explicit
__pool_base() ;
explicit
__pool_base(const _Tune& __options) ;
private:
explicit
__pool_base(const __pool_base&);
__pool_base&
operator=(const __pool_base&);
protected:
_Tune _M_options;
_Binmap_type* _M_binmap;
bool _M_init;
};
template<bool _Thread>
class __pool;
template<>
class __pool<false> : public __pool_base
{
public:
union _Block_record
{
_Block_record* _M_next;
};
struct _Bin_record
{
_Block_record** _M_first;
_Block_address* _M_address;
};
void
_M_initialize_once()
;
void
_M_destroy() throw();
char*
_M_reserve_block(size_t __bytes, const size_t __thread_id);
void
_M_reclaim_block(char* __p, size_t __bytes) throw ();
size_t
_M_get_thread_id() ;
const _Bin_record&
_M_get_bin(size_t __which)
;
void
_M_adjust_freelist(const _Bin_record&, _Block_record*, size_t)
;
explicit __pool() ;
explicit __pool(const __pool_base::_Tune& __tune) ;
private:
_Bin_record* _M_bin;
size_t _M_bin_size;
void
_M_initialize();
};
template<>
class __pool<true> : public __pool_base
{
public:
struct _Thread_record
{
_Thread_record* _M_next;
size_t _M_id;
};
union _Block_record
{
_Block_record* _M_next;
size_t _M_thread_id;
};
struct _Bin_record
{
_Block_record** _M_first;
_Block_address* _M_address;
size_t* _M_free;
size_t* _M_used;
__gthread_mutex_t* _M_mutex;
};
void
_M_initialize(__destroy_handler);
void
_M_initialize_once()
;
void
_M_destroy() throw();
char*
_M_reserve_block(size_t __bytes, const size_t __thread_id);
void
_M_reclaim_block(char* __p, size_t __bytes) throw ();
const _Bin_record&
_M_get_bin(size_t __which)
;
void
_M_adjust_freelist(const _Bin_record& __bin, _Block_record* __block,
size_t __thread_id)
;
__attribute__ ((__const__)) void
_M_destroy_thread_key(void*) throw ();
size_t
_M_get_thread_id();
explicit __pool()
;
explicit __pool(const __pool_base::_Tune& __tune)
;
private:
_Bin_record* _M_bin;
size_t _M_bin_size;
_Thread_record* _M_thread_freelist;
void* _M_thread_freelist_initial;
void
_M_initialize();
};
template<template <bool> class _PoolTp, bool _Thread>
struct __common_pool
{
typedef _PoolTp<_Thread> pool_type;
static pool_type&
_S_get_pool()
;
};
template<template <bool> class _PoolTp, bool _Thread>
struct __common_pool_base;
template<template <bool> class _PoolTp>
struct __common_pool_base<_PoolTp, false>
: public __common_pool<_PoolTp, false>
{
using __common_pool<_PoolTp, false>::_S_get_pool;
static void
_S_initialize_once()
;
};
template<template <bool> class _PoolTp>
struct __common_pool_base<_PoolTp, true>
: public __common_pool<_PoolTp, true>
{
using __common_pool<_PoolTp, true>::_S_get_pool;
static void
_S_initialize()
;
static void
_S_initialize_once()
;
};
template<template <bool> class _PoolTp, bool _Thread>
struct __common_pool_policy : public __common_pool_base<_PoolTp, _Thread>
{
template<typename _Tp1, template <bool> class _PoolTp1 = _PoolTp,
bool _Thread1 = _Thread>
struct _M_rebind
{ typedef __common_pool_policy<_PoolTp1, _Thread1> other; };
using __common_pool_base<_PoolTp, _Thread>::_S_get_pool;
using __common_pool_base<_PoolTp, _Thread>::_S_initialize_once;
};
template<typename _Tp, template <bool> class _PoolTp, bool _Thread>
struct __per_type_pool
{
typedef _Tp value_type;
typedef _PoolTp<_Thread> pool_type;
static pool_type&
_S_get_pool()
;
};
template<typename _Tp, template <bool> class _PoolTp, bool _Thread>
struct __per_type_pool_base;
template<typename _Tp, template <bool> class _PoolTp>
struct __per_type_pool_base<_Tp, _PoolTp, false>
: public __per_type_pool<_Tp, _PoolTp, false>
{
using __per_type_pool<_Tp, _PoolTp, false>::_S_get_pool;
static void
_S_initialize_once()
;
};
template<typename _Tp, template <bool> class _PoolTp>
struct __per_type_pool_base<_Tp, _PoolTp, true>
: public __per_type_pool<_Tp, _PoolTp, true>
{
using __per_type_pool<_Tp, _PoolTp, true>::_S_get_pool;
static void
_S_initialize()
;
static void
_S_initialize_once()
;
};
template<typename _Tp, template <bool> class _PoolTp, bool _Thread>
struct __per_type_pool_policy
: public __per_type_pool_base<_Tp, _PoolTp, _Thread>
{
template<typename _Tp1, template <bool> class _PoolTp1 = _PoolTp,
bool _Thread1 = _Thread>
struct _M_rebind
{ typedef __per_type_pool_policy<_Tp1, _PoolTp1, _Thread1> other; };
using __per_type_pool_base<_Tp, _PoolTp, _Thread>::_S_get_pool;
using __per_type_pool_base<_Tp, _PoolTp, _Thread>::_S_initialize_once;
};
template<typename _Tp>
class __mt_alloc_base
{
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;
typedef std::true_type propagate_on_container_move_assignment;
pointer
address(reference __x) const noexcept
{ return std::__addressof(__x); }
const_pointer
address(const_reference __x) const noexcept
{ return std::__addressof(__x); }
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(); }
};
#define __thread_default true
template<typename _Tp,
typename _Poolp = __common_pool_policy<__pool, true> >
class __mt_alloc : public __mt_alloc_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;
typedef _Poolp __policy_type;
typedef typename _Poolp::pool_type __pool_type;
template<typename _Tp1, typename _Poolp1 = _Poolp>
struct rebind
{
typedef typename _Poolp1::template _M_rebind<_Tp1>::other pol_type;
typedef __mt_alloc<_Tp1, pol_type> other;
};
__mt_alloc() noexcept { }
__mt_alloc(const __mt_alloc&) noexcept { }
template<typename _Tp1, typename _Poolp1>
__mt_alloc(const __mt_alloc<_Tp1, _Poolp1>&) noexcept { }
~__mt_alloc() noexcept { }
pointer
allocate(size_type __n, const void* = 0);
void
deallocate(pointer __p, size_type __n);
const __pool_base::_Tune
_M_get_options()
;
void
_M_set_options(__pool_base::_Tune __t)
;
};
template<typename _Tp, typename _Poolp>
bool
operator==(const __mt_alloc<_Tp, _Poolp>&, const __mt_alloc<_Tp, _Poolp>&)
;
template<typename _Tp, typename _Poolp>
bool
operator!=(const __mt_alloc<_Tp, _Poolp>&, const __mt_alloc<_Tp, _Poolp>&)
;
#undef __thread_default
}
namespace std
{
template<typename _Tp>
using __allocator_base = __gnu_cxx::__mt_alloc<_Tp>;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<>
class allocator<void>
{
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef void* pointer;
typedef const void* const_pointer;
typedef void value_type;
template<typename _Tp1>
struct rebind
{ typedef allocator<_Tp1> other; };
typedef true_type propagate_on_container_move_assignment;
};
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;
allocator() throw() ;
allocator(const allocator& __a) throw() ;
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&)
;
};
template<typename _Alloc>
struct __alloc_neq<_Alloc, false>
{
static bool
_S_do_it(const _Alloc& __one, const _Alloc& __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; }
}
};
}
#define _LOCALE_FWD_H 1
#define _GLIBCXX_CXX_LOCALE_H 1
#define _LOCALE_H 1
#define __need_NULL
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define _BITS_LOCALE_H 1
#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
#define __LC_PAPER 7
#define __LC_NAME 8
#define __LC_ADDRESS 9
#define __LC_TELEPHONE 10
#define __LC_MEASUREMENT 11
#define __LC_IDENTIFICATION 12
extern "C" {
#define LC_CTYPE __LC_CTYPE
#define LC_NUMERIC __LC_NUMERIC
#define LC_TIME __LC_TIME
#define LC_COLLATE __LC_COLLATE
#define LC_MONETARY __LC_MONETARY
#define LC_MESSAGES __LC_MESSAGES
#define LC_ALL __LC_ALL
#define LC_PAPER __LC_PAPER
#define LC_NAME __LC_NAME
#define LC_ADDRESS __LC_ADDRESS
#define LC_TELEPHONE __LC_TELEPHONE
#define LC_MEASUREMENT __LC_MEASUREMENT
#define LC_IDENTIFICATION __LC_IDENTIFICATION
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;
};
extern char *setlocale (int __category, const char *__locale) throw ();
extern struct lconv *localeconv (void) throw ();
extern __locale_t newlocale (int __category_mask, const char *__locale,
__locale_t __base) throw ();
#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_PAPER_MASK (1 << __LC_PAPER)
#define LC_NAME_MASK (1 << __LC_NAME)
#define LC_ADDRESS_MASK (1 << __LC_ADDRESS)
#define LC_TELEPHONE_MASK (1 << __LC_TELEPHONE)
#define LC_MEASUREMENT_MASK (1 << __LC_MEASUREMENT)
#define LC_IDENTIFICATION_MASK (1 << __LC_IDENTIFICATION)
#define LC_ALL_MASK (LC_CTYPE_MASK | LC_NUMERIC_MASK | LC_TIME_MASK | LC_COLLATE_MASK | LC_MONETARY_MASK | LC_MESSAGES_MASK | LC_PAPER_MASK | LC_NAME_MASK | LC_ADDRESS_MASK | LC_TELEPHONE_MASK | LC_MEASUREMENT_MASK | LC_IDENTIFICATION_MASK )
extern __locale_t duplocale (__locale_t __dataset) throw ();
extern void freelocale (__locale_t __dataset) throw ();
extern __locale_t uselocale (__locale_t __dataset) throw ();
#define LC_GLOBAL_LOCALE ((__locale_t) -1L)
}
#define _GLIBCXX_CLOCALE 1
#undef setlocale
#undef localeconv
namespace std
{
using ::lconv;
using ::setlocale;
using ::localeconv;
}
#define _GLIBCXX_C_LOCALE_GNU 1
#define _GLIBCXX_NUM_CATEGORIES 6
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
extern "C" __typeof(uselocale) __uselocale;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
typedef __locale_t __c_locale;
int
__convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
char* __out,
const int __size __attribute__ ((__unused__)),
const char* __fmt, ...)
;
}
#define _GLIBCXX_IOSFWD 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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;
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;
}
#define _CTYPE_H 1
extern "C" {
#define _ISbit(bit) ((bit) < 8 ? ((1 << (bit)) << 8) : ((1 << (bit)) >> 8))
enum
{
_ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
_ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
_ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
_ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
_ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
_ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
_ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
_ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
_ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
_IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
_ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
_ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
};
extern const unsigned short int **__ctype_b_loc (void)
throw () __attribute__ ((__const__));
extern const __int32_t **__ctype_tolower_loc (void)
throw () __attribute__ ((__const__));
extern const __int32_t **__ctype_toupper_loc (void)
throw () __attribute__ ((__const__));
#define __isascii(c) (((c) & ~0x7f) == 0)
#define __toascii(c) ((c) & 0x7f)
#define __exctype(name) extern int name (int) __THROW
extern int isalnum (int) throw ();
extern int isalpha (int) throw ();
extern int iscntrl (int) throw ();
extern int isdigit (int) throw ();
extern int islower (int) throw ();
extern int isgraph (int) throw ();
extern int isprint (int) throw ();
extern int ispunct (int) throw ();
extern int isspace (int) throw ();
extern int isupper (int) throw ();
extern int isxdigit (int) throw ();
extern int tolower (int __c) throw ();
extern int toupper (int __c) throw ();
extern int isblank (int) throw ();
extern int isctype (int __c, int __mask) throw ();
extern int isascii (int __c) throw ();
extern int toascii (int __c) throw ();
extern int _toupper (int) throw ();
extern int _tolower (int) throw ();
#define __tobody(c,f,a,args) (__extension__ ({ int __res; if (sizeof (c) > 1) { if (__builtin_constant_p (c)) { int __c = (c); __res = __c < -128 || __c > 255 ? __c : (a)[__c]; } else __res = f args; } else __res = (a)[(int) (c)]; __res; }))
#define __isctype_l(c,type,locale) ((locale)->__ctype_b[(int) (c)] & (unsigned short int) type)
#define __exctype_l(name) extern int name (int, __locale_t) __THROW
extern int isalnum_l (int, __locale_t) throw ();
extern int isalpha_l (int, __locale_t) throw ();
extern int iscntrl_l (int, __locale_t) throw ();
extern int isdigit_l (int, __locale_t) throw ();
extern int islower_l (int, __locale_t) throw ();
extern int isgraph_l (int, __locale_t) throw ();
extern int isprint_l (int, __locale_t) throw ();
extern int ispunct_l (int, __locale_t) throw ();
extern int isspace_l (int, __locale_t) throw ();
extern int isupper_l (int, __locale_t) throw ();
extern int isxdigit_l (int, __locale_t) throw ();
extern int isblank_l (int, __locale_t) throw ();
extern int __tolower_l (int __c, __locale_t __l) throw ();
extern int tolower_l (int __c, __locale_t __l) throw ();
extern int __toupper_l (int __c, __locale_t __l) throw ();
extern int toupper_l (int __c, __locale_t __l) throw ();
}
#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;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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>
_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;
template<typename _CharT> class numpunct;
template<typename _CharT> class numpunct_byname;
template<typename _CharT>
class collate;
template<typename _CharT> class
collate_byname;
class time_base;
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;
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class money_get;
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class money_put;
template<typename _CharT, bool _Intl = false>
class moneypunct;
template<typename _CharT, bool _Intl = false>
class moneypunct_byname;
class messages_base;
template<typename _CharT>
class messages;
template<typename _CharT>
class messages_byname;
}
#define _OSTREAM_INSERT_H 1
#define _CXXABI_FORCED_H 1
#pragma GCC visibility push(default)
namespace __cxxabiv1
{
class __forced_unwind
{
virtual ~__forced_unwind() throw();
virtual void __pure_dummy() = 0;
};
}
#pragma GCC visibility pop
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
void
__ostream_write(basic_ostream<_CharT, _Traits>& __out,
const _CharT* __s, streamsize __n)
;
template<typename _CharT, typename _Traits>
void
__ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
__ostream_insert(basic_ostream<_CharT, _Traits>& __out,
const _CharT* __s, streamsize __n)
;
extern template ostream& __ostream_insert(ostream&, const char*, streamsize);
extern template wostream& __ostream_insert(wostream&, const wchar_t*,
streamsize);
}
#define _STL_FUNCTION_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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;
};
template<typename _Tp>
struct plus : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct minus : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct multiplies : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct divides : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct modulus : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct negate : public unary_function<_Tp, _Tp>
{
_Tp
operator()(const _Tp& __x) const
;
};
template<typename _Tp>
struct equal_to : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct not_equal_to : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct greater : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct less : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct greater_equal : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct less_equal : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct logical_and : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct logical_or : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct logical_not : public unary_function<_Tp, bool>
{
bool
operator()(const _Tp& __x) const
;
};
template<typename _Tp>
struct bit_and : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct bit_or : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct bit_not : public unary_function<_Tp, _Tp>
{
_Tp
operator()(const _Tp& __x) const
;
};
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) ;
bool
operator()(const typename _Predicate::argument_type& __x) const
;
};
template<typename _Predicate>
unary_negate<_Predicate>
not1(const _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) ;
bool
operator()(const typename _Predicate::first_argument_type& __x,
const typename _Predicate::second_argument_type& __y) const
;
};
template<typename _Predicate>
binary_negate<_Predicate>
not2(const _Predicate& __pred)
;
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)) ;
_Result
operator()(_Arg __x) const
;
};
template<typename _Arg, typename _Result>
pointer_to_unary_function<_Arg, _Result>
ptr_fun(_Result (*__x)(_Arg))
;
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)) ;
_Result
operator()(_Arg1 __x, _Arg2 __y) const
;
};
template<typename _Arg1, typename _Arg2, typename _Result>
pointer_to_binary_function<_Arg1, _Arg2, _Result>
ptr_fun(_Result (*__x)(_Arg1, _Arg2))
;
template<typename _Tp>
struct _Identity
: public unary_function<_Tp,_Tp>
{
_Tp&
operator()(_Tp& __x) const
;
const _Tp&
operator()(const _Tp& __x) const
;
};
template<typename _Pair>
struct _Select1st
: public unary_function<_Pair, typename _Pair::first_type>
{
typename _Pair::first_type&
operator()(_Pair& __x) const
;
const typename _Pair::first_type&
operator()(const _Pair& __x) const
;
template<typename _Pair2>
typename _Pair2::first_type&
operator()(_Pair2& __x) const
;
template<typename _Pair2>
const typename _Pair2::first_type&
operator()(const _Pair2& __x) const
;
};
template<typename _Pair>
struct _Select2nd
: public unary_function<_Pair, typename _Pair::second_type>
{
typename _Pair::second_type&
operator()(_Pair& __x) const
;
const typename _Pair::second_type&
operator()(const _Pair& __x) const
;
};
template<typename _Ret, typename _Tp>
class mem_fun_t : public unary_function<_Tp*, _Ret>
{
public:
explicit
mem_fun_t(_Ret (_Tp::*__pf)()) ;
_Ret
operator()(_Tp* __p) const
;
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) ;
_Ret
operator()(const _Tp* __p) const
;
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)()) ;
_Ret
operator()(_Tp& __r) const
;
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) ;
_Ret
operator()(const _Tp& __r) const
;
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)) ;
_Ret
operator()(_Tp* __p, _Arg __x) const
;
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) ;
_Ret
operator()(const _Tp* __p, _Arg __x) const
;
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)) ;
_Ret
operator()(_Tp& __r, _Arg __x) const
;
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) ;
_Ret
operator()(const _Tp& __r, _Arg __x) const
;
private:
_Ret (_Tp::*_M_f)(_Arg) const;
};
template<typename _Ret, typename _Tp>
mem_fun_t<_Ret, _Tp>
mem_fun(_Ret (_Tp::*__f)())
;
template<typename _Ret, typename _Tp>
const_mem_fun_t<_Ret, _Tp>
mem_fun(_Ret (_Tp::*__f)() const)
;
template<typename _Ret, typename _Tp>
mem_fun_ref_t<_Ret, _Tp>
mem_fun_ref(_Ret (_Tp::*__f)())
;
template<typename _Ret, typename _Tp>
const_mem_fun_ref_t<_Ret, _Tp>
mem_fun_ref(_Ret (_Tp::*__f)() const)
;
template<typename _Ret, typename _Tp, typename _Arg>
mem_fun1_t<_Ret, _Tp, _Arg>
mem_fun(_Ret (_Tp::*__f)(_Arg))
;
template<typename _Ret, typename _Tp, typename _Arg>
const_mem_fun1_t<_Ret, _Tp, _Arg>
mem_fun(_Ret (_Tp::*__f)(_Arg) const)
;
template<typename _Ret, typename _Tp, typename _Arg>
mem_fun1_ref_t<_Ret, _Tp, _Arg>
mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
;
template<typename _Ret, typename _Tp, typename _Arg>
const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
;
}
#define _BACKWARD_BINDERS_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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) ;
typename _Operation::result_type
operator()(const typename _Operation::second_argument_type& __x) const
;
typename _Operation::result_type
operator()(typename _Operation::second_argument_type& __x) const
;
} __attribute__ ((__deprecated__));
template<typename _Operation, typename _Tp>
binder1st<_Operation>
bind1st(const _Operation& __fn, const _Tp& __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) ;
typename _Operation::result_type
operator()(const typename _Operation::first_argument_type& __x) const
;
typename _Operation::result_type
operator()(typename _Operation::first_argument_type& __x) const
;
} __attribute__ ((__deprecated__));
template<typename _Operation, typename _Tp>
binder2nd<_Operation>
bind2nd(const _Operation& __fn, const _Tp& __x)
;
}
#define _GLIBCXX_RANGE_ACCESS_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<class _Container>
inline auto
begin(_Container& __cont) -> decltype(__cont.begin())
{ return __cont.begin(); }
template<class _Container>
inline auto
begin(const _Container& __cont) -> decltype(__cont.begin())
{ return __cont.begin(); }
template<class _Container>
inline auto
end(_Container& __cont) -> decltype(__cont.end())
{ return __cont.end(); }
template<class _Container>
inline auto
end(const _Container& __cont) -> decltype(__cont.end())
{ return __cont.end(); }
template<class _Tp, size_t _Nm>
_Tp*
begin(_Tp (&__arr)[_Nm])
;
template<class _Tp, size_t _Nm>
_Tp*
end(_Tp (&__arr)[_Nm])
;
}
#define _BASIC_STRING_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits, typename _Alloc>
class basic_string
{
typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;
public:
typedef _Traits traits_type;
typedef typename _Traits::char_type value_type;
typedef _Alloc allocator_type;
typedef typename _CharT_alloc_type::size_type size_type;
typedef typename _CharT_alloc_type::difference_type difference_type;
typedef typename _CharT_alloc_type::reference reference;
typedef typename _CharT_alloc_type::const_reference const_reference;
typedef typename _CharT_alloc_type::pointer pointer;
typedef typename _CharT_alloc_type::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;
private:
struct _Rep_base
{
size_type _M_length;
size_type _M_capacity;
_Atomic_word _M_refcount;
};
struct _Rep : _Rep_base
{
typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
static const size_type _S_max_size;
static const _CharT _S_terminal;
static size_type _S_empty_rep_storage[];
static _Rep&
_S_empty_rep() noexcept
{
void* __p = reinterpret_cast<void*>(&_S_empty_rep_storage);
return *reinterpret_cast<_Rep*>(__p);
}
bool
_M_is_leaked() const noexcept
{ return this->_M_refcount < 0; }
bool
_M_is_shared() const noexcept
{ return this->_M_refcount > 0; }
void
_M_set_leaked() noexcept
{ this->_M_refcount = -1; }
void
_M_set_sharable() noexcept
{ this->_M_refcount = 0; }
void
_M_set_length_and_sharable(size_type __n) noexcept
{
if (__builtin_expect(this != &_S_empty_rep(), false))
{
this->_M_set_sharable();
this->_M_length = __n;
traits_type::assign(this->_M_refdata()[__n], _S_terminal);
}
}
_CharT*
_M_refdata() throw()
{ return reinterpret_cast<_CharT*>(this + 1); }
_CharT*
_M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2)
{
return (!_M_is_leaked() && __alloc1 == __alloc2)
? _M_refcopy() : _M_clone(__alloc1);
}
static _Rep*
_S_create(size_type, size_type, const _Alloc&);
void
_M_dispose(const _Alloc& __a) noexcept
{
if (__builtin_expect(this != &_S_empty_rep(), false))
{
;
if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount,
-1) <= 0)
{
;
_M_destroy(__a);
}
}
}
void
_M_destroy(const _Alloc&) throw();
_CharT*
_M_refcopy() throw()
;
_CharT*
_M_clone(const _Alloc&, size_type __res = 0);
};
struct _Alloc_hider : _Alloc
{
_Alloc_hider(_CharT* __dat, const _Alloc& __a) noexcept
: _Alloc(__a), _M_p(__dat) { }
_CharT* _M_p;
};
public:
static const size_type npos = static_cast<size_type>(-1);
private:
mutable _Alloc_hider _M_dataplus;
_CharT*
_M_data() const noexcept
{ return _M_dataplus._M_p; }
_CharT*
_M_data(_CharT* __p) noexcept
{ return (_M_dataplus._M_p = __p); }
_Rep*
_M_rep() const noexcept
{ return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }
iterator
_M_ibegin() const noexcept
{ return iterator(_M_data()); }
iterator
_M_iend() const noexcept
{ return iterator(_M_data() + this->size()); }
void
_M_leak()
{
if (!_M_rep()->_M_is_leaked())
_M_leak_hard();
}
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
_M_copy(_CharT* __d, const _CharT* __s, size_type __n) noexcept
{
if (__n == 1)
traits_type::assign(*__d, *__s);
else
traits_type::copy(__d, __s, __n);
}
static void
_M_move(_CharT* __d, const _CharT* __s, size_type __n) noexcept
{
if (__n == 1)
traits_type::assign(*__d, *__s);
else
traits_type::move(__d, __s, __n);
}
static void
_M_assign(_CharT* __d, size_type __n, _CharT __c) noexcept
{
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)
noexcept
{
for (; __k1 != __k2; ++__k1, ++__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
{ _M_copy(__p, __k1, __k2 - __k1); }
static void
_S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
noexcept
{ _M_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_mutate(size_type __pos, size_type __len1, size_type __len2);
void
_M_leak_hard();
static _Rep&
_S_empty_rep() noexcept
{ return _Rep::_S_empty_rep(); }
public:
basic_string()
: _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { }
explicit
basic_string(const _Alloc& __a);
basic_string(const basic_string& __str);
basic_string(const basic_string& __str, size_type __pos,
size_type __n = npos);
basic_string(const basic_string& __str, size_type __pos,
size_type __n, const _Alloc& __a);
basic_string(const _CharT* __s, size_type __n,
const _Alloc& __a = _Alloc());
basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc());
basic_string(basic_string&& __str)
noexcept
: _M_dataplus(__str._M_dataplus)
{
__str._M_data(_S_empty_rep()._M_refdata());
}
basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc());
template<class _InputIterator>
basic_string(_InputIterator __beg, _InputIterator __end,
const _Alloc& __a = _Alloc());
~basic_string() noexcept
{ _M_rep()->_M_dispose(this->get_allocator()); }
basic_string&
operator=(const basic_string& __str)
{ return this->assign(__str); }
basic_string&
operator=(const _CharT* __s)
{ return this->assign(__s); }
basic_string&
operator=(_CharT __c)
{
this->assign(1, __c);
return *this;
}
basic_string&
operator=(basic_string&& __str)
{
this->swap(__str);
return *this;
}
basic_string&
operator=(initializer_list<_CharT> __l)
{
this->assign(__l.begin(), __l.size());
return *this;
}
iterator
begin()
{
_M_leak();
return iterator(_M_data());
}
const_iterator
begin() const noexcept
{ return const_iterator(_M_data()); }
iterator
end()
{
_M_leak();
return iterator(_M_data() + this->size());
}
const_iterator
end() const noexcept
{ return const_iterator(_M_data() + this->size()); }
reverse_iterator
rbegin()
{ return reverse_iterator(this->end()); }
const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(this->end()); }
reverse_iterator
rend()
{ 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_rep()->_M_length; }
size_type
length() const noexcept
{ return _M_rep()->_M_length; }
size_type
max_size() const noexcept
{ return _Rep::_S_max_size; }
void
resize(size_type __n, _CharT __c);
void
resize(size_type __n)
;
void
shrink_to_fit() noexcept
{
if (capacity() > size())
{
try
{ reserve(0); }
catch(...)
{ }
}
}
size_type
capacity() const noexcept
{ return _M_rep()->_M_capacity; }
void
reserve(size_type __res_arg = 0);
void
clear()
;
bool
empty() const noexcept
{ return this->size() == 0; }
const_reference
operator[] (size_type __pos) const noexcept
{
;
return _M_data()[__pos];
}
reference
operator[](size_type __pos)
{
;
;
_M_leak();
return _M_data()[__pos];
}
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];
}
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());
_M_leak();
return _M_data()[__n];
}
reference
front()
{ return operator[](0); }
const_reference
front() const noexcept
{ return operator[](0); }
reference
back()
{ return operator[](this->size() - 1); }
const_reference
back() const noexcept
{ return operator[](this->size() - 1); }
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()); }
basic_string&
append(const basic_string& __str);
basic_string&
append(const basic_string& __str, size_type __pos, size_type __n);
basic_string&
append(const _CharT* __s, size_type __n);
basic_string&
append(const _CharT* __s)
;
basic_string&
append(size_type __n, _CharT __c);
basic_string&
append(initializer_list<_CharT> __l)
;
template<class _InputIterator>
basic_string&
append(_InputIterator __first, _InputIterator __last)
;
void
push_back(_CharT __c)
;
basic_string&
assign(const basic_string& __str);
basic_string&
assign(basic_string&& __str)
;
basic_string&
assign(const basic_string& __str, size_type __pos, size_type __n)
;
basic_string&
assign(const _CharT* __s, size_type __n);
basic_string&
assign(const _CharT* __s)
;
basic_string&
assign(size_type __n, _CharT __c)
;
template<class _InputIterator>
basic_string&
assign(_InputIterator __first, _InputIterator __last)
;
basic_string&
assign(initializer_list<_CharT> __l)
;
void
insert(iterator __p, size_type __n, _CharT __c)
;
template<class _InputIterator>
void
insert(iterator __p, _InputIterator __beg, _InputIterator __end)
;
void
insert(iterator __p, initializer_list<_CharT> __l)
;
basic_string&
insert(size_type __pos1, const basic_string& __str)
;
basic_string&
insert(size_type __pos1, const basic_string& __str,
size_type __pos2, size_type __n)
;
basic_string&
insert(size_type __pos, const _CharT* __s, size_type __n);
basic_string&
insert(size_type __pos, const _CharT* __s)
;
basic_string&
insert(size_type __pos, size_type __n, _CharT __c)
;
iterator
insert(iterator __p, _CharT __c)
;
basic_string&
erase(size_type __pos = 0, size_type __n = npos)
;
iterator
erase(iterator __position)
;
iterator
erase(iterator __first, iterator __last);
void
pop_back()
;
basic_string&
replace(size_type __pos, size_type __n, const basic_string& __str)
;
basic_string&
replace(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2)
;
basic_string&
replace(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2);
basic_string&
replace(size_type __pos, size_type __n1, const _CharT* __s)
;
basic_string&
replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
;
basic_string&
replace(iterator __i1, iterator __i2, const basic_string& __str)
;
basic_string&
replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
;
basic_string&
replace(iterator __i1, iterator __i2, const _CharT* __s)
;
basic_string&
replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
;
template<class _InputIterator>
basic_string&
replace(iterator __i1, iterator __i2,
_InputIterator __k1, _InputIterator __k2)
;
basic_string&
replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
;
basic_string&
replace(iterator __i1, iterator __i2,
const _CharT* __k1, const _CharT* __k2)
;
basic_string&
replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
;
basic_string&
replace(iterator __i1, iterator __i2,
const_iterator __k1, const_iterator __k2)
;
basic_string& replace(iterator __i1, iterator __i2,
initializer_list<_CharT> __l)
;
private:
template<class _Integer>
basic_string&
_M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n,
_Integer __val, __true_type)
;
template<class _InputIterator>
basic_string&
_M_replace_dispatch(iterator __i1, 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_safe(size_type __pos1, size_type __n1, const _CharT* __s,
size_type __n2);
template<class _InIterator>
static _CharT*
_S_construct_aux(_InIterator __beg, _InIterator __end,
const _Alloc& __a, __false_type)
;
template<class _Integer>
static _CharT*
_S_construct_aux(_Integer __beg, _Integer __end,
const _Alloc& __a, __true_type)
;
static _CharT*
_S_construct_aux_2(size_type __req, _CharT __c, const _Alloc& __a)
;
template<class _InIterator>
static _CharT*
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a)
;
template<class _InIterator>
static _CharT*
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
input_iterator_tag);
template<class _FwdIterator>
static _CharT*
_S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a,
forward_iterator_tag);
static _CharT*
_S_construct(size_type __req, _CharT __c, const _Alloc& __a);
public:
size_type
copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
void
swap(basic_string& __s);
const _CharT*
c_str() const noexcept
{ return _M_data(); }
const _CharT*
data() const noexcept
{ return _M_data(); }
allocator_type
get_allocator() const noexcept
{ return _M_dataplus; }
size_type
find(const _CharT* __s, size_type __pos, size_type __n) const;
size_type
find(const basic_string& __str, size_type __pos = 0) const
noexcept
{ return this->find(__str.data(), __pos, __str.size()); }
size_type
find(const _CharT* __s, size_type __pos = 0) const
{
;
return this->find(__s, __pos, traits_type::length(__s));
}
size_type
find(_CharT __c, size_type __pos = 0) const noexcept;
size_type
rfind(const basic_string& __str, size_type __pos = npos) const
noexcept
{ return this->rfind(__str.data(), __pos, __str.size()); }
size_type
rfind(const _CharT* __s, size_type __pos, size_type __n) const;
size_type
rfind(const _CharT* __s, size_type __pos = npos) const
;
size_type
rfind(_CharT __c, size_type __pos = npos) const noexcept;
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()); }
size_type
find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
size_type
find_first_of(const _CharT* __s, size_type __pos = 0) const
;
size_type
find_first_of(_CharT __c, size_type __pos = 0) const noexcept
{ return this->find(__c, __pos); }
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()); }
size_type
find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
size_type
find_last_of(const _CharT* __s, size_type __pos = npos) const
;
size_type
find_last_of(_CharT __c, size_type __pos = npos) const noexcept
{ return this->rfind(__c, __pos); }
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()); }
size_type
find_first_not_of(const _CharT* __s, size_type __pos,
size_type __n) const;
size_type
find_first_not_of(const _CharT* __s, size_type __pos = 0) const
;
size_type
find_first_not_of(_CharT __c, size_type __pos = 0) const
noexcept;
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()); }
size_type
find_last_not_of(const _CharT* __s, size_type __pos,
size_type __n) const;
size_type
find_last_not_of(const _CharT* __s, size_type __pos = npos) const
;
size_type
find_last_not_of(_CharT __c, size_type __pos = npos) const
noexcept;
basic_string
substr(size_type __pos = 0, size_type __n = npos) const
;
int
compare(const basic_string& __str) const
;
int
compare(size_type __pos, size_type __n, const basic_string& __str) const;
int
compare(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2) const;
int
compare(const _CharT* __s) const;
int
compare(size_type __pos, size_type __n1, const _CharT* __s) const;
int
compare(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2) const;
};
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)
;
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>
basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
basic_string<_CharT, _Traits, _Alloc>&& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
basic_string<_CharT, _Traits, _Alloc>&& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const _CharT* __lhs,
basic_string<_CharT, _Traits, _Alloc>&& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(_CharT __lhs,
basic_string<_CharT, _Traits, _Alloc>&& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
_CharT __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
operator==(const basic_string<_CharT>& __lhs,
const basic_string<_CharT>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator==(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator!=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
void
swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
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);
template<typename _CharT, typename _Traits, typename _Alloc>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os,
const basic_string<_CharT, _Traits, _Alloc>& __str)
;
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);
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Alloc>& __str)
;
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)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>&& __is,
basic_string<_CharT, _Traits, _Alloc>& __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);
}
#define _STRING_CONVERSIONS_H 1
#undef __need_mbstate_t
#undef __need_wint_t
#define _STDIO_H 1
extern "C" {
#define __need_size_t
#define __need_NULL
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define __need_FILE
#define __need___FILE
#undef __need_FILE
#undef __need___FILE
#define _STDIO_USES_IOSTREAM
#define _IO_STDIO_H
#define _G_config_h 1
#define __need_size_t
#define __need_NULL
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define __need_mbstate_t
#undef __need_mbstate_t
#undef __need_wint_t
typedef struct
{
__off_t __pos;
__mbstate_t __state;
} _G_fpos_t;
typedef struct
{
__off64_t __pos;
__mbstate_t __state;
} _G_fpos64_t;
#define _G_va_list __gnuc_va_list
#define _G_HAVE_MMAP 1
#define _G_HAVE_MREMAP 1
#define _G_IO_IO_FILE_VERSION 0x20001
#define _G_HAVE_ST_BLKSIZE defined (_STATBUF_ST_BLKSIZE)
#define _G_BUFSIZ 8192
#define _IO_fpos_t _G_fpos_t
#define _IO_fpos64_t _G_fpos64_t
#define _IO_size_t size_t
#define _IO_ssize_t __ssize_t
#define _IO_off_t __off_t
#define _IO_off64_t __off64_t
#define _IO_pid_t __pid_t
#define _IO_uid_t __uid_t
#define _IO_iconv_t _G_iconv_t
#define _IO_HAVE_ST_BLKSIZE _G_HAVE_ST_BLKSIZE
#define _IO_BUFSIZ _G_BUFSIZ
#define _IO_va_list _G_va_list
#define _IO_wint_t wint_t
#define __need___va_list
#undef __need___va_list
#undef _IO_va_list
#define _IO_va_list __gnuc_va_list
#define _IO_UNIFIED_JUMPTABLES 1
#define EOF (-1)
#define _IOS_INPUT 1
#define _IOS_OUTPUT 2
#define _IOS_ATEND 4
#define _IOS_APPEND 8
#define _IOS_TRUNC 16
#define _IOS_NOCREATE 32
#define _IOS_NOREPLACE 64
#define _IOS_BIN 128
#define _IO_MAGIC 0xFBAD0000
#define _OLD_STDIO_MAGIC 0xFABC0000
#define _IO_MAGIC_MASK 0xFFFF0000
#define _IO_USER_BUF 1
#define _IO_UNBUFFERED 2
#define _IO_NO_READS 4
#define _IO_NO_WRITES 8
#define _IO_EOF_SEEN 0x10
#define _IO_ERR_SEEN 0x20
#define _IO_DELETE_DONT_CLOSE 0x40
#define _IO_LINKED 0x80
#define _IO_IN_BACKUP 0x100
#define _IO_LINE_BUF 0x200
#define _IO_TIED_PUT_GET 0x400
#define _IO_CURRENTLY_PUTTING 0x800
#define _IO_IS_APPENDING 0x1000
#define _IO_IS_FILEBUF 0x2000
#define _IO_BAD_SEEN 0x4000
#define _IO_USER_LOCK 0x8000
#define _IO_FLAGS2_MMAP 1
#define _IO_FLAGS2_NOTCANCEL 2
#define _IO_FLAGS2_USER_WBUF 8
#define _IO_SKIPWS 01
#define _IO_LEFT 02
#define _IO_RIGHT 04
#define _IO_INTERNAL 010
#define _IO_DEC 020
#define _IO_OCT 040
#define _IO_HEX 0100
#define _IO_SHOWBASE 0200
#define _IO_SHOWPOINT 0400
#define _IO_UPPERCASE 01000
#define _IO_SHOWPOS 02000
#define _IO_SCIENTIFIC 04000
#define _IO_FIXED 010000
#define _IO_UNITBUF 020000
#define _IO_STDIO 040000
#define _IO_DONT_CLOSE 0100000
#define _IO_BOOLALPHA 0200000
struct _IO_jump_t; struct _IO_FILE;
typedef void _IO_lock_t;
struct _IO_marker {
struct _IO_marker *_next;
struct _IO_FILE *_sbuf;
int _pos;
};
enum __codecvt_result
{
__codecvt_ok,
__codecvt_partial,
__codecvt_error,
__codecvt_noconv
};
struct _IO_FILE {
int _flags;
#define _IO_file_flags _flags
char* _IO_read_ptr;
char* _IO_read_end;
char* _IO_read_base;
char* _IO_write_base;
char* _IO_write_ptr;
char* _IO_write_end;
char* _IO_buf_base;
char* _IO_buf_end;
char *_IO_save_base;
char *_IO_backup_base;
char *_IO_save_end;
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
int _flags2;
__off_t _old_offset;
#define __HAVE_COLUMN
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
_IO_lock_t *_lock;
__off64_t _offset;
void *__pad1;
void *__pad2;
void *__pad3;
void *__pad4;
size_t __pad5;
int _mode;
char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
};
struct _IO_FILE_plus;
extern struct _IO_FILE_plus _IO_2_1_stdin_;
extern struct _IO_FILE_plus _IO_2_1_stdout_;
extern struct _IO_FILE_plus _IO_2_1_stderr_;
#define _IO_stdin ((_IO_FILE*)(&_IO_2_1_stdin_))
#define _IO_stdout ((_IO_FILE*)(&_IO_2_1_stdout_))
#define _IO_stderr ((_IO_FILE*)(&_IO_2_1_stderr_))
typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
typedef __ssize_t __io_write_fn (void *__cookie, const char *__buf,
size_t __n);
typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
typedef int __io_close_fn (void *__cookie);
typedef __io_read_fn cookie_read_function_t;
typedef __io_write_fn cookie_write_function_t;
typedef __io_seek_fn cookie_seek_function_t;
typedef __io_close_fn cookie_close_function_t;
typedef struct
{
__io_read_fn *read;
__io_write_fn *write;
__io_seek_fn *seek;
__io_close_fn *close;
} _IO_cookie_io_functions_t;
typedef _IO_cookie_io_functions_t cookie_io_functions_t;
struct _IO_cookie_file;
extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
void *__cookie, _IO_cookie_io_functions_t __fns);
extern "C" {
extern int __underflow (_IO_FILE *);
extern int __uflow (_IO_FILE *);
extern int __overflow (_IO_FILE *, int);
#define _IO_BE(expr,res) __builtin_expect ((expr), res)
#define _IO_getc_unlocked(_fp) (_IO_BE ((_fp)->_IO_read_ptr >= (_fp)->_IO_read_end, 0) ? __uflow (_fp) : *(unsigned char *) (_fp)->_IO_read_ptr++)
#define _IO_peekc_unlocked(_fp) (_IO_BE ((_fp)->_IO_read_ptr >= (_fp)->_IO_read_end, 0) && __underflow (_fp) == EOF ? EOF : *(unsigned char *) (_fp)->_IO_read_ptr)
#define _IO_putc_unlocked(_ch,_fp) (_IO_BE ((_fp)->_IO_write_ptr >= (_fp)->_IO_write_end, 0) ? __overflow (_fp, (unsigned char) (_ch)) : (unsigned char) (*(_fp)->_IO_write_ptr++ = (_ch)))
#define _IO_feof_unlocked(__fp) (((__fp)->_flags & _IO_EOF_SEEN) != 0)
#define _IO_ferror_unlocked(__fp) (((__fp)->_flags & _IO_ERR_SEEN) != 0)
extern int _IO_getc (_IO_FILE *__fp);
extern int _IO_putc (int __c, _IO_FILE *__fp);
extern int _IO_feof (_IO_FILE *__fp) throw ();
extern int _IO_ferror (_IO_FILE *__fp) throw ();
extern int _IO_peekc_locked (_IO_FILE *__fp);
#define _IO_PENDING_OUTPUT_COUNT(_fp) ((_fp)->_IO_write_ptr - (_fp)->_IO_write_base)
extern void _IO_flockfile (_IO_FILE *) throw ();
extern void _IO_funlockfile (_IO_FILE *) throw ();
extern int _IO_ftrylockfile (_IO_FILE *) throw ();
#define _IO_peekc(_fp) _IO_peekc_unlocked (_fp)
#define _IO_flockfile(_fp)
#define _IO_funlockfile(_fp)
#define _IO_ftrylockfile(_fp)
#define _IO_cleanup_region_start(_fct,_fp)
#define _IO_cleanup_region_end(_Doit)
extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
__gnuc_va_list, int *__restrict);
extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
__gnuc_va_list);
extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);
extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);
extern void _IO_free_backup_area (_IO_FILE *) throw ();
}
typedef __gnuc_va_list va_list;
#define _VA_LIST_DEFINED
typedef _G_fpos_t fpos_t;
typedef _G_fpos64_t fpos64_t;
#define _IOFBF 0
#define _IOLBF 1
#define _IONBF 2
#define BUFSIZ _IO_BUFSIZ
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2
#define SEEK_DATA 3
#define SEEK_HOLE 4
#define P_tmpdir "/tmp"
#define L_tmpnam 20
#define TMP_MAX 238328
#define FILENAME_MAX 4096
#define L_ctermid 9
#define L_cuserid 9
#undef FOPEN_MAX
#define FOPEN_MAX 16
extern struct _IO_FILE *stdin;
extern struct _IO_FILE *stdout;
extern struct _IO_FILE *stderr;
#define stdin stdin
#define stdout stdout
#define stderr stderr
extern int remove (const char *__filename) throw ();
extern int rename (const char *__old, const char *__new) throw ();
extern int renameat (int __oldfd, const char *__old, int __newfd,
const char *__new) throw ();
extern FILE *tmpfile (void) ;
extern FILE *tmpfile64 (void) ;
extern char *tmpnam (char *__s) throw () ;
extern char *tmpnam_r (char *__s) throw () ;
extern char *tempnam (const char *__dir, const char *__pfx)
throw () __attribute__ ((__malloc__)) ;
extern int fclose (FILE *__stream);
extern int fflush (FILE *__stream);
extern int fflush_unlocked (FILE *__stream);
extern int fcloseall (void);
extern FILE *fopen (const char *__restrict __filename,
const char *__restrict __modes) ;
extern FILE *freopen (const char *__restrict __filename,
const char *__restrict __modes,
FILE *__restrict __stream) ;
extern FILE *fopen64 (const char *__restrict __filename,
const char *__restrict __modes) ;
extern FILE *freopen64 (const char *__restrict __filename,
const char *__restrict __modes,
FILE *__restrict __stream) ;
extern FILE *fdopen (int __fd, const char *__modes) throw () ;
extern FILE *fopencookie (void *__restrict __magic_cookie,
const char *__restrict __modes,
_IO_cookie_io_functions_t __io_funcs) throw () ;
extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
throw () ;
extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ;
extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();
extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
int __modes, size_t __n) throw ();
extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
size_t __size) throw ();
extern void setlinebuf (FILE *__stream) throw ();
extern int fprintf (FILE *__restrict __stream,
const char *__restrict __format, ...);
extern int printf (const char *__restrict __format, ...);
extern int sprintf (char *__restrict __s,
const char *__restrict __format, ...) throw ();
extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg);
extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
extern int vsprintf (char *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg) throw ();
extern int snprintf (char *__restrict __s, size_t __maxlen,
const char *__restrict __format, ...)
throw () __attribute__ ((__format__ (__printf__, 3, 4)));
extern int vsnprintf (char *__restrict __s, size_t __maxlen,
const char *__restrict __format, __gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__printf__, 3, 0)));
extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
__gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__printf__, 2, 0))) ;
extern int __asprintf (char **__restrict __ptr,
const char *__restrict __fmt, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
extern int asprintf (char **__restrict __ptr,
const char *__restrict __fmt, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
extern int vdprintf (int __fd, const char *__restrict __fmt,
__gnuc_va_list __arg)
__attribute__ ((__format__ (__printf__, 2, 0)));
extern int dprintf (int __fd, const char *__restrict __fmt, ...)
__attribute__ ((__format__ (__printf__, 2, 3)));
extern int fscanf (FILE *__restrict __stream,
const char *__restrict __format, ...) ;
extern int scanf (const char *__restrict __format, ...) ;
extern int sscanf (const char *__restrict __s,
const char *__restrict __format, ...) throw ();
extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg)
__attribute__ ((__format__ (__scanf__, 2, 0))) ;
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
__attribute__ ((__format__ (__scanf__, 1, 0))) ;
extern int vsscanf (const char *__restrict __s,
const char *__restrict __format, __gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
extern int fgetc (FILE *__stream);
extern int getc (FILE *__stream);
extern int getchar (void);
#define getc(_fp) _IO_getc (_fp)
extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
extern int fgetc_unlocked (FILE *__stream);
extern int fputc (int __c, FILE *__stream);
extern int putc (int __c, FILE *__stream);
extern int putchar (int __c);
#define putc(_ch,_fp) _IO_putc (_ch, _fp)
extern int fputc_unlocked (int __c, FILE *__stream);
extern int putc_unlocked (int __c, FILE *__stream);
extern int putchar_unlocked (int __c);
extern int getw (FILE *__stream);
extern int putw (int __w, FILE *__stream);
extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
;
extern char *gets (char *__s) __attribute__ ((__deprecated__));
extern char *fgets_unlocked (char *__restrict __s, int __n,
FILE *__restrict __stream) ;
extern __ssize_t __getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) ;
extern __ssize_t getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) ;
extern __ssize_t getline (char **__restrict __lineptr,
size_t *__restrict __n,
FILE *__restrict __stream) ;
extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
extern int puts (const char *__s);
extern int ungetc (int __c, FILE *__stream);
extern size_t fread (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite (const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __s);
extern int fputs_unlocked (const char *__restrict __s,
FILE *__restrict __stream);
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream);
extern int fseek (FILE *__stream, long int __off, int __whence);
extern long int ftell (FILE *__stream) ;
extern void rewind (FILE *__stream);
extern int fseeko (FILE *__stream, __off_t __off, int __whence);
extern __off_t ftello (FILE *__stream) ;
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
extern int fsetpos (FILE *__stream, const fpos_t *__pos);
extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
extern __off64_t ftello64 (FILE *__stream) ;
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos);
extern void clearerr (FILE *__stream) throw ();
extern int feof (FILE *__stream) throw () ;
extern int ferror (FILE *__stream) throw () ;
extern void clearerr_unlocked (FILE *__stream) throw ();
extern int feof_unlocked (FILE *__stream) throw () ;
extern int ferror_unlocked (FILE *__stream) throw () ;
extern void perror (const char *__s);
extern int sys_nerr;
extern const char *const sys_errlist[];
extern int _sys_nerr;
extern const char *const _sys_errlist[];
extern int fileno (FILE *__stream) throw () ;
extern int fileno_unlocked (FILE *__stream) throw () ;
extern FILE *popen (const char *__command, const char *__modes) ;
extern int pclose (FILE *__stream);
extern char *ctermid (char *__s) throw ();
extern char *cuserid (char *__s);
struct obstack;
extern int obstack_printf (struct obstack *__restrict __obstack,
const char *__restrict __format, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3)));
extern int obstack_vprintf (struct obstack *__restrict __obstack,
const char *__restrict __format,
__gnuc_va_list __args)
throw () __attribute__ ((__format__ (__printf__, 2, 0)));
extern void flockfile (FILE *__stream) throw ();
extern int ftrylockfile (FILE *__stream) throw () ;
extern void funlockfile (FILE *__stream) throw ();
}
#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
{
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;
}
#define _ERRNO_H 1
extern "C" {
#undef EDOM
#undef EILSEQ
#undef ERANGE
#define _ASM_GENERIC_ERRNO_H
#define _ASM_GENERIC_ERRNO_BASE_H
#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 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
#define ENOTSUP EOPNOTSUPP
extern int *__errno_location (void) throw () __attribute__ ((__const__));
#define errno (*__errno_location ())
#undef __need_Emath
extern char *program_invocation_name, *program_invocation_short_name;
}
typedef int error_t;
#define __error_t_defined 1
#undef __need_error_t
#define _GLIBCXX_CERRNO 1
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)
;
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, ...)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
int
stoi(const string& __str, size_t* __idx = 0, int __base = 10)
;
long
stol(const string& __str, size_t* __idx = 0, int __base = 10)
;
unsigned long
stoul(const string& __str, size_t* __idx = 0, int __base = 10)
;
long long
stoll(const string& __str, size_t* __idx = 0, int __base = 10)
;
unsigned long long
stoull(const string& __str, size_t* __idx = 0, int __base = 10)
;
float
stof(const string& __str, size_t* __idx = 0)
;
double
stod(const string& __str, size_t* __idx = 0)
;
long double
stold(const string& __str, size_t* __idx = 0)
;
string
to_string(int __val)
;
string
to_string(unsigned __val)
;
string
to_string(long __val)
;
string
to_string(unsigned long __val)
;
string
to_string(long long __val)
;
string
to_string(unsigned long long __val)
;
string
to_string(float __val)
;
string
to_string(double __val)
;
string
to_string(long double __val)
;
int
stoi(const wstring& __str, size_t* __idx = 0, int __base = 10)
;
long
stol(const wstring& __str, size_t* __idx = 0, int __base = 10)
;
unsigned long
stoul(const wstring& __str, size_t* __idx = 0, int __base = 10)
;
long long
stoll(const wstring& __str, size_t* __idx = 0, int __base = 10)
;
unsigned long long
stoull(const wstring& __str, size_t* __idx = 0, int __base = 10)
;
float
stof(const wstring& __str, size_t* __idx = 0)
;
double
stod(const wstring& __str, size_t* __idx = 0)
;
long double
stold(const wstring& __str, size_t* __idx = 0)
;
wstring
to_wstring(int __val)
;
wstring
to_wstring(unsigned __val)
;
wstring
to_wstring(long __val)
;
wstring
to_wstring(unsigned long __val)
;
wstring
to_wstring(long long __val)
;
wstring
to_wstring(unsigned long long __val)
;
wstring
to_wstring(float __val)
;
wstring
to_wstring(double __val)
;
wstring
to_wstring(long double __val)
;
}
#define _FUNCTIONAL_HASH_H 1
#define _HASH_BYTES_H 1
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);
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Result, typename _Arg>
struct __hash_base
{
typedef _Result result_type;
typedef _Arg argument_type;
};
template<typename _Tp>
struct hash;
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); } };
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); } };
#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))
;
template<typename _Tp>
static size_t
hash(const _Tp& __val)
;
template<typename _Tp>
static size_t
__hash_combine(const _Tp& __val, size_t __hash)
;
};
struct _Fnv_hash_impl
{
static size_t
hash(const void* __ptr, size_t __clength,
size_t __seed = static_cast<size_t>(2166136261UL))
;
template<typename _Tp>
static size_t
hash(const _Tp& __val)
;
template<typename _Tp>
static size_t
__hash_combine(const _Tp& __val, size_t __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
{ };
}
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
{ };
}
#define _BASIC_STRING_TCC 1
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>::
_Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4;
template<typename _CharT, typename _Traits, typename _Alloc>
const _CharT
basic_string<_CharT, _Traits, _Alloc>::
_Rep::_S_terminal = _CharT();
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>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[
(sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) /
sizeof(size_type)];
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>
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
{
;
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
{
;
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
{
;
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
{
;
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
{
;
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
{
;
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&);
}
namespace std __attribute__ ((__visibility__ ("default")))
{
class logic_error : public exception
{
string _M_msg;
public:
explicit
logic_error(const string& __arg);
virtual ~logic_error() noexcept;
virtual const char*
what() const noexcept;
};
class domain_error : public logic_error
{
public:
explicit domain_error(const string& __arg);
virtual ~domain_error() noexcept;
};
class invalid_argument : public logic_error
{
public:
explicit invalid_argument(const string& __arg);
virtual ~invalid_argument() noexcept;
};
class length_error : public logic_error
{
public:
explicit length_error(const string& __arg);
virtual ~length_error() noexcept;
};
class out_of_range : public logic_error
{
public:
explicit out_of_range(const string& __arg);
virtual ~out_of_range() noexcept;
};
class runtime_error : public exception
{
string _M_msg;
public:
explicit
runtime_error(const string& __arg);
virtual ~runtime_error() noexcept;
virtual const char*
what() const noexcept;
};
class range_error : public runtime_error
{
public:
explicit range_error(const string& __arg);
virtual ~range_error() noexcept;
};
class overflow_error : public runtime_error
{
public:
explicit overflow_error(const string& __arg);
virtual ~overflow_error() noexcept;
};
class underflow_error : public runtime_error
{
public:
explicit underflow_error(const string& __arg);
virtual ~underflow_error() noexcept;
};
}
#define _TYPEINFO
#pragma GCC visibility push(default)
extern "C++" {
namespace __cxxabiv1
{
class __class_type_info;
}
#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; }
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));
}
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) ;
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
#define BOOST_ASIO_DETAIL_NONCOPYABLE_HPP
namespace boost {
namespace asio {
namespace detail {
class noncopyable
{
protected:
noncopyable() ;
~noncopyable() ;
private:
noncopyable(const noncopyable&);
const noncopyable& operator=(const noncopyable&);
};
}
using boost::asio::detail::noncopyable;
}
}
#define BOOST_ASIO_DETAIL_WRAPPED_HANDLER_HPP
#define BOOST_ASIO_DETAIL_BIND_HANDLER_HPP
#define BOOST_ASIO_DETAIL_HANDLER_ALLOC_HELPERS_HPP
#define BOOST_ASIO_DETAIL_ADDRESSOF_HPP
#define _GLIBCXX_MEMORY 1
#define _STL_CONSTRUCT_H 1
#define _EXT_ALLOC_TRAITS_H 1
#define _ALLOC_TRAITS_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc, typename _Tp>
class __alloctr_rebind_helper
{
template<typename _Alloc2, typename _Tp2>
static constexpr true_type
_S_chk(typename _Alloc2::template rebind<_Tp2>::other*);
template<typename, typename>
static constexpr false_type
_S_chk(...);
public:
using __type = decltype(_S_chk<_Alloc, _Tp>(nullptr));
};
template<typename _Alloc, typename _Tp,
bool = __alloctr_rebind_helper<_Alloc, _Tp>::__type::value>
struct __alloctr_rebind;
template<typename _Alloc, typename _Tp>
struct __alloctr_rebind<_Alloc, _Tp, true>
{
typedef typename _Alloc::template rebind<_Tp>::other __type;
};
template<template<typename, typename...> class _Alloc, typename _Tp,
typename _Up, typename... _Args>
struct __alloctr_rebind<_Alloc<_Up, _Args...>, _Tp, false>
{
typedef _Alloc<_Tp, _Args...> __type;
};
template<typename _Ptr, typename _Tp>
using __alloc_rebind = typename __alloctr_rebind<_Ptr, _Tp>::__type;
template<typename _Alloc>
struct allocator_traits
{
typedef _Alloc allocator_type;
typedef typename _Alloc::value_type value_type;
#define _GLIBCXX_ALLOC_TR_NESTED_TYPE(_NTYPE,_ALT) private: template<typename _Tp> static typename _Tp::_NTYPE _S_ ##_NTYPE ##_helper(_Tp*); static _ALT _S_ ##_NTYPE ##_helper(...); typedef decltype(_S_ ##_NTYPE ##_helper((_Alloc*)0)) __ ##_NTYPE; public:
private: template<typename _Tp> static typename _Tp::pointer _S_pointer_helper(_Tp*); static value_type* _S_pointer_helper(...); typedef decltype(_S_pointer_helper((_Alloc*)0)) __pointer; public:
typedef __pointer pointer;
private: template<typename _Tp> static typename _Tp::const_pointer _S_const_pointer_helper(_Tp*); static typename pointer_traits<pointer>::template rebind<const value_type> _S_const_pointer_helper(...); typedef decltype(_S_const_pointer_helper((_Alloc*)0)) __const_pointer; public:
typedef __const_pointer const_pointer;
private: template<typename _Tp> static typename _Tp::void_pointer _S_void_pointer_helper(_Tp*); static typename pointer_traits<pointer>::template rebind<void> _S_void_pointer_helper(...); typedef decltype(_S_void_pointer_helper((_Alloc*)0)) __void_pointer; public:
typedef __void_pointer void_pointer;
private: template<typename _Tp> static typename _Tp::const_void_pointer _S_const_void_pointer_helper(_Tp*); static typename pointer_traits<pointer>::template rebind<const void> _S_const_void_pointer_helper(...); typedef decltype(_S_const_void_pointer_helper((_Alloc*)0)) __const_void_pointer; public:
typedef __const_void_pointer const_void_pointer;
private: template<typename _Tp> static typename _Tp::difference_type _S_difference_type_helper(_Tp*); static typename pointer_traits<pointer>::difference_type _S_difference_type_helper(...); typedef decltype(_S_difference_type_helper((_Alloc*)0)) __difference_type; public:
typedef __difference_type difference_type;
private: template<typename _Tp> static typename _Tp::size_type _S_size_type_helper(_Tp*); static typename make_unsigned<difference_type>::type _S_size_type_helper(...); typedef decltype(_S_size_type_helper((_Alloc*)0)) __size_type; public:
typedef __size_type size_type;
private: template<typename _Tp> static typename _Tp::propagate_on_container_copy_assignment _S_propagate_on_container_copy_assignment_helper(_Tp*); static false_type _S_propagate_on_container_copy_assignment_helper(...); typedef decltype(_S_propagate_on_container_copy_assignment_helper((_Alloc*)0)) __propagate_on_container_copy_assignment; public:
typedef __propagate_on_container_copy_assignment
propagate_on_container_copy_assignment;
private: template<typename _Tp> static typename _Tp::propagate_on_container_move_assignment _S_propagate_on_container_move_assignment_helper(_Tp*); static false_type _S_propagate_on_container_move_assignment_helper(...); typedef decltype(_S_propagate_on_container_move_assignment_helper((_Alloc*)0)) __propagate_on_container_move_assignment; public:
typedef __propagate_on_container_move_assignment
propagate_on_container_move_assignment;
private: template<typename _Tp> static typename _Tp::propagate_on_container_swap _S_propagate_on_container_swap_helper(_Tp*); static false_type _S_propagate_on_container_swap_helper(...); typedef decltype(_S_propagate_on_container_swap_helper((_Alloc*)0)) __propagate_on_container_swap; public:
typedef __propagate_on_container_swap propagate_on_container_swap;
#undef _GLIBCXX_ALLOC_TR_NESTED_TYPE
template<typename _Tp>
using rebind_alloc = typename __alloctr_rebind<_Alloc, _Tp>::__type;
template<typename _Tp>
using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;
private:
template<typename _Alloc2>
struct __allocate_helper
{
template<typename _Alloc3,
typename = decltype(std::declval<_Alloc3*>()->allocate(
std::declval<size_type>(),
std::declval<const_void_pointer>()))>
static true_type __test(int);
template<typename>
static false_type __test(...);
using type = decltype(__test<_Alloc>(0));
};
template<typename _Alloc2>
using __has_allocate = typename __allocate_helper<_Alloc2>::type;
template<typename _Alloc2,
typename = _Require<__has_allocate<_Alloc2>>>
static pointer
_S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint)
;
template<typename _Alloc2, typename _UnusedHint,
typename = _Require<__not_<__has_allocate<_Alloc2>>>>
static pointer
_S_allocate(_Alloc2& __a, size_type __n, _UnusedHint)
;
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)
;
template<typename _Tp, typename... _Args>
static
_Require<__and_<__not_<__has_construct<_Tp, _Args...>>,
is_constructible<_Tp, _Args...>>>
_S_construct(_Alloc&, _Tp* __p, _Args&&... __args)
;
template<typename _Tp>
struct __destroy_helper
{
template<typename _Alloc2,
typename = decltype(std::declval<_Alloc2*>()->destroy(
std::declval<_Tp*>()))>
static true_type __test(int);
template<typename>
static false_type __test(...);
using type = decltype(__test<_Alloc>(0));
};
template<typename _Tp>
using __has_destroy = typename __destroy_helper<_Tp>::type;
template<typename _Tp>
static _Require<__has_destroy<_Tp>>
_S_destroy(_Alloc& __a, _Tp* __p)
;
template<typename _Tp>
static _Require<__not_<__has_destroy<_Tp>>>
_S_destroy(_Alloc&, _Tp* __p)
;
template<typename _Alloc2>
struct __maxsize_helper
{
template<typename _Alloc3,
typename = decltype(std::declval<_Alloc3*>()->max_size())>
static true_type __test(int);
template<typename>
static false_type __test(...);
using type = decltype(__test<_Alloc2>(0));
};
template<typename _Alloc2>
using __has_max_size = typename __maxsize_helper<_Alloc2>::type;
template<typename _Alloc2,
typename = _Require<__has_max_size<_Alloc2>>>
static size_type
_S_max_size(_Alloc2& __a, int)
;
template<typename _Alloc2,
typename = _Require<__not_<__has_max_size<_Alloc2>>>>
static size_type
_S_max_size(_Alloc2&, ...)
;
template<typename _Alloc2>
struct __select_helper
{
template<typename _Alloc3, typename
= decltype(std::declval<_Alloc3*>()
->select_on_container_copy_construction())>
static true_type __test(int);
template<typename>
static false_type __test(...);
using type = decltype(__test<_Alloc2>(0));
};
template<typename _Alloc2>
using __has_soccc = typename __select_helper<_Alloc2>::type;
template<typename _Alloc2,
typename = _Require<__has_soccc<_Alloc2>>>
static _Alloc2
_S_select(_Alloc2& __a, int)
;
template<typename _Alloc2,
typename = _Require<__not_<__has_soccc<_Alloc2>>>>
static _Alloc2
_S_select(_Alloc2& __a, ...)
;
public:
static pointer
allocate(_Alloc& __a, size_type __n)
;
static pointer
allocate(_Alloc& __a, size_type __n, const_void_pointer __hint)
;
static void deallocate(_Alloc& __a, pointer __p, size_type __n)
;
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)...); }
template <class _Tp>
static void destroy(_Alloc& __a, _Tp* __p)
{ _S_destroy(__a, __p); }
static size_type max_size(const _Alloc& __a) noexcept
{ return _S_max_size(__a, 0); }
static _Alloc
select_on_container_copy_construction(const _Alloc& __rhs)
{ return _S_select(__rhs, 0); }
};
template<typename _Alloc>
void
__do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type)
;
template<typename _Alloc>
void
__do_alloc_on_copy(_Alloc&, const _Alloc&, false_type)
;
template<typename _Alloc>
void __alloc_on_copy(_Alloc& __one, const _Alloc& __two)
;
template<typename _Alloc>
_Alloc __alloc_on_copy(const _Alloc& __a)
;
template<typename _Alloc>
void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type)
;
template<typename _Alloc>
void __do_alloc_on_move(_Alloc&, _Alloc&, false_type)
;
template<typename _Alloc>
void __alloc_on_move(_Alloc& __one, _Alloc& __two)
;
template<typename _Alloc>
void __do_alloc_on_swap(_Alloc& __one, _Alloc& __two, true_type)
;
template<typename _Alloc>
void __do_alloc_on_swap(_Alloc&, _Alloc&, false_type)
;
template<typename _Alloc>
void __alloc_on_swap(_Alloc& __one, _Alloc& __two)
;
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>
{ };
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc>
struct __allocator_always_compares_equal : std::false_type { };
template<typename _Tp>
struct __allocator_always_compares_equal<std::allocator<_Tp>>
: std::true_type { };
template<typename, typename> struct array_allocator;
template<typename _Tp, typename _Array>
struct __allocator_always_compares_equal<array_allocator<_Tp, _Array>>
: std::true_type { };
template<typename> struct bitmap_allocator;
template<typename _Tp>
struct __allocator_always_compares_equal<bitmap_allocator<_Tp>>
: std::true_type { };
template<typename> struct malloc_allocator;
template<typename _Tp>
struct __allocator_always_compares_equal<malloc_allocator<_Tp>>
: std::true_type { };
template<typename> struct mt_allocator;
template<typename _Tp>
struct __allocator_always_compares_equal<mt_allocator<_Tp>>
: std::true_type { };
template<typename> struct new_allocator;
template<typename _Tp>
struct __allocator_always_compares_equal<new_allocator<_Tp>>
: std::true_type { };
template<typename> struct pool_allocator;
template<typename _Tp>
struct __allocator_always_compares_equal<pool_allocator<_Tp>>
: std::true_type { };
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)
;
template<typename _Ptr>
static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
destroy(_Alloc& __a, _Ptr __p)
;
static _Alloc _S_select_on_copy(const _Alloc& __a)
;
static void _S_on_swap(_Alloc& __a, _Alloc& __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 __allocator_always_compares_equal<_Alloc>::value; }
static constexpr bool _S_nothrow_move()
{ return _S_propagate_on_move_assign() || _S_always_equal(); }
static constexpr bool _S_nothrow_swap()
{
using std::swap;
return !_S_propagate_on_swap()
|| noexcept(swap(std::declval<_Alloc&>(), std::declval<_Alloc&>()));
}
template<typename _Tp>
struct rebind
{ typedef typename _Base_type::template rebind_alloc<_Tp> other; };
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _T1, typename... _Args>
void
_Construct(_T1* __p, _Args&&... __args)
;
template<typename _Tp>
void
_Destroy(_Tp* __pointer)
;
template<bool>
struct _Destroy_aux
{
template<typename _ForwardIterator>
static void
__destroy(_ForwardIterator __first, _ForwardIterator __last)
;
};
template<>
struct _Destroy_aux<true>
{
template<typename _ForwardIterator>
static void
__destroy(_ForwardIterator, _ForwardIterator) ;
};
template<typename _ForwardIterator>
void
_Destroy(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Allocator>
void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
_Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Tp>
void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
allocator<_Tp>&)
;
}
#define _STL_UNINITIALIZED_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<bool _TrivialValueTypes>
struct __uninitialized_copy
{
template<typename _InputIterator, typename _ForwardIterator>
static _ForwardIterator
__uninit_copy(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result)
;
};
template<>
struct __uninitialized_copy<true>
{
template<typename _InputIterator, typename _ForwardIterator>
static _ForwardIterator
__uninit_copy(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result)
;
};
template<typename _InputIterator, typename _ForwardIterator>
_ForwardIterator
uninitialized_copy(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result)
;
template<bool _TrivialValueType>
struct __uninitialized_fill
{
template<typename _ForwardIterator, typename _Tp>
static void
__uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x)
;
};
template<>
struct __uninitialized_fill<true>
{
template<typename _ForwardIterator, typename _Tp>
static void
__uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x)
;
};
template<typename _ForwardIterator, typename _Tp>
void
uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x)
;
template<bool _TrivialValueType>
struct __uninitialized_fill_n
{
template<typename _ForwardIterator, typename _Size, typename _Tp>
static _ForwardIterator
__uninit_fill_n(_ForwardIterator __first, _Size __n,
const _Tp& __x)
;
};
template<>
struct __uninitialized_fill_n<true>
{
template<typename _ForwardIterator, typename _Size, typename _Tp>
static _ForwardIterator
__uninit_fill_n(_ForwardIterator __first, _Size __n,
const _Tp& __x)
;
};
template<typename _ForwardIterator, typename _Size, typename _Tp>
_ForwardIterator
uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
;
template<typename _InputIterator, typename _ForwardIterator,
typename _Allocator>
_ForwardIterator
__uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
;
template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
_ForwardIterator
__uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, allocator<_Tp>&)
;
template<typename _InputIterator, typename _ForwardIterator,
typename _Allocator>
_ForwardIterator
__uninitialized_move_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
;
template<typename _InputIterator, typename _ForwardIterator,
typename _Allocator>
_ForwardIterator
__uninitialized_move_if_noexcept_a(_InputIterator __first,
_InputIterator __last,
_ForwardIterator __result,
_Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Tp, typename _Allocator>
void
__uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x, _Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Tp, typename _Tp2>
void
__uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x, allocator<_Tp2>&)
;
template<typename _ForwardIterator, typename _Size, typename _Tp,
typename _Allocator>
_ForwardIterator
__uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
const _Tp& __x, _Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Size, typename _Tp,
typename _Tp2>
_ForwardIterator
__uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
const _Tp& __x, allocator<_Tp2>&)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _ForwardIterator, typename _Allocator>
_ForwardIterator
__uninitialized_copy_move(_InputIterator1 __first1,
_InputIterator1 __last1,
_InputIterator2 __first2,
_InputIterator2 __last2,
_ForwardIterator __result,
_Allocator& __alloc)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _ForwardIterator, typename _Allocator>
_ForwardIterator
__uninitialized_move_copy(_InputIterator1 __first1,
_InputIterator1 __last1,
_InputIterator2 __first2,
_InputIterator2 __last2,
_ForwardIterator __result,
_Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
typename _Allocator>
_ForwardIterator
__uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
const _Tp& __x, _InputIterator __first,
_InputIterator __last, _Allocator& __alloc)
;
template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
typename _Allocator>
void
__uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
_ForwardIterator __first2,
_ForwardIterator __last2, const _Tp& __x,
_Allocator& __alloc)
;
template<bool _TrivialValueType>
struct __uninitialized_default_1
{
template<typename _ForwardIterator>
static void
__uninit_default(_ForwardIterator __first, _ForwardIterator __last)
;
};
template<>
struct __uninitialized_default_1<true>
{
template<typename _ForwardIterator>
static void
__uninit_default(_ForwardIterator __first, _ForwardIterator __last)
;
};
template<bool _TrivialValueType>
struct __uninitialized_default_n_1
{
template<typename _ForwardIterator, typename _Size>
static _ForwardIterator
__uninit_default_n(_ForwardIterator __first, _Size __n)
;
};
template<>
struct __uninitialized_default_n_1<true>
{
template<typename _ForwardIterator, typename _Size>
static _ForwardIterator
__uninit_default_n(_ForwardIterator __first, _Size __n)
;
};
template<typename _ForwardIterator>
void
__uninitialized_default(_ForwardIterator __first,
_ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Size>
_ForwardIterator
__uninitialized_default_n(_ForwardIterator __first, _Size __n)
;
template<typename _ForwardIterator, typename _Allocator>
void
__uninitialized_default_a(_ForwardIterator __first,
_ForwardIterator __last,
_Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Tp>
void
__uninitialized_default_a(_ForwardIterator __first,
_ForwardIterator __last,
allocator<_Tp>&)
;
template<typename _ForwardIterator, typename _Size, typename _Allocator>
_ForwardIterator
__uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
_Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Size, typename _Tp>
_ForwardIterator
__uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
allocator<_Tp>&)
;
template<typename _InputIterator, typename _Size,
typename _ForwardIterator>
_ForwardIterator
__uninitialized_copy_n(_InputIterator __first, _Size __n,
_ForwardIterator __result, input_iterator_tag)
;
template<typename _RandomAccessIterator, typename _Size,
typename _ForwardIterator>
_ForwardIterator
__uninitialized_copy_n(_RandomAccessIterator __first, _Size __n,
_ForwardIterator __result,
random_access_iterator_tag)
;
template<typename _InputIterator, typename _Size, typename _ForwardIterator>
_ForwardIterator
uninitialized_copy_n(_InputIterator __first, _Size __n,
_ForwardIterator __result)
;
}
#define _STL_TEMPBUF_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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);
}
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)
;
};
template<>
struct __uninitialized_construct_buf_dispatch<true>
{
template<typename _Pointer, typename _ForwardIterator>
static void
__ucr(_Pointer, _Pointer, _ForwardIterator) ;
};
template<typename _Pointer, typename _ForwardIterator>
void
__uninitialized_construct_buf(_Pointer __first, _Pointer __last,
_ForwardIterator __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;
}
}
}
#define _STL_RAW_STORAGE_ITERATOR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template <class _OutputIterator, class _Tp>
class raw_storage_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
protected:
_OutputIterator _M_iter;
public:
explicit
raw_storage_iterator(_OutputIterator __x) ;
raw_storage_iterator&
operator*() ;
raw_storage_iterator&
operator=(const _Tp& __element)
;
raw_storage_iterator<_OutputIterator, _Tp>&
operator++()
;
raw_storage_iterator<_OutputIterator, _Tp>
operator++(int)
;
};
}
#define _CONCURRENCE_H 1
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
enum _Lock_policy { _S_single, _S_mutex, _S_atomic };
static const _Lock_policy __default_lock_policy =
_S_atomic;
class __concurrence_lock_error : public std::exception
{
public:
virtual char const*
what() const throw()
;
};
class __concurrence_unlock_error : public std::exception
{
public:
virtual char const*
what() const throw()
;
};
class __concurrence_broadcast_error : public std::exception
{
public:
virtual char const*
what() const throw()
;
};
class __concurrence_wait_error : public std::exception
{
public:
virtual char const*
what() const throw()
;
};
void
__throw_concurrence_lock_error()
;
void
__throw_concurrence_unlock_error()
;
void
__throw_concurrence_broadcast_error()
;
void
__throw_concurrence_wait_error()
;
class __mutex
{
private:
__gthread_mutex_t _M_mutex = { { 0, 0, 0, 0, 0, 0, 0, { 0, 0 } } };
__mutex(const __mutex&);
__mutex& operator=(const __mutex&);
public:
__mutex()
;
void lock()
;
void unlock()
;
__gthread_mutex_t* gthread_mutex(void)
;
};
class __recursive_mutex
{
private:
__gthread_recursive_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, 0, 0, { 0, 0 } } };
__recursive_mutex(const __recursive_mutex&);
__recursive_mutex& operator=(const __recursive_mutex&);
public:
__recursive_mutex()
;
void lock()
;
void unlock()
;
__gthread_recursive_mutex_t* gthread_recursive_mutex(void)
;
};
class __scoped_lock
{
public:
typedef __mutex __mutex_type;
private:
__mutex_type& _M_device;
__scoped_lock(const __scoped_lock&);
__scoped_lock& operator=(const __scoped_lock&);
public:
explicit __scoped_lock(__mutex_type& __name)
;
~__scoped_lock() throw()
;
};
class __cond
{
private:
__gthread_cond_t _M_cond = { { 0, 0, 0, 0, 0, (void *) 0, 0, 0 } };
__cond(const __cond&);
__cond& operator=(const __cond&);
public:
__cond()
;
void broadcast()
;
void wait(__mutex *mutex)
;
void wait_recursive(__recursive_mutex *mutex)
;
};
}
#define _USES_ALLOCATOR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
struct allocator_arg_t { };
constexpr allocator_arg_t allocator_arg = allocator_arg_t();
template<typename _Tp> class __has_allocator_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::allocator_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_allocator_type : public __has_allocator_type_helper <typename remove_cv<_Tp>::type>::type { };
template<typename _Tp, typename _Alloc,
bool = __has_allocator_type<_Tp>::value>
struct __uses_allocator_helper
: false_type { };
template<typename _Tp, typename _Alloc>
struct __uses_allocator_helper<_Tp, _Alloc, true>
: is_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
{ };
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>
__uses_alloc_t<_Tp, _Alloc, _Args...>
__use_alloc(const _Alloc& __a)
;
}
#define _GLIBCXX_FUNCTIONAL 1
#define _GLIBCXX_TUPLE 1
#define _GLIBCXX_ARRAY 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp, std::size_t _Nm>
struct __array_traits
{
typedef _Tp _Type[_Nm];
static constexpr _Tp&
_S_ref(const _Type& __t, std::size_t __n) noexcept
{ return const_cast<_Tp&>(__t[__n]); }
};
template<typename _Tp>
struct __array_traits<_Tp, 0>
{
struct _Type { };
static constexpr _Tp&
_S_ref(const _Type&, std::size_t) noexcept
{ return *static_cast<_Tp*>(nullptr); }
};
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)
;
void
swap(array& __other)
noexcept(noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())))
{ 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 std::__addressof(_AT_Type::_S_ref(_M_elems, 0)); }
const_pointer
data() const noexcept
{ return std::__addressof(_AT_Type::_S_ref(_M_elems, 0)); }
};
template<typename _Tp, std::size_t _Nm>
bool
operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
;
template<typename _Tp, std::size_t _Nm>
bool
operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
;
template<typename _Tp, std::size_t _Nm>
bool
operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
;
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 void
swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
noexcept(noexcept(__one.swap(__two)))
{ __one.swap(__two); }
template<std::size_t _Int, typename _Tp, std::size_t _Nm>
constexpr _Tp&
get(array<_Tp, _Nm>& __arr) noexcept
{
static_assert(_Int < _Nm, "index is out of 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, "index is out of 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, "index is out of 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;
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<std::size_t _Idx, typename _Head, bool _IsEmptyNotFinal>
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;
};
template<std::size_t _Idx, typename... _Elements>
struct _Tuple_impl;
template<std::size_t _Idx>
struct _Tuple_impl<_Idx>
{
template<std::size_t, typename...> friend class _Tuple_impl;
_Tuple_impl() = default;
template<typename _Alloc>
_Tuple_impl(allocator_arg_t, const _Alloc&) { }
template<typename _Alloc>
_Tuple_impl(allocator_arg_t, const _Alloc&, const _Tuple_impl&) { }
template<typename _Alloc>
_Tuple_impl(allocator_arg_t, const _Alloc&, _Tuple_impl&&) { }
protected:
void _M_swap(_Tuple_impl&) noexcept { }
};
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, typename... _Tail>
struct _Tuple_impl<_Idx, _Head, _Tail...>
: public _Tuple_impl<_Idx + 1, _Tail...>,
private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value>
{
template<std::size_t, typename...> friend class _Tuple_impl;
typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _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(noexcept(swap(std::declval<_Head&>(),
std::declval<_Head&>()))
&& 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<typename... _Elements>
class tuple : public _Tuple_impl<0, _Elements...>
{
typedef _Tuple_impl<0, _Elements...> _Inherited;
public:
constexpr tuple()
: _Inherited() { }
explicit
constexpr tuple(const _Elements&... __elements)
: _Inherited(__elements...) { }
template<typename... _UElements, typename = typename
enable_if<__and_<is_convertible<_UElements,
_Elements>...>::value>::type>
explicit
constexpr tuple(_UElements&&... __elements)
: _Inherited(std::forward<_UElements>(__elements)...) { }
constexpr tuple(const tuple&) = default;
constexpr tuple(tuple&&) = default;
template<typename... _UElements, typename = typename
enable_if<__and_<is_convertible<const _UElements&,
_Elements>...>::value>::type>
constexpr tuple(const tuple<_UElements...>& __in)
: _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
{ }
template<typename... _UElements, typename = typename
enable_if<__and_<is_convertible<_UElements,
_Elements>...>::value>::type>
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>
tuple(allocator_arg_t __tag, const _Alloc& __a,
const _Elements&... __elements)
: _Inherited(__tag, __a, __elements...) { }
template<typename _Alloc, typename... _UElements, typename = typename
enable_if<sizeof...(_UElements)
== sizeof...(_Elements)>::type>
tuple(allocator_arg_t __tag, const _Alloc& __a,
_UElements&&... __elements)
: _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
{ }
template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
: _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
: _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
template<typename _Alloc, typename... _UElements, typename = typename
enable_if<sizeof...(_UElements)
== sizeof...(_Elements)>::type>
tuple(allocator_arg_t __tag, const _Alloc& __a,
const tuple<_UElements...>& __in)
: _Inherited(__tag, __a,
static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
{ }
template<typename _Alloc, typename... _UElements, typename = typename
enable_if<sizeof...(_UElements)
== sizeof...(_Elements)>::type>
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 = typename
enable_if<sizeof...(_UElements)
== sizeof...(_Elements)>::type>
tuple&
operator=(const tuple<_UElements...>& __in)
{
static_cast<_Inherited&>(*this) = __in;
return *this;
}
template<typename... _UElements, typename = typename
enable_if<sizeof...(_UElements)
== sizeof...(_Elements)>::type>
tuple&
operator=(tuple<_UElements...>&& __in)
{
static_cast<_Inherited&>(*this) = std::move(__in);
return *this;
}
void
swap(tuple& __in)
noexcept(noexcept(__in._M_swap(__in)))
{ _Inherited::_M_swap(__in); }
};
template<>
class tuple<>
{
public:
void swap(tuple&) noexcept { }
};
template<typename _T1, typename _T2>
class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
{
typedef _Tuple_impl<0, _T1, _T2> _Inherited;
public:
constexpr tuple()
: _Inherited() { }
explicit
constexpr tuple(const _T1& __a1, const _T2& __a2)
: _Inherited(__a1, __a2) { }
template<typename _U1, typename _U2, typename = typename
enable_if<__and_<is_convertible<_U1, _T1>,
is_convertible<_U2, _T2>>::value>::type>
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 = typename
enable_if<__and_<is_convertible<const _U1&, _T1>,
is_convertible<const _U2&, _T2>>::value>::type>
constexpr tuple(const tuple<_U1, _U2>& __in)
: _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
template<typename _U1, typename _U2, typename = typename
enable_if<__and_<is_convertible<_U1, _T1>,
is_convertible<_U2, _T2>>::value>::type>
constexpr tuple(tuple<_U1, _U2>&& __in)
: _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
template<typename _U1, typename _U2, typename = typename
enable_if<__and_<is_convertible<const _U1&, _T1>,
is_convertible<const _U2&, _T2>>::value>::type>
constexpr tuple(const pair<_U1, _U2>& __in)
: _Inherited(__in.first, __in.second) { }
template<typename _U1, typename _U2, typename = typename
enable_if<__and_<is_convertible<_U1, _T1>,
is_convertible<_U2, _T2>>::value>::type>
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>
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>
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>
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>
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>
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>
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)
;
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<std::size_t __i, typename _Tp>
struct tuple_element;
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<std::size_t __i, typename _Tp>
using __tuple_element_t = typename tuple_element<__i, _Tp>::type;
template<std::size_t __i, typename _Tp>
struct tuple_element<__i, const _Tp>
{
typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type;
};
template<std::size_t __i, typename _Tp>
struct tuple_element<__i, volatile _Tp>
{
typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type;
};
template<std::size_t __i, typename _Tp>
struct tuple_element<__i, const volatile _Tp>
{
typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type;
};
template<typename _Tp>
struct tuple_size;
template<typename _Tp>
struct tuple_size<const _Tp>
: integral_constant<size_t, tuple_size<_Tp>::value> { };
template<typename _Tp>
struct tuple_size<volatile _Tp>
: integral_constant<size_t, tuple_size<_Tp>::value> { };
template<typename _Tp>
struct tuple_size<const volatile _Tp>
: integral_constant<size_t, tuple_size<_Tp>::value> { };
template<typename... _Elements>
struct tuple_size<tuple<_Elements...>>
: public integral_constant<std::size_t, sizeof...(_Elements)> { };
template<std::size_t __i, typename _Head, typename... _Tail>
constexpr _Head&
__get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
{ return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
template<std::size_t __i, typename _Head, typename... _Tail>
constexpr const _Head&
__get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
{ return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
template<std::size_t __i, typename... _Elements>
constexpr __tuple_element_t<__i, tuple<_Elements...>>&
get(tuple<_Elements...>& __t) noexcept
{ return std::__get_helper<__i>(__t); }
template<std::size_t __i, typename... _Elements>
constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
get(const tuple<_Elements...>& __t) noexcept
{ return std::__get_helper<__i>(__t); }
template<std::size_t __i, typename... _Elements>
constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
get(tuple<_Elements...>&& __t) noexcept
{
typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
return std::forward<__element_type&&>(std::get<__i>(__t));
}
template<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>
tuple<_Elements&&...>
forward_as_tuple(_Elements&&... __args) noexcept
{ return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
template<typename>
struct __is_tuple_like_impl : false_type
{ };
template<typename... _Tps>
struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
{ };
template<typename _T1, typename _T2>
struct __is_tuple_like_impl<pair<_T1, _T2>> : true_type
{ };
template<typename _Tp, std::size_t _Nm>
struct __is_tuple_like_impl<array<_Tp, _Nm>> : true_type
{ };
template<typename _Tp>
struct __is_tuple_like
: public __is_tuple_like_impl<typename std::remove_cv
<typename std::remove_reference<_Tp>::type>::type>::type
{ };
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>
inline tuple<_Elements&...>
tie(_Elements&... __args) noexcept
{ return tuple<_Elements&...>(__args...); }
template<typename... _Elements>
inline void
swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
struct _Swallow_assign
{
template<class _Tp>
const _Swallow_assign&
operator=(const _Tp&) const
{ return *this; }
};
const _Swallow_assign ignore{};
template<typename... _Types, typename _Alloc>
struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _MemberPointer>
class _Mem_fn;
template<typename _Tp, typename _Class>
_Mem_fn<_Tp _Class::*>
mem_fn(_Tp _Class::*) noexcept;
template<typename _Tp> class __has_result_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::result_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_result_type : public __has_result_type_helper <typename remove_cv<_Tp>::type>::type { };
template<bool _Has_result_type, typename _Functor>
struct _Maybe_get_result_type
{ };
template<typename _Functor>
struct _Maybe_get_result_type<true, _Functor>
{ typedef typename _Functor::result_type result_type; };
template<typename _Functor>
struct _Weak_result_type_impl
: _Maybe_get_result_type<__has_result_type<_Functor>::value, _Functor>
{ };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...)>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......)>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...) const>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......) const>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)
const volatile>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)
const volatile>
{ typedef _Res result_type; };
template<typename _Functor>
struct _Weak_result_type
: _Weak_result_type_impl<typename remove_cv<_Functor>::type>
{ };
template<typename _Functor, typename... _Args>
typename enable_if<
(!is_member_pointer<_Functor>::value
&& !is_function<_Functor>::value
&& !is_function<typename remove_pointer<_Functor>::type>::value),
typename result_of<_Functor&(_Args&&...)>::type
>::type
__invoke(_Functor& __f, _Args&&... __args)
;
template<typename _Functor, typename... _Args>
typename enable_if<
(is_member_pointer<_Functor>::value
&& !is_function<_Functor>::value
&& !is_function<typename remove_pointer<_Functor>::type>::value),
typename result_of<_Functor(_Args&&...)>::type
>::type
__invoke(_Functor& __f, _Args&&... __args)
;
template<typename _Functor, typename... _Args>
typename enable_if<
(is_pointer<_Functor>::value
&& is_function<typename remove_pointer<_Functor>::type>::value),
typename result_of<_Functor(_Args&&...)>::type
>::type
__invoke(_Functor __f, _Args&&... __args)
;
template<bool _Unary, bool _Binary, typename _Tp>
struct _Reference_wrapper_base_impl;
template<typename _Tp>
struct _Reference_wrapper_base_impl<false, false, _Tp>
: _Weak_result_type<_Tp>
{ };
template<typename _Tp>
struct _Reference_wrapper_base_impl<true, false, _Tp>
: _Weak_result_type<_Tp>
{
typedef typename _Tp::argument_type argument_type;
};
template<typename _Tp>
struct _Reference_wrapper_base_impl<false, true, _Tp>
: _Weak_result_type<_Tp>
{
typedef typename _Tp::first_argument_type first_argument_type;
typedef typename _Tp::second_argument_type second_argument_type;
};
template<typename _Tp>
struct _Reference_wrapper_base_impl<true, true, _Tp>
: _Weak_result_type<_Tp>
{
typedef typename _Tp::argument_type argument_type;
typedef typename _Tp::first_argument_type first_argument_type;
typedef typename _Tp::second_argument_type second_argument_type;
};
template<typename _Tp> class __has_argument_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::argument_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_argument_type : public __has_argument_type_helper <typename remove_cv<_Tp>::type>::type { };
template<typename _Tp> class __has_first_argument_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::first_argument_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_first_argument_type : public __has_first_argument_type_helper <typename remove_cv<_Tp>::type>::type { };
template<typename _Tp> class __has_second_argument_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::second_argument_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_second_argument_type : public __has_second_argument_type_helper <typename remove_cv<_Tp>::type>::type { };
template<typename _Tp>
struct _Reference_wrapper_base
: _Reference_wrapper_base_impl<
__has_argument_type<_Tp>::value,
__has_first_argument_type<_Tp>::value
&& __has_second_argument_type<_Tp>::value,
_Tp>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1)>
: unary_function<_T1, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1) const>
: unary_function<_T1, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1) volatile>
: unary_function<_T1, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1) const volatile>
: unary_function<_T1, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2)>
: binary_function<_T1, _T2, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2) const>
: binary_function<_T1, _T2, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
: binary_function<_T1, _T2, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
: binary_function<_T1, _T2, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(*)(_T1)>
: unary_function<_T1, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
: binary_function<_T1, _T2, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)()>
: unary_function<_T1*, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
: binary_function<_T1*, _T2, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)() const>
: unary_function<const _T1*, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
: binary_function<const _T1*, _T2, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
: unary_function<volatile _T1*, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
: binary_function<volatile _T1*, _T2, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
: unary_function<const volatile _T1*, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
: binary_function<const volatile _T1*, _T2, _Res>
{ };
template<typename _Tp>
class reference_wrapper
: public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
{
_Tp* _M_data;
public:
typedef _Tp type;
reference_wrapper(_Tp& __indata) noexcept
: _M_data(std::__addressof(__indata))
{ }
reference_wrapper(_Tp&&) = delete;
reference_wrapper(const reference_wrapper<_Tp>& __inref) noexcept
: _M_data(__inref._M_data)
{ }
reference_wrapper&
operator=(const reference_wrapper<_Tp>& __inref) noexcept
{
_M_data = __inref._M_data;
return *this;
}
operator _Tp&() const noexcept
{ return this->get(); }
_Tp&
get() const noexcept
{ return *_M_data; }
template<typename... _Args>
typename result_of<_Tp&(_Args&&...)>::type
operator()(_Args&&... __args) const
{
return __invoke(get(), std::forward<_Args>(__args)...);
}
};
template<typename _Tp>
inline reference_wrapper<_Tp>
ref(_Tp& __t) noexcept
{ return reference_wrapper<_Tp>(__t); }
template<typename _Tp>
inline reference_wrapper<const _Tp>
cref(const _Tp& __t) noexcept
{ return reference_wrapper<const _Tp>(__t); }
template<typename _Tp>
void ref(const _Tp&&) = delete;
template<typename _Tp>
void cref(const _Tp&&) = delete;
template<typename _Tp>
inline reference_wrapper<_Tp>
ref(reference_wrapper<_Tp> __t) noexcept
{ return ref(__t.get()); }
template<typename _Tp>
inline reference_wrapper<const _Tp>
cref(reference_wrapper<_Tp> __t) noexcept
{ return cref(__t.get()); }
template<typename... _Types>
struct _Pack : integral_constant<size_t, sizeof...(_Types)>
{ };
template<typename _From, typename _To, bool = _From::value == _To::value>
struct _AllConvertible : false_type
{ };
template<typename... _From, typename... _To>
struct _AllConvertible<_Pack<_From...>, _Pack<_To...>, true>
: __and_<is_convertible<_From, _To>...>
{ };
template<typename _Tp1, typename _Tp2>
using _NotSame = __not_<is_same<typename std::decay<_Tp1>::type,
typename std::decay<_Tp2>::type>>;
template<typename _Res, typename... _ArgTypes>
struct _Maybe_unary_or_binary_function { };
template<typename _Res, typename _T1>
struct _Maybe_unary_or_binary_function<_Res, _T1>
: std::unary_function<_T1, _Res> { };
template<typename _Res, typename _T1, typename _T2>
struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
: std::binary_function<_T1, _T2, _Res> { };
template<typename _Res, typename _Class, typename... _ArgTypes>
class _Mem_fn<_Res (_Class::*)(_ArgTypes...)>
: public _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>
{
typedef _Res (_Class::*_Functor)(_ArgTypes...);
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __object, const volatile _Class *,
_Args&&... __args) const
;
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
;
template<typename... _Args>
using _RequireValidArgs
= _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs2
= _Require<_NotSame<_Class, _Tp>, _NotSame<_Class*, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs3
= _Require<is_base_of<_Class, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
public:
typedef _Res result_type;
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(_Class& __object, _Args&&... __args) const
{ return (__object.*__pmf)(std::forward<_Args>(__args)...); }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(_Class&& __object, _Args&&... __args) const
{
return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
}
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(_Class* __object, _Args&&... __args) const
{ return (__object->*__pmf)(std::forward<_Args>(__args)...); }
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs2<_Tp, _Args...>>
_Res
operator()(_Tp&& __object, _Args&&... __args) const
{
return _M_call(std::forward<_Tp>(__object), &__object,
std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs3<_Tp, _Args...>>
_Res
operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
{ return operator()(__ref.get(), std::forward<_Args>(__args)...); }
private:
_Functor __pmf;
};
template<typename _Res, typename _Class, typename... _ArgTypes>
class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const>
: public _Maybe_unary_or_binary_function<_Res, const _Class*,
_ArgTypes...>
{
typedef _Res (_Class::*_Functor)(_ArgTypes...) const;
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __object, const volatile _Class *,
_Args&&... __args) const
{
return (std::forward<_Tp>(__object).*__pmf)
(std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
{ return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }
template<typename... _Args>
using _RequireValidArgs
= _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs2
= _Require<_NotSame<_Class, _Tp>, _NotSame<const _Class*, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs3
= _Require<is_base_of<_Class, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
public:
typedef _Res result_type;
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(const _Class& __object, _Args&&... __args) const
{ return (__object.*__pmf)(std::forward<_Args>(__args)...); }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(const _Class&& __object, _Args&&... __args) const
{
return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
}
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(const _Class* __object, _Args&&... __args) const
{ return (__object->*__pmf)(std::forward<_Args>(__args)...); }
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs2<_Tp, _Args...>>
_Res operator()(_Tp&& __object, _Args&&... __args) const
{
return _M_call(std::forward<_Tp>(__object), &__object,
std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs3<_Tp, _Args...>>
_Res
operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
{ return operator()(__ref.get(), std::forward<_Args>(__args)...); }
private:
_Functor __pmf;
};
template<typename _Res, typename _Class, typename... _ArgTypes>
class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile>
: public _Maybe_unary_or_binary_function<_Res, volatile _Class*,
_ArgTypes...>
{
typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile;
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __object, const volatile _Class *,
_Args&&... __args) const
{
return (std::forward<_Tp>(__object).*__pmf)
(std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
{ return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }
template<typename... _Args>
using _RequireValidArgs
= _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs2
= _Require<_NotSame<_Class, _Tp>, _NotSame<volatile _Class*, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs3
= _Require<is_base_of<_Class, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
public:
typedef _Res result_type;
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(volatile _Class& __object, _Args&&... __args) const
{ return (__object.*__pmf)(std::forward<_Args>(__args)...); }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(volatile _Class&& __object, _Args&&... __args) const
{
return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
}
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(volatile _Class* __object, _Args&&... __args) const
{ return (__object->*__pmf)(std::forward<_Args>(__args)...); }
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs2<_Tp, _Args...>>
_Res
operator()(_Tp&& __object, _Args&&... __args) const
{
return _M_call(std::forward<_Tp>(__object), &__object,
std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs3<_Tp, _Args...>>
_Res
operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
{ return operator()(__ref.get(), std::forward<_Args>(__args)...); }
private:
_Functor __pmf;
};
template<typename _Res, typename _Class, typename... _ArgTypes>
class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile>
: public _Maybe_unary_or_binary_function<_Res, const volatile _Class*,
_ArgTypes...>
{
typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile;
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __object, const volatile _Class *,
_Args&&... __args) const
{
return (std::forward<_Tp>(__object).*__pmf)
(std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
{ return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }
template<typename... _Args>
using _RequireValidArgs
= _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs2
= _Require<_NotSame<_Class, _Tp>,
_NotSame<const volatile _Class*, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs3
= _Require<is_base_of<_Class, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
public:
typedef _Res result_type;
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(const volatile _Class& __object, _Args&&... __args) const
{ return (__object.*__pmf)(std::forward<_Args>(__args)...); }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(const volatile _Class&& __object, _Args&&... __args) const
{
return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
}
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(const volatile _Class* __object, _Args&&... __args) const
{ return (__object->*__pmf)(std::forward<_Args>(__args)...); }
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs2<_Tp, _Args...>>
_Res operator()(_Tp&& __object, _Args&&... __args) const
{
return _M_call(std::forward<_Tp>(__object), &__object,
std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs3<_Tp, _Args...>>
_Res
operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
{ return operator()(__ref.get(), std::forward<_Args>(__args)...); }
private:
_Functor __pmf;
};
template<typename _Tp, bool>
struct _Mem_fn_const_or_non
{
typedef const _Tp& type;
};
template<typename _Tp>
struct _Mem_fn_const_or_non<_Tp, false>
{
typedef _Tp& type;
};
template<typename _Res, typename _Class>
class _Mem_fn<_Res _Class::*>
{
using __pm_type = _Res _Class::*;
template<typename _Tp>
auto
_M_call(_Tp&& __object, const _Class *) const noexcept
-> decltype(std::forward<_Tp>(__object).*std::declval<__pm_type&>())
{ return std::forward<_Tp>(__object).*__pm; }
template<typename _Tp, typename _Up>
auto
_M_call(_Tp&& __object, _Up * const *) const noexcept
-> decltype((*std::forward<_Tp>(__object)).*std::declval<__pm_type&>())
{ return (*std::forward<_Tp>(__object)).*__pm; }
template<typename _Tp>
auto
_M_call(_Tp&& __ptr, const volatile void*) const
noexcept(noexcept((*__ptr).*std::declval<__pm_type&>()))
-> decltype((*__ptr).*std::declval<__pm_type&>())
{ return (*__ptr).*__pm; }
public:
explicit
_Mem_fn(_Res _Class::*__pm) noexcept : __pm(__pm) { }
_Res&
operator()(_Class& __object) const noexcept
{ return __object.*__pm; }
const _Res&
operator()(const _Class& __object) const noexcept
{ return __object.*__pm; }
_Res&&
operator()(_Class&& __object) const noexcept
{ return std::forward<_Class>(__object).*__pm; }
const _Res&&
operator()(const _Class&& __object) const noexcept
{ return std::forward<const _Class>(__object).*__pm; }
_Res&
operator()(_Class* __object) const noexcept
{ return __object->*__pm; }
const _Res&
operator()(const _Class* __object) const noexcept
{ return __object->*__pm; }
template<typename _Tp, typename _Req = _Require<_NotSame<_Class*, _Tp>>>
auto
operator()(_Tp&& __unknown) const
noexcept(noexcept(std::declval<_Mem_fn*>()->_M_call
(std::forward<_Tp>(__unknown), &__unknown)))
-> decltype(this->_M_call(std::forward<_Tp>(__unknown), &__unknown))
{ return _M_call(std::forward<_Tp>(__unknown), &__unknown); }
template<typename _Tp, typename _Req = _Require<is_base_of<_Class, _Tp>>>
auto
operator()(reference_wrapper<_Tp> __ref) const
noexcept(noexcept(std::declval<_Mem_fn&>()(__ref.get())))
-> decltype((*this)(__ref.get()))
{ return (*this)(__ref.get()); }
private:
_Res _Class::*__pm;
};
template<typename _Tp, typename _Class>
inline _Mem_fn<_Tp _Class::*>
mem_fn(_Tp _Class::* __pm) noexcept
{
return _Mem_fn<_Tp _Class::*>(__pm);
}
template<typename _Tp>
struct is_bind_expression
: public false_type { };
template<typename _Tp>
struct is_placeholder
: public integral_constant<int, 0>
{ };
template<int _Num> struct _Placeholder { };
namespace placeholders
{
extern const _Placeholder<1> _1;
extern const _Placeholder<2> _2;
extern const _Placeholder<3> _3;
extern const _Placeholder<4> _4;
extern const _Placeholder<5> _5;
extern const _Placeholder<6> _6;
extern const _Placeholder<7> _7;
extern const _Placeholder<8> _8;
extern const _Placeholder<9> _9;
extern const _Placeholder<10> _10;
extern const _Placeholder<11> _11;
extern const _Placeholder<12> _12;
extern const _Placeholder<13> _13;
extern const _Placeholder<14> _14;
extern const _Placeholder<15> _15;
extern const _Placeholder<16> _16;
extern const _Placeholder<17> _17;
extern const _Placeholder<18> _18;
extern const _Placeholder<19> _19;
extern const _Placeholder<20> _20;
extern const _Placeholder<21> _21;
extern const _Placeholder<22> _22;
extern const _Placeholder<23> _23;
extern const _Placeholder<24> _24;
extern const _Placeholder<25> _25;
extern const _Placeholder<26> _26;
extern const _Placeholder<27> _27;
extern const _Placeholder<28> _28;
extern const _Placeholder<29> _29;
}
template<int _Num>
struct is_placeholder<_Placeholder<_Num> >
: public integral_constant<int, _Num>
{ };
template<int _Num>
struct is_placeholder<const _Placeholder<_Num> >
: public integral_constant<int, _Num>
{ };
struct _No_tuple_element;
template<std::size_t __i, typename _Tuple, bool _IsSafe>
struct _Safe_tuple_element_impl
: tuple_element<__i, _Tuple> { };
template<std::size_t __i, typename _Tuple>
struct _Safe_tuple_element_impl<__i, _Tuple, false>
{
typedef _No_tuple_element type;
};
template<std::size_t __i, typename _Tuple>
struct _Safe_tuple_element
: _Safe_tuple_element_impl<__i, _Tuple,
(__i < tuple_size<_Tuple>::value)>
{ };
template<typename _Arg,
bool _IsBindExp = is_bind_expression<_Arg>::value,
bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
class _Mu;
template<typename _Tp>
class _Mu<reference_wrapper<_Tp>, false, false>
{
public:
typedef _Tp& result_type;
template<typename _CVRef, typename _Tuple>
result_type
operator()(_CVRef& __arg, _Tuple&) const volatile
{ return __arg.get(); }
};
template<typename _Arg>
class _Mu<_Arg, true, false>
{
public:
template<typename _CVArg, typename... _Args>
auto
operator()(_CVArg& __arg,
tuple<_Args...>& __tuple) const volatile
-> decltype(__arg(declval<_Args>()...))
{
typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
_Indexes;
return this->__call(__arg, __tuple, _Indexes());
}
private:
template<typename _CVArg, typename... _Args, std::size_t... _Indexes>
auto
__call(_CVArg& __arg, tuple<_Args...>& __tuple,
const _Index_tuple<_Indexes...>&) const volatile
-> decltype(__arg(declval<_Args>()...))
{
return __arg(std::forward<_Args>(std::get<_Indexes>(__tuple))...);
}
};
template<typename _Arg>
class _Mu<_Arg, false, true>
{
public:
template<typename _Signature> class result;
template<typename _CVMu, typename _CVArg, typename _Tuple>
class result<_CVMu(_CVArg, _Tuple)>
{
typedef typename _Safe_tuple_element<(is_placeholder<_Arg>::value
- 1), _Tuple>::type
__base_type;
public:
typedef typename add_rvalue_reference<__base_type>::type type;
};
template<typename _Tuple>
typename result<_Mu(_Arg, _Tuple)>::type
operator()(const volatile _Arg&, _Tuple& __tuple) const volatile
{
return std::forward<typename result<_Mu(_Arg, _Tuple)>::type>(
::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple));
}
};
template<typename _Arg>
class _Mu<_Arg, false, false>
{
public:
template<typename _Signature> struct result;
template<typename _CVMu, typename _CVArg, typename _Tuple>
struct result<_CVMu(_CVArg, _Tuple)>
{
typedef typename add_lvalue_reference<_CVArg>::type type;
};
template<typename _CVArg, typename _Tuple>
_CVArg&&
operator()(_CVArg&& __arg, _Tuple&) const volatile
{ return std::forward<_CVArg>(__arg); }
};
template<typename _Tp>
struct _Maybe_wrap_member_pointer
{
typedef _Tp type;
static const _Tp&
__do_wrap(const _Tp& __x)
{ return __x; }
static _Tp&&
__do_wrap(_Tp&& __x)
{ return static_cast<_Tp&&>(__x); }
};
template<typename _Tp, typename _Class>
struct _Maybe_wrap_member_pointer<_Tp _Class::*>
{
typedef _Mem_fn<_Tp _Class::*> type;
static type
__do_wrap(_Tp _Class::* __pm)
{ return type(__pm); }
};
template<>
struct _Maybe_wrap_member_pointer<void>
{
typedef void type;
};
template<std::size_t _Ind, typename... _Tp>
inline auto
__volget(volatile tuple<_Tp...>& __tuple)
-> __tuple_element_t<_Ind, tuple<_Tp...>> volatile&
{ return std::get<_Ind>(const_cast<tuple<_Tp...>&>(__tuple)); }
template<std::size_t _Ind, typename... _Tp>
inline auto
__volget(const volatile tuple<_Tp...>& __tuple)
-> __tuple_element_t<_Ind, tuple<_Tp...>> const volatile&
{ return std::get<_Ind>(const_cast<const tuple<_Tp...>&>(__tuple)); }
template<typename _Signature>
struct _Bind;
template<typename _Functor, typename... _Bound_args>
class _Bind<_Functor(_Bound_args...)>
: public _Weak_result_type<_Functor>
{
typedef _Bind __self_type;
typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
_Bound_indexes;
_Functor _M_f;
tuple<_Bound_args...> _M_bound_args;
template<typename _Result, typename... _Args, std::size_t... _Indexes>
_Result
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
{
return _M_f(_Mu<_Bound_args>()
(std::get<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Result, typename... _Args, std::size_t... _Indexes>
_Result
__call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
{
return _M_f(_Mu<_Bound_args>()
(std::get<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Result, typename... _Args, std::size_t... _Indexes>
_Result
__call_v(tuple<_Args...>&& __args,
_Index_tuple<_Indexes...>) volatile
{
return _M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Result, typename... _Args, std::size_t... _Indexes>
_Result
__call_c_v(tuple<_Args...>&& __args,
_Index_tuple<_Indexes...>) const volatile
{
return _M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
public:
template<typename... _Args>
explicit _Bind(const _Functor& __f, _Args&&... __args)
: _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
{ }
template<typename... _Args>
explicit _Bind(_Functor&& __f, _Args&&... __args)
: _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
{ }
_Bind(const _Bind&) = default;
_Bind(_Bind&& __b)
: _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
{ }
template<typename... _Args, typename _Result
= decltype( std::declval<_Functor>()(
_Mu<_Bound_args>()( std::declval<_Bound_args&>(),
std::declval<tuple<_Args...>&>() )... ) )>
_Result
operator()(_Args&&... __args)
;
template<typename... _Args, typename _Result
= decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
typename add_const<_Functor>::type>::type>()(
_Mu<_Bound_args>()( std::declval<const _Bound_args&>(),
std::declval<tuple<_Args...>&>() )... ) )>
_Result
operator()(_Args&&... __args) const
;
template<typename... _Args, typename _Result
= decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
typename add_volatile<_Functor>::type>::type>()(
_Mu<_Bound_args>()( std::declval<volatile _Bound_args&>(),
std::declval<tuple<_Args...>&>() )... ) )>
_Result
operator()(_Args&&... __args) volatile
;
template<typename... _Args, typename _Result
= decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
typename add_cv<_Functor>::type>::type>()(
_Mu<_Bound_args>()( std::declval<const volatile _Bound_args&>(),
std::declval<tuple<_Args...>&>() )... ) )>
_Result
operator()(_Args&&... __args) const volatile
;
};
template<typename _Result, typename _Signature>
struct _Bind_result;
template<typename _Result, typename _Functor, typename... _Bound_args>
class _Bind_result<_Result, _Functor(_Bound_args...)>
{
typedef _Bind_result __self_type;
typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
_Bound_indexes;
_Functor _M_f;
tuple<_Bound_args...> _M_bound_args;
template<typename _Res>
struct __enable_if_void : enable_if<is_void<_Res>::value, int> { };
template<typename _Res>
struct __disable_if_void : enable_if<!is_void<_Res>::value, int> { };
template<typename _Res, typename... _Args, std::size_t... _Indexes>
_Result
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0)
;
template<typename _Res, typename... _Args, std::size_t... _Indexes>
void
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0)
;
template<typename _Res, typename... _Args, std::size_t... _Indexes>
_Result
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0) const
;
template<typename _Res, typename... _Args, std::size_t... _Indexes>
void
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0) const
;
template<typename _Res, typename... _Args, std::size_t... _Indexes>
_Result
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0) volatile
{
return _M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Res, typename... _Args, std::size_t... _Indexes>
void
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0) volatile
{
_M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Res, typename... _Args, std::size_t... _Indexes>
_Result
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0) const volatile
{
return _M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Res, typename... _Args, std::size_t... _Indexes>
void
__call(tuple<_Args...>&& __args,
_Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0) const volatile
{
_M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
public:
typedef _Result result_type;
template<typename... _Args>
explicit _Bind_result(const _Functor& __f, _Args&&... __args)
: _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
{ }
template<typename... _Args>
explicit _Bind_result(_Functor&& __f, _Args&&... __args)
: _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
{ }
_Bind_result(const _Bind_result&) = default;
_Bind_result(_Bind_result&& __b)
: _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
{ }
template<typename... _Args>
result_type
operator()(_Args&&... __args)
{
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
template<typename... _Args>
result_type
operator()(_Args&&... __args) const
{
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
template<typename... _Args>
result_type
operator()(_Args&&... __args) volatile
{
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
template<typename... _Args>
result_type
operator()(_Args&&... __args) const volatile
{
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
};
template<typename _Signature>
struct is_bind_expression<_Bind<_Signature> >
: public true_type { };
template<typename _Signature>
struct is_bind_expression<const _Bind<_Signature> >
: public true_type { };
template<typename _Signature>
struct is_bind_expression<volatile _Bind<_Signature> >
: public true_type { };
template<typename _Signature>
struct is_bind_expression<const volatile _Bind<_Signature>>
: public true_type { };
template<typename _Result, typename _Signature>
struct is_bind_expression<_Bind_result<_Result, _Signature>>
: public true_type { };
template<typename _Result, typename _Signature>
struct is_bind_expression<const _Bind_result<_Result, _Signature>>
: public true_type { };
template<typename _Result, typename _Signature>
struct is_bind_expression<volatile _Bind_result<_Result, _Signature>>
: public true_type { };
template<typename _Result, typename _Signature>
struct is_bind_expression<const volatile _Bind_result<_Result, _Signature>>
: public true_type { };
template<typename _Tp, typename _Tp2 = typename decay<_Tp>::type>
using __is_socketlike = __or_<is_integral<_Tp2>, is_enum<_Tp2>>;
template<bool _SocketLike, typename _Func, typename... _BoundArgs>
struct _Bind_helper
{
typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
__maybe_type;
typedef typename __maybe_type::type __func_type;
typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type;
};
template<typename _Func, typename... _BoundArgs>
struct _Bind_helper<true, _Func, _BoundArgs...>
{ };
template<typename _Func, typename... _BoundArgs>
inline typename
_Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
bind(_Func&& __f, _BoundArgs&&... __args)
{
typedef _Bind_helper<false, _Func, _BoundArgs...> __helper_type;
typedef typename __helper_type::__maybe_type __maybe_type;
typedef typename __helper_type::type __result_type;
return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
std::forward<_BoundArgs>(__args)...);
}
template<typename _Result, typename _Func, typename... _BoundArgs>
struct _Bindres_helper
{
typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
__maybe_type;
typedef typename __maybe_type::type __functor_type;
typedef _Bind_result<_Result,
__functor_type(typename decay<_BoundArgs>::type...)>
type;
};
template<typename _Result, typename _Func, typename... _BoundArgs>
inline
typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type
bind(_Func&& __f, _BoundArgs&&... __args)
{
typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type;
typedef typename __helper_type::__maybe_type __maybe_type;
typedef typename __helper_type::type __result_type;
return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
std::forward<_BoundArgs>(__args)...);
}
template<typename _Signature>
struct _Bind_simple;
template<typename _Callable, typename... _Args>
struct _Bind_simple<_Callable(_Args...)>
{
typedef typename result_of<_Callable(_Args...)>::type result_type;
template<typename... _Args2, typename = typename
enable_if< sizeof...(_Args) == sizeof...(_Args2)>::type>
explicit
_Bind_simple(const _Callable& __callable, _Args2&&... __args)
: _M_bound(__callable, std::forward<_Args2>(__args)...)
{ }
template<typename... _Args2, typename = typename
enable_if< sizeof...(_Args) == sizeof...(_Args2)>::type>
explicit
_Bind_simple(_Callable&& __callable, _Args2&&... __args)
: _M_bound(std::move(__callable), std::forward<_Args2>(__args)...)
{ }
_Bind_simple(const _Bind_simple&) = default;
_Bind_simple(_Bind_simple&&) = default;
result_type
operator()()
{
typedef typename _Build_index_tuple<sizeof...(_Args)>::__type _Indices;
return _M_invoke(_Indices());
}
private:
template<std::size_t... _Indices>
typename result_of<_Callable(_Args...)>::type
_M_invoke(_Index_tuple<_Indices...>)
{
return std::forward<_Callable>(std::get<0>(_M_bound))(
std::forward<_Args>(std::get<_Indices+1>(_M_bound))...);
}
std::tuple<_Callable, _Args...> _M_bound;
};
template<typename _Func, typename... _BoundArgs>
struct _Bind_simple_helper
{
typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
__maybe_type;
typedef typename __maybe_type::type __func_type;
typedef _Bind_simple<__func_type(typename decay<_BoundArgs>::type...)>
__type;
};
template<typename _Callable, typename... _Args>
typename _Bind_simple_helper<_Callable, _Args...>::__type
__bind_simple(_Callable&& __callable, _Args&&... __args)
{
typedef _Bind_simple_helper<_Callable, _Args...> __helper_type;
typedef typename __helper_type::__maybe_type __maybe_type;
typedef typename __helper_type::__type __result_type;
return __result_type(
__maybe_type::__do_wrap( std::forward<_Callable>(__callable)),
std::forward<_Args>(__args)...);
}
class bad_function_call : public std::exception
{
public:
virtual ~bad_function_call() noexcept;
const char* what() const noexcept;
};
template<typename _Tp>
struct __is_location_invariant
: __or_<is_pointer<_Tp>, is_member_pointer<_Tp>>::type
{ };
class _Undefined_class;
union _Nocopy_types
{
void* _M_object;
const void* _M_const_object;
void (*_M_function_pointer)();
void (_Undefined_class::*_M_member_pointer)();
};
union _Any_data
{
void* _M_access() { return &_M_pod_data[0]; }
const void* _M_access() const { return &_M_pod_data[0]; }
template<typename _Tp>
_Tp&
_M_access()
{ return *static_cast<_Tp*>(_M_access()); }
template<typename _Tp>
const _Tp&
_M_access() const
;
_Nocopy_types _M_unused;
char _M_pod_data[sizeof(_Nocopy_types)];
};
enum _Manager_operation
{
__get_type_info,
__get_functor_ptr,
__clone_functor,
__destroy_functor
};
template<typename _Tp>
struct _Simple_type_wrapper
{
_Simple_type_wrapper(_Tp __value) ;
_Tp __value;
};
template<typename _Tp>
struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
: __is_location_invariant<_Tp>
{ };
template<typename _Functor>
_Functor&
__callable_functor(_Functor& __f)
;
template<typename _Member, typename _Class>
_Mem_fn<_Member _Class::*>
__callable_functor(_Member _Class::* &__p)
;
template<typename _Member, typename _Class>
_Mem_fn<_Member _Class::*>
__callable_functor(_Member _Class::* const &__p)
;
template<typename _Member, typename _Class>
_Mem_fn<_Member _Class::*>
__callable_functor(_Member _Class::* volatile &__p)
;
template<typename _Member, typename _Class>
_Mem_fn<_Member _Class::*>
__callable_functor(_Member _Class::* const volatile &__p)
;
template<typename _Signature>
class function;
class _Function_base
{
public:
static const std::size_t _M_max_size = sizeof(_Nocopy_types);
static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
template<typename _Functor>
class _Base_manager
{
protected:
static const bool __stored_locally =
(__is_location_invariant<_Functor>::value
&& sizeof(_Functor) <= _M_max_size
&& __alignof__(_Functor) <= _M_max_align
&& (_M_max_align % __alignof__(_Functor) == 0));
typedef integral_constant<bool, __stored_locally> _Local_storage;
static _Functor*
_M_get_pointer(const _Any_data& __source)
;
static void
_M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
;
static void
_M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
;
static void
_M_destroy(_Any_data& __victim, true_type)
;
static void
_M_destroy(_Any_data& __victim, false_type)
;
public:
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
_Manager_operation __op)
;
static void
_M_init_functor(_Any_data& __functor, _Functor&& __f)
;
template<typename _Signature>
static bool
_M_not_empty_function(const function<_Signature>& __f)
;
template<typename _Tp>
static bool
_M_not_empty_function(_Tp* const& __fp)
;
template<typename _Class, typename _Tp>
static bool
_M_not_empty_function(_Tp _Class::* const& __mp)
;
template<typename _Tp>
static bool
_M_not_empty_function(const _Tp&)
;
private:
static void
_M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
;
static void
_M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
;
};
template<typename _Functor>
class _Ref_manager : public _Base_manager<_Functor*>
{
typedef _Function_base::_Base_manager<_Functor*> _Base;
public:
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
_Manager_operation __op)
;
static void
_M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
;
};
_Function_base() ;
~_Function_base()
;
bool _M_empty() const ;
typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
_Manager_operation);
_Any_data _M_functor;
_Manager_type _M_manager;
};
template<typename _Signature, typename _Functor>
class _Function_handler;
template<typename _Res, typename _Functor, typename... _ArgTypes>
class _Function_handler<_Res(_ArgTypes...), _Functor>
: public _Function_base::_Base_manager<_Functor>
{
typedef _Function_base::_Base_manager<_Functor> _Base;
public:
static _Res
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
;
};
template<typename _Functor, typename... _ArgTypes>
class _Function_handler<void(_ArgTypes...), _Functor>
: public _Function_base::_Base_manager<_Functor>
{
typedef _Function_base::_Base_manager<_Functor> _Base;
public:
static void
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
;
};
template<typename _Res, typename _Functor, typename... _ArgTypes>
class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >
: public _Function_base::_Ref_manager<_Functor>
{
typedef _Function_base::_Ref_manager<_Functor> _Base;
public:
static _Res
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
;
};
template<typename _Functor, typename... _ArgTypes>
class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> >
: public _Function_base::_Ref_manager<_Functor>
{
typedef _Function_base::_Ref_manager<_Functor> _Base;
public:
static void
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
;
};
template<typename _Class, typename _Member, typename _Res,
typename... _ArgTypes>
class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
: public _Function_handler<void(_ArgTypes...), _Member _Class::*>
{
typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
_Base;
public:
static _Res
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
;
};
template<typename _Class, typename _Member, typename... _ArgTypes>
class _Function_handler<void(_ArgTypes...), _Member _Class::*>
: public _Function_base::_Base_manager<
_Simple_type_wrapper< _Member _Class::* > >
{
typedef _Member _Class::* _Functor;
typedef _Simple_type_wrapper<_Functor> _Wrapper;
typedef _Function_base::_Base_manager<_Wrapper> _Base;
public:
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
_Manager_operation __op)
;
static void
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
;
};
template<typename _From, typename _To>
using __check_func_return_type
= __or_<is_void<_To>, is_convertible<_From, _To>>;
template<typename _Res, typename... _ArgTypes>
class function<_Res(_ArgTypes...)>
: public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
private _Function_base
{
typedef _Res _Signature_type(_ArgTypes...);
template<typename _Functor>
using _Invoke = decltype(__callable_functor(std::declval<_Functor&>())
(std::declval<_ArgTypes>()...) );
template<typename _Tp>
using _NotSelf = __not_<is_same<_Tp, function>>;
template<typename _Functor>
using _Callable
= __and_<_NotSelf<_Functor>,
__check_func_return_type<_Invoke<_Functor>, _Res>>;
template<typename _Cond, typename _Tp>
using _Requires = typename enable_if<_Cond::value, _Tp>::type;
public:
typedef _Res result_type;
function() noexcept
: _Function_base() { }
function(nullptr_t) noexcept
: _Function_base() { }
function(const function& __x);
function(function&& __x)
;
template<typename _Functor,
typename = _Requires<_Callable<_Functor>, void>>
function(_Functor);
function&
operator=(const function& __x)
;
function&
operator=(function&& __x)
;
function&
operator=(nullptr_t)
;
template<typename _Functor>
_Requires<_Callable<typename decay<_Functor>::type>, function&>
operator=(_Functor&& __f)
{
function(std::forward<_Functor>(__f)).swap(*this);
return *this;
}
template<typename _Functor>
function&
operator=(reference_wrapper<_Functor> __f) noexcept
{
function(__f).swap(*this);
return *this;
}
void swap(function& __x)
{
std::swap(_M_functor, __x._M_functor);
std::swap(_M_manager, __x._M_manager);
std::swap(_M_invoker, __x._M_invoker);
}
explicit operator bool() const noexcept
{ return !_M_empty(); }
_Res operator()(_ArgTypes... __args) const;
const type_info& target_type() const noexcept;
template<typename _Functor> _Functor* target() noexcept;
template<typename _Functor> const _Functor* target() const noexcept;
private:
typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...);
_Invoker_type _M_invoker;
};
template<typename _Res, typename... _ArgTypes>
const type_info&
function<_Res(_ArgTypes...)>::
target_type() const noexcept
{
if (_M_manager)
{
_Any_data __typeinfo_result;
_M_manager(__typeinfo_result, _M_functor, __get_type_info);
return *__typeinfo_result._M_access<const type_info*>();
}
else
return typeid(void);
}
template<typename _Res, typename... _ArgTypes>
template<typename _Functor>
_Functor*
function<_Res(_ArgTypes...)>::
target() noexcept
{
if (typeid(_Functor) == target_type() && _M_manager)
{
_Any_data __ptr;
if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
&& !is_const<_Functor>::value)
return 0;
else
return __ptr._M_access<_Functor*>();
}
else
return 0;
}
template<typename _Res, typename... _ArgTypes>
template<typename _Functor>
const _Functor*
function<_Res(_ArgTypes...)>::
target() const noexcept
{
if (typeid(_Functor) == target_type() && _M_manager)
{
_Any_data __ptr;
_M_manager(__ptr, _M_functor, __get_functor_ptr);
return __ptr._M_access<const _Functor*>();
}
else
return 0;
}
template<typename _Res, typename... _Args>
inline bool
operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
{ return !static_cast<bool>(__f); }
template<typename _Res, typename... _Args>
inline bool
operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
{ return !static_cast<bool>(__f); }
template<typename _Res, typename... _Args>
inline bool
operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
{ return static_cast<bool>(__f); }
template<typename _Res, typename... _Args>
inline bool
operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
{ return static_cast<bool>(__f); }
template<typename _Res, typename... _Args>
inline void
swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y)
{ __x.swap(__y); }
}
#define _UNIQUE_PTR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename> class auto_ptr;
template<typename _Tp>
struct default_delete
{
constexpr default_delete() noexcept = default;
template<typename _Up, typename = typename
enable_if<is_convertible<_Up*, _Tp*>::value>::type>
default_delete(const default_delete<_Up>&) noexcept { }
void
operator()(_Tp* __ptr) const
{
static_assert(!is_void<_Tp>::value,
"can't delete pointer to incomplete type");
static_assert(sizeof(_Tp)>0,
"can't delete pointer to incomplete type");
delete __ptr;
}
};
template<typename _Tp>
struct default_delete<_Tp[]>
{
private:
template<typename _Up>
using __remove_cv = typename remove_cv<_Up>::type;
template<typename _Up>
using __is_derived_Tp
= __and_< is_base_of<_Tp, _Up>,
__not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
public:
constexpr default_delete() noexcept = default;
template<typename _Up, typename = typename
enable_if<!__is_derived_Tp<_Up>::value>::type>
default_delete(const default_delete<_Up[]>&) noexcept { }
void
operator()(_Tp* __ptr) const
{
static_assert(sizeof(_Tp)>0,
"can't delete pointer to incomplete type");
delete [] __ptr;
}
template<typename _Up>
typename enable_if<__is_derived_Tp<_Up>::value>::type
operator()(_Up*) const = delete;
};
template <typename _Tp, typename _Dp = default_delete<_Tp> >
class unique_ptr
{
class _Pointer
{
template<typename _Up>
static typename _Up::pointer __test(typename _Up::pointer*);
template<typename _Up>
static _Tp* __test(...);
typedef typename remove_reference<_Dp>::type _Del;
public:
typedef decltype(__test<_Del>(0)) type;
};
typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
__tuple_type _M_t;
public:
typedef typename _Pointer::type pointer;
typedef _Tp element_type;
typedef _Dp deleter_type;
constexpr unique_ptr() noexcept
: _M_t()
{ static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
explicit
unique_ptr(pointer __p) noexcept
: _M_t(__p, deleter_type())
{ static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
unique_ptr(pointer __p,
typename conditional<is_reference<deleter_type>::value,
deleter_type, const deleter_type&>::type __d) noexcept
: _M_t(__p, __d) { }
unique_ptr(pointer __p,
typename remove_reference<deleter_type>::type&& __d) noexcept
: _M_t(std::move(__p), std::move(__d))
{ static_assert(!std::is_reference<deleter_type>::value,
"rvalue deleter bound to reference"); }
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
unique_ptr(unique_ptr&& __u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
template<typename _Up, typename _Ep, typename = _Require<
is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
__not_<is_array<_Up>>,
typename conditional<is_reference<_Dp>::value,
is_same<_Ep, _Dp>,
is_convertible<_Ep, _Dp>>::type>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }
template<typename _Up, typename = _Require<
is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
unique_ptr(auto_ptr<_Up>&& __u) noexcept;
~unique_ptr() noexcept
{
auto& __ptr = std::get<0>(_M_t);
if (__ptr != nullptr)
get_deleter()(__ptr);
__ptr = pointer();
}
unique_ptr&
operator=(unique_ptr&& __u) noexcept
{
reset(__u.release());
get_deleter() = std::forward<deleter_type>(__u.get_deleter());
return *this;
}
template<typename _Up, typename _Ep>
typename enable_if< __and_<
is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
__not_<is_array<_Up>>
>::value,
unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
reset(__u.release());
get_deleter() = std::forward<_Ep>(__u.get_deleter());
return *this;
}
unique_ptr&
operator=(nullptr_t) noexcept
{
reset();
return *this;
}
typename add_lvalue_reference<element_type>::type
operator*() const
{
;
return *get();
}
pointer
operator->() const noexcept
{
;
return get();
}
pointer
get() const noexcept
{ return std::get<0>(_M_t); }
deleter_type&
get_deleter() noexcept
{ return std::get<1>(_M_t); }
const deleter_type&
get_deleter() const noexcept
{ return std::get<1>(_M_t); }
explicit operator bool() const noexcept
{ return get() == pointer() ? false : true; }
pointer
release() noexcept
{
pointer __p = get();
std::get<0>(_M_t) = pointer();
return __p;
}
void
reset(pointer __p = pointer()) noexcept
{
using std::swap;
swap(std::get<0>(_M_t), __p);
if (__p != pointer())
get_deleter()(__p);
}
void
swap(unique_ptr& __u) noexcept
{
using std::swap;
swap(_M_t, __u._M_t);
}
unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;
};
template<typename _Tp, typename _Dp>
class unique_ptr<_Tp[], _Dp>
{
class _Pointer
{
template<typename _Up>
static typename _Up::pointer __test(typename _Up::pointer*);
template<typename _Up>
static _Tp* __test(...);
typedef typename remove_reference<_Dp>::type _Del;
public:
typedef decltype(__test<_Del>(0)) type;
};
typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
__tuple_type _M_t;
template<typename _Up>
using __remove_cv = typename remove_cv<_Up>::type;
template<typename _Up>
using __is_derived_Tp
= __and_< is_base_of<_Tp, _Up>,
__not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
template<typename _Up, typename _Ep,
typename _Tp_pointer = typename _Pointer::type,
typename _Up_pointer = typename unique_ptr<_Up, _Ep>::pointer>
using __safe_conversion = __and_<
is_convertible<_Up_pointer, _Tp_pointer>,
is_array<_Up>,
__or_<__not_<is_pointer<_Up_pointer>>,
__not_<is_pointer<_Tp_pointer>>,
__not_<__is_derived_Tp<typename remove_extent<_Up>::type>>
>
>;
public:
typedef typename _Pointer::type pointer;
typedef _Tp element_type;
typedef _Dp deleter_type;
constexpr unique_ptr() noexcept
: _M_t()
{ static_assert(!std::is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
explicit
unique_ptr(pointer __p) noexcept
: _M_t(__p, deleter_type())
{ static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
template<typename _Up, typename = _Require<is_pointer<pointer>,
is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
explicit
unique_ptr(_Up* __p) = delete;
unique_ptr(pointer __p,
typename conditional<is_reference<deleter_type>::value,
deleter_type, const deleter_type&>::type __d) noexcept
: _M_t(__p, __d) { }
unique_ptr(pointer __p, typename
remove_reference<deleter_type>::type&& __d) noexcept
: _M_t(std::move(__p), std::move(__d))
{ static_assert(!is_reference<deleter_type>::value,
"rvalue deleter bound to reference"); }
unique_ptr(unique_ptr&& __u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
template<typename _Up, typename _Ep,
typename = _Require<__safe_conversion<_Up, _Ep>,
typename conditional<is_reference<_Dp>::value,
is_same<_Ep, _Dp>,
is_convertible<_Ep, _Dp>>::type
>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }
~unique_ptr()
{
auto& __ptr = std::get<0>(_M_t);
if (__ptr != nullptr)
get_deleter()(__ptr);
__ptr = pointer();
}
unique_ptr&
operator=(unique_ptr&& __u) noexcept
{
reset(__u.release());
get_deleter() = std::forward<deleter_type>(__u.get_deleter());
return *this;
}
template<typename _Up, typename _Ep>
typename
enable_if<__safe_conversion<_Up, _Ep>::value, unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
reset(__u.release());
get_deleter() = std::forward<_Ep>(__u.get_deleter());
return *this;
}
unique_ptr&
operator=(nullptr_t) noexcept
{
reset();
return *this;
}
typename std::add_lvalue_reference<element_type>::type
operator[](size_t __i) const
{
;
return get()[__i];
}
pointer
get() const noexcept
{ return std::get<0>(_M_t); }
deleter_type&
get_deleter() noexcept
{ return std::get<1>(_M_t); }
const deleter_type&
get_deleter() const noexcept
{ return std::get<1>(_M_t); }
explicit operator bool() const noexcept
{ return get() == pointer() ? false : true; }
pointer
release() noexcept
{
pointer __p = get();
std::get<0>(_M_t) = pointer();
return __p;
}
void
reset(pointer __p = pointer()) noexcept
{
using std::swap;
swap(std::get<0>(_M_t), __p);
if (__p != nullptr)
get_deleter()(__p);
}
template<typename _Up, typename = _Require<is_pointer<pointer>,
is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
void reset(_Up*) = delete;
void
swap(unique_ptr& __u) noexcept
{
using std::swap;
swap(_M_t, __u._M_t);
}
unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;
template<typename _Up, typename = _Require<is_pointer<pointer>,
is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
unique_ptr(_Up*, typename
conditional<is_reference<deleter_type>::value,
deleter_type, const deleter_type&>::type) = delete;
template<typename _Up, typename = _Require<is_pointer<pointer>,
is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
unique_ptr(_Up*, typename
remove_reference<deleter_type>::type&&) = delete;
};
template<typename _Tp, typename _Dp>
inline void
swap(unique_ptr<_Tp, _Dp>& __x,
unique_ptr<_Tp, _Dp>& __y) noexcept
{ __x.swap(__y); }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator==(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return __x.get() == __y.get(); }
template<typename _Tp, typename _Dp>
inline bool
operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
{ return !__x; }
template<typename _Tp, typename _Dp>
inline bool
operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
{ return !__x; }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator!=(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return __x.get() != __y.get(); }
template<typename _Tp, typename _Dp>
inline bool
operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
{ return (bool)__x; }
template<typename _Tp, typename _Dp>
inline bool
operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
{ return (bool)__x; }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator<(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{
typedef typename
std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
return std::less<_CT>()(__x.get(), __y.get());
}
template<typename _Tp, typename _Dp>
inline bool
operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
{ return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
nullptr); }
template<typename _Tp, typename _Dp>
inline bool
operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
{ return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
__x.get()); }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator<=(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return !(__y < __x); }
template<typename _Tp, typename _Dp>
inline bool
operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
{ return !(nullptr < __x); }
template<typename _Tp, typename _Dp>
inline bool
operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
{ return !(__x < nullptr); }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator>(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return (__y < __x); }
template<typename _Tp, typename _Dp>
inline bool
operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
{ return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
__x.get()); }
template<typename _Tp, typename _Dp>
inline bool
operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
{ return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
nullptr); }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator>=(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return !(__x < __y); }
template<typename _Tp, typename _Dp>
inline bool
operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
{ return !(__x < nullptr); }
template<typename _Tp, typename _Dp>
inline bool
operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
{ return !(nullptr < __x); }
template<typename _Tp, typename _Dp>
struct hash<unique_ptr<_Tp, _Dp>>
: public __hash_base<size_t, unique_ptr<_Tp, _Dp>>
{
size_t
operator()(const unique_ptr<_Tp, _Dp>& __u) const noexcept
{
typedef unique_ptr<_Tp, _Dp> _UP;
return std::hash<typename _UP::pointer>()(__u.get());
}
};
}
#define _SHARED_PTR_H 1
#define _SHARED_PTR_BASE_H 1
#define _ALLOCATED_PTR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc>
struct __allocated_ptr
{
using pointer = typename allocator_traits<_Alloc>::pointer;
using value_type = typename allocator_traits<_Alloc>::value_type;
__allocated_ptr(_Alloc& __a, pointer __ptr) noexcept
: _M_alloc(&__a), _M_ptr(__ptr)
{ }
template<typename _Ptr,
typename _Req = _Require<is_same<_Ptr, value_type*>>>
__allocated_ptr(_Alloc& __a, _Ptr __ptr)
: _M_alloc(&__a), _M_ptr(pointer_traits<pointer>::pointer_to(*__ptr))
{ }
__allocated_ptr(__allocated_ptr&& __gd) noexcept
: _M_alloc(__gd._M_alloc), _M_ptr(__gd._M_ptr)
{ __gd._M_ptr = nullptr; }
~__allocated_ptr()
{
if (_M_ptr != nullptr)
std::allocator_traits<_Alloc>::deallocate(*_M_alloc, _M_ptr, 1);
}
__allocated_ptr&
operator=(std::nullptr_t) noexcept
{
_M_ptr = nullptr;
return *this;
}
value_type* get() { return _S_raw_ptr(_M_ptr); }
private:
value_type* _S_raw_ptr(value_type* __ptr) { return __ptr; }
template<typename _Ptr>
auto _S_raw_ptr(_Ptr __ptr) -> decltype(_S_raw_ptr(__ptr.operator->()))
{ return _S_raw_ptr(__ptr.operator->()); }
_Alloc* _M_alloc;
pointer _M_ptr;
};
template<typename _Alloc>
__allocated_ptr<_Alloc>
__allocate_guarded(_Alloc& __a)
;
}
#define _ALIGNED_BUFFER_H 1
namespace __gnu_cxx
{
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()); }
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename> class auto_ptr;
class bad_weak_ptr : public std::exception
{
public:
virtual char const*
what() const noexcept;
virtual ~bad_weak_ptr() noexcept;
};
void
__throw_bad_weak_ptr()
;
using __gnu_cxx::_Lock_policy;
using __gnu_cxx::__default_lock_policy;
using __gnu_cxx::_S_single;
using __gnu_cxx::_S_mutex;
using __gnu_cxx::_S_atomic;
template<_Lock_policy _Lp>
class _Mutex_base
{
protected:
enum { _S_need_barriers = 0 };
};
template<>
class _Mutex_base<_S_mutex>
: public __gnu_cxx::__mutex
{
protected:
enum { _S_need_barriers = 1 };
};
template<_Lock_policy _Lp = __default_lock_policy>
class _Sp_counted_base
: public _Mutex_base<_Lp>
{
public:
_Sp_counted_base() noexcept
: _M_use_count(1), _M_weak_count(1) { }
virtual
~_Sp_counted_base() noexcept
{ }
virtual void
_M_dispose() noexcept = 0;
virtual void
_M_destroy() noexcept
{ delete this; }
virtual void*
_M_get_deleter(const std::type_info&) noexcept = 0;
void
_M_add_ref_copy()
;
void
_M_add_ref_lock();
bool
_M_add_ref_lock_nothrow();
void
_M_release() noexcept
{
;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
{
;
_M_dispose();
if (_Mutex_base<_Lp>::_S_need_barriers)
{
__asm __volatile ("":::"memory");
__asm __volatile ("":::"memory");
}
;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
-1) == 1)
{
;
_M_destroy();
}
}
}
void
_M_weak_add_ref() noexcept
{ __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }
void
_M_weak_release() noexcept
{
;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
{
;
if (_Mutex_base<_Lp>::_S_need_barriers)
{
__asm __volatile ("":::"memory");
__asm __volatile ("":::"memory");
}
_M_destroy();
}
}
long
_M_get_use_count() const noexcept
{
return __atomic_load_n(&_M_use_count, 0);
}
private:
_Sp_counted_base(_Sp_counted_base const&) = delete;
_Sp_counted_base& operator=(_Sp_counted_base const&) = delete;
_Atomic_word _M_use_count;
_Atomic_word _M_weak_count;
};
template<>
inline void
_Sp_counted_base<_S_single>::_M_release() noexcept
{
if (--_M_use_count == 0)
{
_M_dispose();
if (--_M_weak_count == 0)
_M_destroy();
}
}
template<>
inline void
_Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept
{ ++_M_weak_count; }
template<>
inline void
_Sp_counted_base<_S_single>::_M_weak_release() noexcept
{
if (--_M_weak_count == 0)
_M_destroy();
}
template<>
inline long
_Sp_counted_base<_S_single>::_M_get_use_count() const noexcept
{ return _M_use_count; }
template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
class __shared_ptr;
template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
class __weak_ptr;
template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
class __enable_shared_from_this;
template<typename _Tp>
class shared_ptr;
template<typename _Tp>
class weak_ptr;
template<typename _Tp>
struct owner_less;
template<typename _Tp>
class enable_shared_from_this;
template<_Lock_policy _Lp = __default_lock_policy>
class __weak_count;
template<_Lock_policy _Lp = __default_lock_policy>
class __shared_count;
template<typename _Ptr, _Lock_policy _Lp>
class _Sp_counted_ptr final : public _Sp_counted_base<_Lp>
{
public:
explicit
_Sp_counted_ptr(_Ptr __p) noexcept
: _M_ptr(__p) { }
virtual void
_M_dispose() noexcept
{ delete _M_ptr; }
virtual void
_M_destroy() noexcept
{ delete this; }
virtual void*
_M_get_deleter(const std::type_info&) noexcept
{ return nullptr; }
_Sp_counted_ptr(const _Sp_counted_ptr&) = delete;
_Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete;
private:
_Ptr _M_ptr;
};
template<>
inline void
_Sp_counted_ptr<nullptr_t, _S_single>::_M_dispose() noexcept { }
template<>
inline void
_Sp_counted_ptr<nullptr_t, _S_mutex>::_M_dispose() noexcept { }
template<>
inline void
_Sp_counted_ptr<nullptr_t, _S_atomic>::_M_dispose() noexcept { }
template<int _Nm, typename _Tp,
bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
struct _Sp_ebo_helper;
template<int _Nm, typename _Tp>
struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp
{
explicit _Sp_ebo_helper(const _Tp& __tp) ;
static _Tp&
_S_get(_Sp_ebo_helper& __eboh) ;
};
template<int _Nm, typename _Tp>
struct _Sp_ebo_helper<_Nm, _Tp, false>
{
explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { }
static _Tp&
_S_get(_Sp_ebo_helper& __eboh)
{ return __eboh._M_tp; }
private:
_Tp _M_tp;
};
template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
class _Sp_counted_deleter final : public _Sp_counted_base<_Lp>
{
class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc>
{
typedef _Sp_ebo_helper<0, _Deleter> _Del_base;
typedef _Sp_ebo_helper<1, _Alloc> _Alloc_base;
public:
_Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
: _M_ptr(__p), _Del_base(__d), _Alloc_base(__a)
{ }
_Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); }
_Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); }
_Ptr _M_ptr;
};
public:
using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_deleter>;
_Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept
: _M_impl(__p, __d, _Alloc()) { }
_Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
: _M_impl(__p, __d, __a) { }
~_Sp_counted_deleter() noexcept { }
virtual void
_M_dispose() noexcept
{ _M_impl._M_del()(_M_impl._M_ptr); }
virtual void
_M_destroy() noexcept
{
__allocator_type __a(_M_impl._M_alloc());
__allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
this->~_Sp_counted_deleter();
}
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept
{
return __ti == typeid(_Deleter) ? &_M_impl._M_del() : nullptr;
}
private:
_Impl _M_impl;
};
struct _Sp_make_shared_tag { };
template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp>
{
class _Impl : _Sp_ebo_helper<0, _Alloc>
{
typedef _Sp_ebo_helper<0, _Alloc> _A_base;
public:
explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { }
_Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); }
__gnu_cxx::__aligned_buffer<_Tp> _M_storage;
};
public:
using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>;
template<typename... _Args>
_Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
: _M_impl(__a)
{
allocator_traits<_Alloc>::construct(__a, _M_ptr(),
std::forward<_Args>(__args)...);
}
~_Sp_counted_ptr_inplace() noexcept { }
virtual void
_M_dispose() noexcept
{
allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
}
virtual void
_M_destroy() noexcept
{
__allocator_type __a(_M_impl._M_alloc());
__allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
this->~_Sp_counted_ptr_inplace();
}
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept
{
if (__ti == typeid(_Sp_make_shared_tag))
return const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
return nullptr;
}
private:
_Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); }
_Impl _M_impl;
};
template<_Lock_policy _Lp>
class __shared_count
{
public:
constexpr __shared_count() noexcept : _M_pi(0)
{ }
template<typename _Ptr>
explicit
__shared_count(_Ptr __p) : _M_pi(0)
{
try
{
_M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
}
catch(...)
{
delete __p;
throw;
}
}
template<typename _Ptr, typename _Deleter>
__shared_count(_Ptr __p, _Deleter __d)
: __shared_count(__p, std::move(__d), allocator<void>())
{ }
template<typename _Ptr, typename _Deleter, typename _Alloc>
__shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
{
typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
try
{
typename _Sp_cd_type::__allocator_type __a2(__a);
auto __guard = std::__allocate_guarded(__a2);
_Sp_cd_type* __mem = __guard.get();
::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a));
_M_pi = __mem;
__guard = nullptr;
}
catch(...)
{
__d(__p);
throw;
}
}
template<typename _Tp, typename _Alloc, typename... _Args>
__shared_count(_Sp_make_shared_tag, _Tp*, const _Alloc& __a,
_Args&&... __args)
: _M_pi(0)
{
typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
typename _Sp_cp_type::__allocator_type __a2(__a);
auto __guard = std::__allocate_guarded(__a2);
_Sp_cp_type* __mem = __guard.get();
::new (__mem) _Sp_cp_type(std::move(__a),
std::forward<_Args>(__args)...);
_M_pi = __mem;
__guard = nullptr;
}
template<typename _Tp>
explicit
__shared_count(std::auto_ptr<_Tp>&& __r);
template<typename _Tp, typename _Del>
explicit
__shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0)
{
using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
using _Del2 = typename conditional<is_reference<_Del>::value,
reference_wrapper<typename remove_reference<_Del>::type>,
_Del>::type;
using _Sp_cd_type
= _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
using _Alloc = allocator<_Sp_cd_type>;
using _Alloc_traits = allocator_traits<_Alloc>;
_Alloc __a;
_Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1);
_Alloc_traits::construct(__a, __mem, __r.release(),
__r.get_deleter());
_M_pi = __mem;
}
explicit __shared_count(const __weak_count<_Lp>& __r);
explicit __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t);
~__shared_count() noexcept
{
if (_M_pi != nullptr)
_M_pi->_M_release();
}
__shared_count(const __shared_count& __r) noexcept
: _M_pi(__r._M_pi)
{
if (_M_pi != 0)
_M_pi->_M_add_ref_copy();
}
__shared_count&
operator=(const __shared_count& __r) noexcept
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != _M_pi)
{
if (__tmp != 0)
__tmp->_M_add_ref_copy();
if (_M_pi != 0)
_M_pi->_M_release();
_M_pi = __tmp;
}
return *this;
}
void
_M_swap(__shared_count& __r) noexcept
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
}
long
_M_get_use_count() const noexcept
{ return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
bool
_M_unique() const noexcept
{ return this->_M_get_use_count() == 1; }
void*
_M_get_deleter(const std::type_info& __ti) const noexcept
{ return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; }
bool
_M_less(const __shared_count& __rhs) const noexcept
{ return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
bool
_M_less(const __weak_count<_Lp>& __rhs) const noexcept
{ return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
friend inline bool
operator==(const __shared_count& __a, const __shared_count& __b) noexcept
{ return __a._M_pi == __b._M_pi; }
private:
friend class __weak_count<_Lp>;
_Sp_counted_base<_Lp>* _M_pi;
};
template<_Lock_policy _Lp>
class __weak_count
{
public:
constexpr __weak_count() noexcept : _M_pi(0)
{ }
__weak_count(const __shared_count<_Lp>& __r) noexcept
: _M_pi(__r._M_pi)
{
if (_M_pi != 0)
_M_pi->_M_weak_add_ref();
}
__weak_count(const __weak_count<_Lp>& __r) noexcept
: _M_pi(__r._M_pi)
{
if (_M_pi != 0)
_M_pi->_M_weak_add_ref();
}
~__weak_count() noexcept
{
if (_M_pi != 0)
_M_pi->_M_weak_release();
}
__weak_count<_Lp>&
operator=(const __shared_count<_Lp>& __r) noexcept
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != 0)
__tmp->_M_weak_add_ref();
if (_M_pi != 0)
_M_pi->_M_weak_release();
_M_pi = __tmp;
return *this;
}
__weak_count<_Lp>&
operator=(const __weak_count<_Lp>& __r) noexcept
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != 0)
__tmp->_M_weak_add_ref();
if (_M_pi != 0)
_M_pi->_M_weak_release();
_M_pi = __tmp;
return *this;
}
void
_M_swap(__weak_count<_Lp>& __r) noexcept
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
}
long
_M_get_use_count() const noexcept
{ return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
bool
_M_less(const __weak_count& __rhs) const noexcept
{ return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
bool
_M_less(const __shared_count<_Lp>& __rhs) const noexcept
{ return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
friend inline bool
operator==(const __weak_count& __a, const __weak_count& __b) noexcept
{ return __a._M_pi == __b._M_pi; }
private:
friend class __shared_count<_Lp>;
_Sp_counted_base<_Lp>* _M_pi;
};
template<_Lock_policy _Lp>
inline
__shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r)
: _M_pi(__r._M_pi)
{
if (_M_pi != nullptr)
_M_pi->_M_add_ref_lock();
else
__throw_bad_weak_ptr();
}
template<_Lock_policy _Lp>
inline
__shared_count<_Lp>::
__shared_count(const __weak_count<_Lp>& __r, std::nothrow_t)
: _M_pi(__r._M_pi)
{
if (_M_pi != nullptr)
if (!_M_pi->_M_add_ref_lock_nothrow())
_M_pi = nullptr;
}
template<_Lock_policy _Lp, typename _Tp1, typename _Tp2>
void
__enable_shared_from_this_helper(const __shared_count<_Lp>&,
const __enable_shared_from_this<_Tp1,
_Lp>*, const _Tp2*) noexcept;
template<typename _Tp1, typename _Tp2>
void
__enable_shared_from_this_helper(const __shared_count<>&,
const enable_shared_from_this<_Tp1>*,
const _Tp2*) noexcept;
template<_Lock_policy _Lp>
inline void
__enable_shared_from_this_helper(const __shared_count<_Lp>&, ...) noexcept
{ }
template<typename _Tp, _Lock_policy _Lp>
class __shared_ptr
{
public:
typedef _Tp element_type;
constexpr __shared_ptr() noexcept
: _M_ptr(0), _M_refcount()
{ }
template<typename _Tp1>
explicit __shared_ptr(_Tp1* __p)
: _M_ptr(__p), _M_refcount(__p)
{
static_assert( !is_void<_Tp1>::value, "incomplete type" );
static_assert( sizeof(_Tp1) > 0, "incomplete type" );
__enable_shared_from_this_helper(_M_refcount, __p, __p);
}
template<typename _Tp1, typename _Deleter>
__shared_ptr(_Tp1* __p, _Deleter __d)
: _M_ptr(__p), _M_refcount(__p, __d)
{
__enable_shared_from_this_helper(_M_refcount, __p, __p);
}
template<typename _Tp1, typename _Deleter, typename _Alloc>
__shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)
: _M_ptr(__p), _M_refcount(__p, __d, std::move(__a))
{
__enable_shared_from_this_helper(_M_refcount, __p, __p);
}
template<typename _Deleter>
__shared_ptr(nullptr_t __p, _Deleter __d)
: _M_ptr(0), _M_refcount(__p, __d)
{ }
template<typename _Deleter, typename _Alloc>
__shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
: _M_ptr(0), _M_refcount(__p, __d, std::move(__a))
{ }
template<typename _Tp1>
__shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, _Tp* __p) noexcept
: _M_ptr(__p), _M_refcount(__r._M_refcount)
{ }
__shared_ptr(const __shared_ptr&) noexcept = default;
__shared_ptr& operator=(const __shared_ptr&) noexcept = default;
~__shared_ptr() = default;
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
__shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
{ }
__shared_ptr(__shared_ptr&& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount()
{
_M_refcount._M_swap(__r._M_refcount);
__r._M_ptr = 0;
}
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
__shared_ptr(__shared_ptr<_Tp1, _Lp>&& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount()
{
_M_refcount._M_swap(__r._M_refcount);
__r._M_ptr = 0;
}
template<typename _Tp1>
explicit __shared_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
: _M_refcount(__r._M_refcount)
{
_M_ptr = __r._M_ptr;
}
template<typename _Tp1, typename _Del>
__shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r)
: _M_ptr(__r.get()), _M_refcount()
{
auto __raw = _S_raw_ptr(__r.get());
_M_refcount = __shared_count<_Lp>(std::move(__r));
__enable_shared_from_this_helper(_M_refcount, __raw, __raw);
}
template<typename _Tp1>
__shared_ptr(std::auto_ptr<_Tp1>&& __r);
constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { }
template<typename _Tp1>
__shared_ptr&
operator=(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
{
_M_ptr = __r._M_ptr;
_M_refcount = __r._M_refcount;
return *this;
}
template<typename _Tp1>
__shared_ptr&
operator=(std::auto_ptr<_Tp1>&& __r)
{
__shared_ptr(std::move(__r)).swap(*this);
return *this;
}
__shared_ptr&
operator=(__shared_ptr&& __r) noexcept
{
__shared_ptr(std::move(__r)).swap(*this);
return *this;
}
template<class _Tp1>
__shared_ptr&
operator=(__shared_ptr<_Tp1, _Lp>&& __r) noexcept
{
__shared_ptr(std::move(__r)).swap(*this);
return *this;
}
template<typename _Tp1, typename _Del>
__shared_ptr&
operator=(std::unique_ptr<_Tp1, _Del>&& __r)
{
__shared_ptr(std::move(__r)).swap(*this);
return *this;
}
void
reset() noexcept
{ __shared_ptr().swap(*this); }
template<typename _Tp1>
void
reset(_Tp1* __p)
{
;
__shared_ptr(__p).swap(*this);
}
template<typename _Tp1, typename _Deleter>
void
reset(_Tp1* __p, _Deleter __d)
{ __shared_ptr(__p, __d).swap(*this); }
template<typename _Tp1, typename _Deleter, typename _Alloc>
void
reset(_Tp1* __p, _Deleter __d, _Alloc __a)
{ __shared_ptr(__p, __d, std::move(__a)).swap(*this); }
typename std::add_lvalue_reference<_Tp>::type
operator*() const noexcept
{
;
return *_M_ptr;
}
_Tp*
operator->() const noexcept
{
;
return _M_ptr;
}
_Tp*
get() const noexcept
{ return _M_ptr; }
explicit operator bool() const
{ return _M_ptr == 0 ? false : true; }
bool
unique() const noexcept
{ return _M_refcount._M_unique(); }
long
use_count() const noexcept
{ return _M_refcount._M_get_use_count(); }
void
swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
{
std::swap(_M_ptr, __other._M_ptr);
_M_refcount._M_swap(__other._M_refcount);
}
template<typename _Tp1>
bool
owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const
{ return _M_refcount._M_less(__rhs._M_refcount); }
template<typename _Tp1>
bool
owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const
{ return _M_refcount._M_less(__rhs._M_refcount); }
protected:
template<typename _Alloc, typename... _Args>
__shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
_Args&&... __args)
: _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a,
std::forward<_Args>(__args)...)
{
void* __p = _M_refcount._M_get_deleter(typeid(__tag));
_M_ptr = static_cast<_Tp*>(__p);
__enable_shared_from_this_helper(_M_refcount, _M_ptr, _M_ptr);
}
template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
typename... _Args>
friend __shared_ptr<_Tp1, _Lp1>
__allocate_shared(const _Alloc& __a, _Args&&... __args);
__shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t)
: _M_refcount(__r._M_refcount, std::nothrow)
{
_M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr;
}
friend class __weak_ptr<_Tp, _Lp>;
private:
void*
_M_get_deleter(const std::type_info& __ti) const noexcept
{ return _M_refcount._M_get_deleter(__ti); }
template<typename _Tp1>
static _Tp1*
_S_raw_ptr(_Tp1* __ptr)
{ return __ptr; }
template<typename _Tp1>
static auto
_S_raw_ptr(_Tp1 __ptr) -> decltype(std::__addressof(*__ptr))
{ return std::__addressof(*__ptr); }
template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept;
_Tp* _M_ptr;
__shared_count<_Lp> _M_refcount;
};
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool
operator==(const __shared_ptr<_Tp1, _Lp>& __a,
const __shared_ptr<_Tp2, _Lp>& __b) noexcept
{ return __a.get() == __b.get(); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
{ return !__a; }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
{ return !__a; }
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool
operator!=(const __shared_ptr<_Tp1, _Lp>& __a,
const __shared_ptr<_Tp2, _Lp>& __b) noexcept
{ return __a.get() != __b.get(); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
{ return (bool)__a; }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
{ return (bool)__a; }
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool
operator<(const __shared_ptr<_Tp1, _Lp>& __a,
const __shared_ptr<_Tp2, _Lp>& __b) noexcept
{
typedef typename std::common_type<_Tp1*, _Tp2*>::type _CT;
return std::less<_CT>()(__a.get(), __b.get());
}
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
{ return std::less<_Tp*>()(__a.get(), nullptr); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
{ return std::less<_Tp*>()(nullptr, __a.get()); }
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool
operator<=(const __shared_ptr<_Tp1, _Lp>& __a,
const __shared_ptr<_Tp2, _Lp>& __b) noexcept
{ return !(__b < __a); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
{ return !(nullptr < __a); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
{ return !(__a < nullptr); }
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool
operator>(const __shared_ptr<_Tp1, _Lp>& __a,
const __shared_ptr<_Tp2, _Lp>& __b) noexcept
{ return (__b < __a); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
{ return std::less<_Tp*>()(nullptr, __a.get()); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
{ return std::less<_Tp*>()(__a.get(), nullptr); }
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool
operator>=(const __shared_ptr<_Tp1, _Lp>& __a,
const __shared_ptr<_Tp2, _Lp>& __b) noexcept
{ return !(__a < __b); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
{ return !(__a < nullptr); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
{ return !(nullptr < __a); }
template<typename _Sp>
struct _Sp_less : public binary_function<_Sp, _Sp, bool>
{
bool
operator()(const _Sp& __lhs, const _Sp& __rhs) const noexcept
{
typedef typename _Sp::element_type element_type;
return std::less<element_type*>()(__lhs.get(), __rhs.get());
}
};
template<typename _Tp, _Lock_policy _Lp>
struct less<__shared_ptr<_Tp, _Lp>>
: public _Sp_less<__shared_ptr<_Tp, _Lp>>
{ };
template<typename _Tp, _Lock_policy _Lp>
inline void
swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept
{ __a.swap(__b); }
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
inline __shared_ptr<_Tp, _Lp>
static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
{ return __shared_ptr<_Tp, _Lp>(__r, static_cast<_Tp*>(__r.get())); }
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
inline __shared_ptr<_Tp, _Lp>
const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
{ return __shared_ptr<_Tp, _Lp>(__r, const_cast<_Tp*>(__r.get())); }
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
inline __shared_ptr<_Tp, _Lp>
dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
{
if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
return __shared_ptr<_Tp, _Lp>(__r, __p);
return __shared_ptr<_Tp, _Lp>();
}
template<typename _Tp, _Lock_policy _Lp>
class __weak_ptr
{
public:
typedef _Tp element_type;
constexpr __weak_ptr() noexcept
: _M_ptr(0), _M_refcount()
{ }
__weak_ptr(const __weak_ptr&) noexcept = default;
__weak_ptr& operator=(const __weak_ptr&) noexcept = default;
~__weak_ptr() = default;
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
__weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r) noexcept
: _M_refcount(__r._M_refcount)
{ _M_ptr = __r.lock().get(); }
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
__weak_ptr(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
{ }
template<typename _Tp1>
__weak_ptr&
operator=(const __weak_ptr<_Tp1, _Lp>& __r) noexcept
{
_M_ptr = __r.lock().get();
_M_refcount = __r._M_refcount;
return *this;
}
template<typename _Tp1>
__weak_ptr&
operator=(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
{
_M_ptr = __r._M_ptr;
_M_refcount = __r._M_refcount;
return *this;
}
__shared_ptr<_Tp, _Lp>
lock() const noexcept
{ return __shared_ptr<element_type, _Lp>(*this, std::nothrow); }
long
use_count() const noexcept
{ return _M_refcount._M_get_use_count(); }
bool
expired() const noexcept
{ return _M_refcount._M_get_use_count() == 0; }
template<typename _Tp1>
bool
owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const
{ return _M_refcount._M_less(__rhs._M_refcount); }
template<typename _Tp1>
bool
owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const
{ return _M_refcount._M_less(__rhs._M_refcount); }
void
reset() noexcept
{ __weak_ptr().swap(*this); }
void
swap(__weak_ptr& __s) noexcept
{
std::swap(_M_ptr, __s._M_ptr);
_M_refcount._M_swap(__s._M_refcount);
}
private:
void
_M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept
{
_M_ptr = __ptr;
_M_refcount = __refcount;
}
template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
friend class __enable_shared_from_this<_Tp, _Lp>;
friend class enable_shared_from_this<_Tp>;
_Tp* _M_ptr;
__weak_count<_Lp> _M_refcount;
};
template<typename _Tp, _Lock_policy _Lp>
inline void
swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept
{ __a.swap(__b); }
template<typename _Tp, typename _Tp1>
struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __lhs, const _Tp& __rhs) const
{ return __lhs.owner_before(__rhs); }
bool
operator()(const _Tp& __lhs, const _Tp1& __rhs) const
{ return __lhs.owner_before(__rhs); }
bool
operator()(const _Tp1& __lhs, const _Tp& __rhs) const
{ return __lhs.owner_before(__rhs); }
};
template<typename _Tp, _Lock_policy _Lp>
struct owner_less<__shared_ptr<_Tp, _Lp>>
: public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
{ };
template<typename _Tp, _Lock_policy _Lp>
struct owner_less<__weak_ptr<_Tp, _Lp>>
: public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
{ };
template<typename _Tp, _Lock_policy _Lp>
class __enable_shared_from_this
{
protected:
constexpr __enable_shared_from_this() noexcept { }
__enable_shared_from_this(const __enable_shared_from_this&) noexcept { }
__enable_shared_from_this&
operator=(const __enable_shared_from_this&) noexcept
{ return *this; }
~__enable_shared_from_this() { }
public:
__shared_ptr<_Tp, _Lp>
shared_from_this()
{ return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }
__shared_ptr<const _Tp, _Lp>
shared_from_this() const
{ return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }
private:
template<typename _Tp1>
void
_M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept
{ _M_weak_this._M_assign(__p, __n); }
template<typename _Tp1>
friend void
__enable_shared_from_this_helper(const __shared_count<_Lp>& __pn,
const __enable_shared_from_this* __pe,
const _Tp1* __px) noexcept
{
if (__pe != 0)
__pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
}
mutable __weak_ptr<_Tp, _Lp> _M_weak_this;
};
template<typename _Tp, _Lock_policy _Lp, typename _Alloc, typename... _Args>
inline __shared_ptr<_Tp, _Lp>
__allocate_shared(const _Alloc& __a, _Args&&... __args)
{
return __shared_ptr<_Tp, _Lp>(_Sp_make_shared_tag(), __a,
std::forward<_Args>(__args)...);
}
template<typename _Tp, _Lock_policy _Lp, typename... _Args>
inline __shared_ptr<_Tp, _Lp>
__make_shared(_Args&&... __args)
{
typedef typename std::remove_const<_Tp>::type _Tp_nc;
return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
std::forward<_Args>(__args)...);
}
template<typename _Tp, _Lock_policy _Lp>
struct hash<__shared_ptr<_Tp, _Lp>>
: public __hash_base<size_t, __shared_ptr<_Tp, _Lp>>
{
size_t
operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept
{ return std::hash<_Tp*>()(__s.get()); }
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
inline std::basic_ostream<_Ch, _Tr>&
operator<<(std::basic_ostream<_Ch, _Tr>& __os,
const __shared_ptr<_Tp, _Lp>& __p)
{
__os << __p.get();
return __os;
}
template<typename _Del, typename _Tp, _Lock_policy _Lp>
inline _Del*
get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept
{
return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
}
template<typename _Tp>
class shared_ptr : public __shared_ptr<_Tp>
{
public:
constexpr shared_ptr() noexcept
: __shared_ptr<_Tp>() { }
shared_ptr(const shared_ptr&) noexcept = default;
template<typename _Tp1>
explicit shared_ptr(_Tp1* __p)
: __shared_ptr<_Tp>(__p) { }
template<typename _Tp1, typename _Deleter>
shared_ptr(_Tp1* __p, _Deleter __d)
: __shared_ptr<_Tp>(__p, __d) { }
template<typename _Deleter>
shared_ptr(nullptr_t __p, _Deleter __d)
: __shared_ptr<_Tp>(__p, __d) { }
template<typename _Tp1, typename _Deleter, typename _Alloc>
shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)
: __shared_ptr<_Tp>(__p, __d, std::move(__a)) { }
template<typename _Deleter, typename _Alloc>
shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
: __shared_ptr<_Tp>(__p, __d, std::move(__a)) { }
template<typename _Tp1>
shared_ptr(const shared_ptr<_Tp1>& __r, _Tp* __p) noexcept
: __shared_ptr<_Tp>(__r, __p) { }
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
shared_ptr(const shared_ptr<_Tp1>& __r) noexcept
: __shared_ptr<_Tp>(__r) { }
shared_ptr(shared_ptr&& __r) noexcept
: __shared_ptr<_Tp>(std::move(__r)) { }
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
shared_ptr(shared_ptr<_Tp1>&& __r) noexcept
: __shared_ptr<_Tp>(std::move(__r)) { }
template<typename _Tp1>
explicit shared_ptr(const weak_ptr<_Tp1>& __r)
: __shared_ptr<_Tp>(__r) { }
template<typename _Tp1>
shared_ptr(std::auto_ptr<_Tp1>&& __r);
template<typename _Tp1, typename _Del>
shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r)
: __shared_ptr<_Tp>(std::move(__r)) { }
constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }
shared_ptr& operator=(const shared_ptr&) noexcept = default;
template<typename _Tp1>
shared_ptr&
operator=(const shared_ptr<_Tp1>& __r) noexcept
{
this->__shared_ptr<_Tp>::operator=(__r);
return *this;
}
template<typename _Tp1>
shared_ptr&
operator=(std::auto_ptr<_Tp1>&& __r)
{
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
}
shared_ptr&
operator=(shared_ptr&& __r) noexcept
{
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
}
template<class _Tp1>
shared_ptr&
operator=(shared_ptr<_Tp1>&& __r) noexcept
{
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
}
template<typename _Tp1, typename _Del>
shared_ptr&
operator=(std::unique_ptr<_Tp1, _Del>&& __r)
{
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
}
private:
template<typename _Alloc, typename... _Args>
shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
_Args&&... __args)
: __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...)
{ }
template<typename _Tp1, typename _Alloc, typename... _Args>
friend shared_ptr<_Tp1>
allocate_shared(const _Alloc& __a, _Args&&... __args);
shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t)
: __shared_ptr<_Tp>(__r, std::nothrow) { }
friend class weak_ptr<_Tp>;
};
template<typename _Tp1, typename _Tp2>
inline bool
operator==(const shared_ptr<_Tp1>& __a,
const shared_ptr<_Tp2>& __b) noexcept
{ return __a.get() == __b.get(); }
template<typename _Tp>
inline bool
operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
{ return !__a; }
template<typename _Tp>
inline bool
operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
{ return !__a; }
template<typename _Tp1, typename _Tp2>
inline bool
operator!=(const shared_ptr<_Tp1>& __a,
const shared_ptr<_Tp2>& __b) noexcept
{ return __a.get() != __b.get(); }
template<typename _Tp>
inline bool
operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
{ return (bool)__a; }
template<typename _Tp>
inline bool
operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
{ return (bool)__a; }
template<typename _Tp1, typename _Tp2>
inline bool
operator<(const shared_ptr<_Tp1>& __a,
const shared_ptr<_Tp2>& __b) noexcept
{
typedef typename std::common_type<_Tp1*, _Tp2*>::type _CT;
return std::less<_CT>()(__a.get(), __b.get());
}
template<typename _Tp>
inline bool
operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
{ return std::less<_Tp*>()(__a.get(), nullptr); }
template<typename _Tp>
inline bool
operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
{ return std::less<_Tp*>()(nullptr, __a.get()); }
template<typename _Tp1, typename _Tp2>
inline bool
operator<=(const shared_ptr<_Tp1>& __a,
const shared_ptr<_Tp2>& __b) noexcept
{ return !(__b < __a); }
template<typename _Tp>
inline bool
operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
{ return !(nullptr < __a); }
template<typename _Tp>
inline bool
operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
{ return !(__a < nullptr); }
template<typename _Tp1, typename _Tp2>
inline bool
operator>(const shared_ptr<_Tp1>& __a,
const shared_ptr<_Tp2>& __b) noexcept
{ return (__b < __a); }
template<typename _Tp>
inline bool
operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
{ return std::less<_Tp*>()(nullptr, __a.get()); }
template<typename _Tp>
inline bool
operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
{ return std::less<_Tp*>()(__a.get(), nullptr); }
template<typename _Tp1, typename _Tp2>
inline bool
operator>=(const shared_ptr<_Tp1>& __a,
const shared_ptr<_Tp2>& __b) noexcept
{ return !(__a < __b); }
template<typename _Tp>
inline bool
operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
{ return !(__a < nullptr); }
template<typename _Tp>
inline bool
operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
{ return !(nullptr < __a); }
template<typename _Tp>
struct less<shared_ptr<_Tp>> : public _Sp_less<shared_ptr<_Tp>>
{ };
template<typename _Tp>
inline void
swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept
{ __a.swap(__b); }
template<typename _Tp, typename _Tp1>
inline shared_ptr<_Tp>
static_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept
{ return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get())); }
template<typename _Tp, typename _Tp1>
inline shared_ptr<_Tp>
const_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept
{ return shared_ptr<_Tp>(__r, const_cast<_Tp*>(__r.get())); }
template<typename _Tp, typename _Tp1>
inline shared_ptr<_Tp>
dynamic_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept
{
if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
return shared_ptr<_Tp>(__r, __p);
return shared_ptr<_Tp>();
}
template<typename _Tp>
class weak_ptr : public __weak_ptr<_Tp>
{
public:
constexpr weak_ptr() noexcept
: __weak_ptr<_Tp>() { }
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
weak_ptr(const weak_ptr<_Tp1>& __r) noexcept
: __weak_ptr<_Tp>(__r) { }
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
weak_ptr(const shared_ptr<_Tp1>& __r) noexcept
: __weak_ptr<_Tp>(__r) { }
template<typename _Tp1>
weak_ptr&
operator=(const weak_ptr<_Tp1>& __r) noexcept
{
this->__weak_ptr<_Tp>::operator=(__r);
return *this;
}
template<typename _Tp1>
weak_ptr&
operator=(const shared_ptr<_Tp1>& __r) noexcept
{
this->__weak_ptr<_Tp>::operator=(__r);
return *this;
}
shared_ptr<_Tp>
lock() const noexcept
{ return shared_ptr<_Tp>(*this, std::nothrow); }
};
template<typename _Tp>
inline void
swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept
{ __a.swap(__b); }
template<typename _Tp>
struct owner_less;
template<typename _Tp>
struct owner_less<shared_ptr<_Tp>>
: public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
{ };
template<typename _Tp>
struct owner_less<weak_ptr<_Tp>>
: public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
{ };
template<typename _Tp>
class enable_shared_from_this
{
protected:
constexpr enable_shared_from_this() noexcept { }
enable_shared_from_this(const enable_shared_from_this&) noexcept { }
enable_shared_from_this&
operator=(const enable_shared_from_this&) noexcept
{ return *this; }
~enable_shared_from_this() { }
public:
shared_ptr<_Tp>
shared_from_this()
{ return shared_ptr<_Tp>(this->_M_weak_this); }
shared_ptr<const _Tp>
shared_from_this() const
{ return shared_ptr<const _Tp>(this->_M_weak_this); }
private:
template<typename _Tp1>
void
_M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept
{ _M_weak_this._M_assign(__p, __n); }
template<typename _Tp1>
friend void
__enable_shared_from_this_helper(const __shared_count<>& __pn,
const enable_shared_from_this* __pe,
const _Tp1* __px) noexcept
{
if (__pe != 0)
__pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
}
mutable weak_ptr<_Tp> _M_weak_this;
};
template<typename _Tp, typename _Alloc, typename... _Args>
inline shared_ptr<_Tp>
allocate_shared(const _Alloc& __a, _Args&&... __args)
{
return shared_ptr<_Tp>(_Sp_make_shared_tag(), __a,
std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args>
inline shared_ptr<_Tp>
make_shared(_Args&&... __args)
{
typedef typename std::remove_const<_Tp>::type _Tp_nc;
return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
std::forward<_Args>(__args)...);
}
template<typename _Tp>
struct hash<shared_ptr<_Tp>>
: public __hash_base<size_t, shared_ptr<_Tp>>
{
size_t
operator()(const shared_ptr<_Tp>& __s) const noexcept
{ return std::hash<_Tp*>()(__s.get()); }
};
}
#define _BACKWARD_AUTO_PTR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp1>
struct auto_ptr_ref
{
_Tp1* _M_ptr;
explicit
auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
} __attribute__ ((__deprecated__));
template<typename _Tp>
class auto_ptr
{
private:
_Tp* _M_ptr;
public:
typedef _Tp element_type;
explicit
auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
auto_ptr(auto_ptr& __a) throw() ;
template<typename _Tp1>
auto_ptr(auto_ptr<_Tp1>& __a) throw() ;
auto_ptr&
operator=(auto_ptr& __a) throw()
;
template<typename _Tp1>
auto_ptr&
operator=(auto_ptr<_Tp1>& __a) throw()
;
~auto_ptr() ;
element_type&
operator*() const throw()
;
element_type*
operator->() const throw()
;
element_type*
get() const throw() ;
element_type*
release() throw()
;
void
reset(element_type* __p = 0) throw()
;
auto_ptr(auto_ptr_ref<element_type> __ref) throw() ;
auto_ptr&
operator=(auto_ptr_ref<element_type> __ref) throw()
;
template<typename _Tp1>
operator auto_ptr_ref<_Tp1>() throw()
;
template<typename _Tp1>
operator auto_ptr<_Tp1>() throw()
;
} __attribute__ ((__deprecated__));
template<>
class auto_ptr<void>
{
public:
typedef void element_type;
} __attribute__ ((__deprecated__));
template<typename _Tp, _Lock_policy _Lp>
template<typename _Tp1>
inline
__shared_ptr<_Tp, _Lp>::__shared_ptr(std::auto_ptr<_Tp1>&& __r)
: _M_ptr(__r.get()), _M_refcount()
{
static_assert( sizeof(_Tp1) > 0, "incomplete type" );
_Tp1* __tmp = __r.get();
_M_refcount = __shared_count<_Lp>(std::move(__r));
__enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
}
template<typename _Tp>
template<typename _Tp1>
inline
shared_ptr<_Tp>::shared_ptr(std::auto_ptr<_Tp1>&& __r)
: __shared_ptr<_Tp>(std::move(__r)) { }
template<typename _Tp, typename _Dp>
template<typename _Up, typename>
inline
unique_ptr<_Tp, _Dp>::unique_ptr(auto_ptr<_Up>&& __u) noexcept
: _M_t(__u.release(), deleter_type()) { }
}
namespace boost {
namespace asio {
namespace detail {
using std::addressof;
}
}
}
#define BOOST_ASIO_HANDLER_ALLOC_HOOK_HPP
namespace boost {
namespace asio {
inline void* asio_handler_allocate(
std::size_t size, ...);
inline void asio_handler_deallocate(
void* pointer, std::size_t size, ...);
}
}
#define BOOST_ASIO_IMPL_HANDLER_ALLOC_HOOK_IPP
#define BOOST_ASIO_DETAIL_CALL_STACK_HPP
#define BOOST_ASIO_DETAIL_TSS_PTR_HPP
#define BOOST_ASIO_DETAIL_KEYWORD_TSS_PTR_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename T>
class keyword_tss_ptr
: private noncopyable
{
public:
keyword_tss_ptr()
;
~keyword_tss_ptr()
;
operator T*() const
;
void operator=(T* value)
;
private:
static __thread T* value_;
};
template <typename T>
__thread T* keyword_tss_ptr<T>::value_;
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename T>
class tss_ptr
: public keyword_tss_ptr<T>
{
public:
void operator=(T* value)
;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Key, typename Value = unsigned char>
class call_stack
{
public:
class context
: private noncopyable
{
public:
explicit context(Key* k)
;
context(Key* k, Value& v)
;
~context()
;
Value* next_by_key() const
;
private:
friend class call_stack<Key, Value>;
Key* key_;
Value* value_;
context* next_;
};
friend class context;
static Value* contains(Key* k)
;
static Value* top()
;
private:
static tss_ptr<context> top_;
};
template <typename Key, typename Value>
tss_ptr<typename call_stack<Key, Value>::context>
call_stack<Key, Value>::top_;
}
}
}
#define BOOST_ASIO_DETAIL_TASK_IO_SERVICE_THREAD_INFO_HPP
#define BOOST_ASIO_DETAIL_EVENT_HPP
#define BOOST_ASIO_DETAIL_POSIX_EVENT_HPP
#define BOOST_ASIO_DETAIL_ASSERT_HPP
#undef BOOST_ASSERT
#define _ASSERT_H 1
#define __ASSERT_VOID_CAST static_cast<void>
#define assert(expr) (__ASSERT_VOID_CAST (0))
#define assert_perror(errnum) (__ASSERT_VOID_CAST (0))
#define BOOST_ASSERT(expr) assert(expr)
#undef BOOST_ASSERT_MSG
#define BOOST_ASSERT_MSG(expr,msg) ((void)0)
#undef BOOST_VERIFY
#define BOOST_VERIFY(expr) ((void)(expr))
#define BOOST_ASIO_ASSERT(expr) BOOST_ASSERT(expr)
namespace boost {
namespace asio {
namespace detail {
class posix_event
: private noncopyable
{
public:
inline posix_event();
~posix_event()
;
template <typename Lock>
void signal(Lock& lock)
;
template <typename Lock>
void signal_and_unlock(Lock& lock)
;
template <typename Lock>
void clear(Lock& lock)
;
template <typename Lock>
void wait(Lock& lock)
;
private:
::pthread_cond_t cond_;
bool signalled_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_POSIX_EVENT_IPP
#define BOOST_ASIO_DETAIL_THROW_ERROR_HPP
#define BOOST_ERROR_CODE_HPP
#define BOOST_SYSTEM_CONFIG_HPP
#define BOOST_SYSTEM_API_CONFIG_HPP
#define BOOST_POSIX_API
#define BOOST_SYSTEM_STATIC_LINK
#define BOOST_SYSTEM_DECL
#define BOOST_LIB_NAME boost_system
#undef BOOST_LIB_NAME
#define BOOST_CSTDINT_HPP
namespace boost
{
using ::int8_t;
using ::int_least8_t;
using ::int_fast8_t;
using ::uint8_t;
using ::uint_least8_t;
using ::uint_fast8_t;
using ::int16_t;
using ::int_least16_t;
using ::int_fast16_t;
using ::uint16_t;
using ::uint_least16_t;
using ::uint_fast16_t;
using ::int32_t;
using ::int_least32_t;
using ::int_fast32_t;
using ::uint32_t;
using ::uint_least32_t;
using ::uint_fast32_t;
using ::int64_t;
using ::int_least64_t;
using ::int_fast64_t;
using ::uint64_t;
using ::uint_least64_t;
using ::uint_fast64_t;
using ::intmax_t;
using ::uintmax_t;
}
namespace boost {
using ::intptr_t;
using ::uintptr_t;
}
#define BOOST_HAS_INTPTR_T
#undef BOOST_ASSERT
#undef _ASSERT_H
#undef assert
#undef __ASSERT_VOID_CAST
#undef assert_perror
#define _ASSERT_H 1
#define __ASSERT_VOID_CAST static_cast<void>
#define assert(expr) (__ASSERT_VOID_CAST (0))
#define assert_perror(errnum) (__ASSERT_VOID_CAST (0))
#define BOOST_ASSERT(expr) assert(expr)
#undef BOOST_ASSERT_MSG
#define BOOST_ASSERT_MSG(expr,msg) ((void)0)
#undef BOOST_VERIFY
#define BOOST_VERIFY(expr) ((void)(expr))
#define BOOST_OPERATORS_HPP
#define BOOST_ITERATOR_HPP
#define _GLIBCXX_ITERATOR 1
#define _GLIBCXX_OSTREAM 1
#define _GLIBCXX_IOS 1
#define _IOS_BASE_H 1
#define _LOCALE_CLASSES_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
class locale
{
public:
typedef int category;
class facet;
class id;
class _Impl;
friend class facet;
friend class _Impl;
template<typename _Facet>
friend bool
has_facet(const locale&) throw();
template<typename _Facet>
friend const _Facet&
use_facet(const locale&);
template<typename _Cache>
friend struct __use_cache;
static const category none = 0;
static const category ctype = 1L << 0;
static const category numeric = 1L << 1;
static const category collate = 1L << 2;
static const category time = 1L << 3;
static const category monetary = 1L << 4;
static const category messages = 1L << 5;
static const category all = (ctype | numeric | collate |
time | monetary | messages);
locale() throw();
locale(const locale& __other) throw();
explicit
locale(const char* __s);
locale(const locale& __base, const char* __s, category __cat);
locale(const locale& __base, const locale& __add, category __cat);
template<typename _Facet>
locale(const locale& __other, _Facet* __f);
~locale() throw();
const locale&
operator=(const locale& __other) throw();
template<typename _Facet>
locale
combine(const locale& __other) const;
string
name() const;
bool
operator==(const locale& __other) const throw();
bool
operator!=(const locale& __other) const throw()
;
template<typename _Char, typename _Traits, typename _Alloc>
bool
operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
const basic_string<_Char, _Traits, _Alloc>& __s2) const;
static locale
global(const locale& __loc);
static const locale&
classic();
private:
_Impl* _M_impl;
static _Impl* _S_classic;
static _Impl* _S_global;
static const char* const* const _S_categories;
enum { _S_categories_size = 6 + 6 };
static __gthread_once_t _S_once;
explicit
locale(_Impl*) throw();
static void
_S_initialize();
static void
_S_initialize_once() throw();
static category
_S_normalize_category(category);
void
_M_coalesce(const locale& __base, const locale& __add, category __cat);
};
class locale::facet
{
private:
friend class locale;
friend class locale::_Impl;
mutable _Atomic_word _M_refcount;
static __c_locale _S_c_locale;
static const char _S_c_name[2];
static __gthread_once_t _S_once;
static void
_S_initialize_once();
protected:
explicit
facet(size_t __refs = 0) throw()
;
virtual
~facet();
static void
_S_create_c_locale(__c_locale& __cloc, const char* __s,
__c_locale __old = 0);
static __c_locale
_S_clone_c_locale(__c_locale& __cloc) throw();
static void
_S_destroy_c_locale(__c_locale& __cloc);
static __c_locale
_S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);
static __c_locale
_S_get_c_locale();
__attribute__ ((__const__)) static const char*
_S_get_c_name() throw();
private:
void
_M_add_reference() const throw()
;
void
_M_remove_reference() const throw()
;
facet(const facet&);
facet&
operator=(const facet&);
};
class locale::id
{
private:
friend class locale;
friend class locale::_Impl;
template<typename _Facet>
friend const _Facet&
use_facet(const locale&);
template<typename _Facet>
friend bool
has_facet(const locale&) throw();
mutable size_t _M_index;
static _Atomic_word _S_refcount;
void
operator=(const id&);
id(const id&);
public:
id() ;
size_t
_M_id() const throw();
};
class locale::_Impl
{
public:
friend class locale;
friend class locale::facet;
template<typename _Facet>
friend bool
has_facet(const locale&) throw();
template<typename _Facet>
friend const _Facet&
use_facet(const locale&);
template<typename _Cache>
friend struct __use_cache;
private:
_Atomic_word _M_refcount;
const facet** _M_facets;
size_t _M_facets_size;
const facet** _M_caches;
char** _M_names;
static const locale::id* const _S_id_ctype[];
static const locale::id* const _S_id_numeric[];
static const locale::id* const _S_id_collate[];
static const locale::id* const _S_id_time[];
static const locale::id* const _S_id_monetary[];
static const locale::id* const _S_id_messages[];
static const locale::id* const* const _S_facet_categories[];
void
_M_add_reference() throw()
;
void
_M_remove_reference() throw()
;
_Impl(const _Impl&, size_t);
_Impl(const char*, size_t);
_Impl(size_t) throw();
~_Impl() throw();
_Impl(const _Impl&);
void
operator=(const _Impl&);
bool
_M_check_same_name()
;
void
_M_replace_categories(const _Impl*, category);
void
_M_replace_category(const _Impl*, const locale::id* const*);
void
_M_replace_facet(const _Impl*, const locale::id*);
void
_M_install_facet(const locale::id*, const facet*);
template<typename _Facet>
void
_M_init_facet(_Facet* __facet)
;
void
_M_install_cache(const facet*, size_t);
};
template<typename _CharT>
class collate : public locale::facet
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
protected:
__c_locale _M_c_locale_collate;
public:
static locale::id id;
explicit
collate(size_t __refs = 0)
;
explicit
collate(__c_locale __cloc, size_t __refs = 0)
;
int
compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const
;
string_type
transform(const _CharT* __lo, const _CharT* __hi) const
;
long
hash(const _CharT* __lo, const _CharT* __hi) const
;
int
_M_compare(const _CharT*, const _CharT*) const throw();
size_t
_M_transform(_CharT*, const _CharT*, size_t) const throw();
protected:
virtual
~collate()
;
virtual int
do_compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const;
virtual string_type
do_transform(const _CharT* __lo, const _CharT* __hi) const;
virtual long
do_hash(const _CharT* __lo, const _CharT* __hi) const;
};
template<typename _CharT>
locale::id collate<_CharT>::id;
template<>
int
collate<char>::_M_compare(const char*, const char*) const throw();
template<>
size_t
collate<char>::_M_transform(char*, const char*, size_t) const throw();
template<>
int
collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();
template<>
size_t
collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();
template<typename _CharT>
class collate_byname : public collate<_CharT>
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
explicit
collate_byname(const char* __s, size_t __refs = 0)
;
protected:
virtual
~collate_byname() ;
};
}
#define _LOCALE_CLASSES_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Facet>
bool
has_facet(const locale& __loc) throw()
;
template<typename _Facet>
const _Facet&
use_facet(const locale& __loc)
;
extern template class collate<char>;
extern template class collate_byname<char>;
extern template
const collate<char>&
use_facet<collate<char> >(const locale&);
extern template
bool
has_facet<collate<char> >(const locale&);
extern template class collate<wchar_t>;
extern template class collate_byname<wchar_t>;
extern template
const collate<wchar_t>&
use_facet<collate<wchar_t> >(const locale&);
extern template
bool
has_facet<collate<wchar_t> >(const locale&);
}
namespace std __attribute__ ((__visibility__ ("default")))
{
enum _Ios_Fmtflags
{
_S_boolalpha = 1L << 0,
_S_dec = 1L << 1,
_S_fixed = 1L << 2,
_S_hex = 1L << 3,
_S_internal = 1L << 4,
_S_left = 1L << 5,
_S_oct = 1L << 6,
_S_right = 1L << 7,
_S_scientific = 1L << 8,
_S_showbase = 1L << 9,
_S_showpoint = 1L << 10,
_S_showpos = 1L << 11,
_S_skipws = 1L << 12,
_S_unitbuf = 1L << 13,
_S_uppercase = 1L << 14,
_S_adjustfield = _S_left | _S_right | _S_internal,
_S_basefield = _S_dec | _S_oct | _S_hex,
_S_floatfield = _S_scientific | _S_fixed,
_S_ios_fmtflags_end = 1L << 16
};
inline constexpr _Ios_Fmtflags
operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
inline constexpr _Ios_Fmtflags
operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
inline constexpr _Ios_Fmtflags
operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
inline constexpr _Ios_Fmtflags
operator~(_Ios_Fmtflags __a)
{ return _Ios_Fmtflags(~static_cast<int>(__a)); }
inline const _Ios_Fmtflags&
operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
{ return __a = __a | __b; }
inline const _Ios_Fmtflags&
operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
{ return __a = __a & __b; }
inline const _Ios_Fmtflags&
operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
{ return __a = __a ^ __b; }
enum _Ios_Openmode
{
_S_app = 1L << 0,
_S_ate = 1L << 1,
_S_bin = 1L << 2,
_S_in = 1L << 3,
_S_out = 1L << 4,
_S_trunc = 1L << 5,
_S_ios_openmode_end = 1L << 16
};
inline constexpr _Ios_Openmode
operator&(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
inline constexpr _Ios_Openmode
operator|(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
inline constexpr _Ios_Openmode
operator^(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
inline constexpr _Ios_Openmode
operator~(_Ios_Openmode __a)
{ return _Ios_Openmode(~static_cast<int>(__a)); }
inline const _Ios_Openmode&
operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
{ return __a = __a | __b; }
inline const _Ios_Openmode&
operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
{ return __a = __a & __b; }
inline const _Ios_Openmode&
operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
{ return __a = __a ^ __b; }
enum _Ios_Iostate
{
_S_goodbit = 0,
_S_badbit = 1L << 0,
_S_eofbit = 1L << 1,
_S_failbit = 1L << 2,
_S_ios_iostate_end = 1L << 16
};
inline constexpr _Ios_Iostate
operator&(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
inline constexpr _Ios_Iostate
operator|(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
inline constexpr _Ios_Iostate
operator^(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
inline constexpr _Ios_Iostate
operator~(_Ios_Iostate __a)
{ return _Ios_Iostate(~static_cast<int>(__a)); }
inline const _Ios_Iostate&
operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
{ return __a = __a | __b; }
inline const _Ios_Iostate&
operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
{ return __a = __a & __b; }
inline const _Ios_Iostate&
operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
{ return __a = __a ^ __b; }
enum _Ios_Seekdir
{
_S_beg = 0,
_S_cur = 1,
_S_end = 2,
_S_ios_seekdir_end = 1L << 16
};
class ios_base
{
public:
class failure : public exception
{
public:
explicit
failure(const string& __str) throw();
virtual
~failure() throw();
virtual const char*
what() const throw();
private:
string _M_msg;
};
typedef _Ios_Fmtflags fmtflags;
static const fmtflags boolalpha = _S_boolalpha;
static const fmtflags dec = _S_dec;
static const fmtflags fixed = _S_fixed;
static const fmtflags hex = _S_hex;
static const fmtflags internal = _S_internal;
static const fmtflags left = _S_left;
static const fmtflags oct = _S_oct;
static const fmtflags right = _S_right;
static const fmtflags scientific = _S_scientific;
static const fmtflags showbase = _S_showbase;
static const fmtflags showpoint = _S_showpoint;
static const fmtflags showpos = _S_showpos;
static const fmtflags skipws = _S_skipws;
static const fmtflags unitbuf = _S_unitbuf;
static const fmtflags uppercase = _S_uppercase;
static const fmtflags adjustfield = _S_adjustfield;
static const fmtflags basefield = _S_basefield;
static const fmtflags floatfield = _S_floatfield;
typedef _Ios_Iostate iostate;
static const iostate badbit = _S_badbit;
static const iostate eofbit = _S_eofbit;
static const iostate failbit = _S_failbit;
static const iostate goodbit = _S_goodbit;
typedef _Ios_Openmode openmode;
static const openmode app = _S_app;
static const openmode ate = _S_ate;
static const openmode binary = _S_bin;
static const openmode in = _S_in;
static const openmode out = _S_out;
static const openmode trunc = _S_trunc;
typedef _Ios_Seekdir seekdir;
static const seekdir beg = _S_beg;
static const seekdir cur = _S_cur;
static const seekdir end = _S_end;
typedef int io_state;
typedef int open_mode;
typedef int seek_dir;
typedef std::streampos streampos;
typedef std::streamoff streamoff;
enum event
{
erase_event,
imbue_event,
copyfmt_event
};
typedef void (*event_callback) (event __e, ios_base& __b, int __i);
void
register_callback(event_callback __fn, int __index);
protected:
streamsize _M_precision;
streamsize _M_width;
fmtflags _M_flags;
iostate _M_exception;
iostate _M_streambuf_state;
struct _Callback_list
{
_Callback_list* _M_next;
ios_base::event_callback _M_fn;
int _M_index;
_Atomic_word _M_refcount;
_Callback_list(ios_base::event_callback __fn, int __index,
_Callback_list* __cb) ;
void
_M_add_reference() ;
int
_M_remove_reference()
;
};
_Callback_list* _M_callbacks;
void
_M_call_callbacks(event __ev) throw();
void
_M_dispose_callbacks(void) throw();
struct _Words
{
void* _M_pword;
long _M_iword;
_Words() ;
};
_Words _M_word_zero;
enum { _S_local_word_size = 8 };
_Words _M_local_word[_S_local_word_size];
int _M_word_size;
_Words* _M_word;
_Words&
_M_grow_words(int __index, bool __iword);
locale _M_ios_locale;
void
_M_init() throw();
public:
class Init
{
friend class ios_base;
public:
Init();
~Init();
private:
static _Atomic_word _S_refcount;
static bool _S_synced_with_stdio;
};
fmtflags
flags() const
;
fmtflags
flags(fmtflags __fmtfl)
;
fmtflags
setf(fmtflags __fmtfl)
;
fmtflags
setf(fmtflags __fmtfl, fmtflags __mask)
;
void
unsetf(fmtflags __mask)
;
streamsize
precision() const
;
streamsize
precision(streamsize __prec)
;
streamsize
width() const
;
streamsize
width(streamsize __wide)
;
static bool
sync_with_stdio(bool __sync = true);
locale
imbue(const locale& __loc) throw();
locale
getloc() const
;
const locale&
_M_getloc() const
;
static int
xalloc() throw();
long&
iword(int __ix)
;
void*&
pword(int __ix)
;
virtual ~ios_base();
protected:
ios_base() throw ();
public:
ios_base(const ios_base&) = delete;
ios_base&
operator=(const ios_base&) = delete;
protected:
void
_M_move(ios_base&) noexcept;
void
_M_swap(ios_base& __rhs) noexcept;
};
ios_base&
boolalpha(ios_base& __base)
;
ios_base&
noboolalpha(ios_base& __base)
;
ios_base&
showbase(ios_base& __base)
;
ios_base&
noshowbase(ios_base& __base)
;
ios_base&
showpoint(ios_base& __base)
;
ios_base&
noshowpoint(ios_base& __base)
;
ios_base&
showpos(ios_base& __base)
;
ios_base&
noshowpos(ios_base& __base)
;
ios_base&
skipws(ios_base& __base)
;
ios_base&
noskipws(ios_base& __base)
;
ios_base&
uppercase(ios_base& __base)
;
ios_base&
nouppercase(ios_base& __base)
;
ios_base&
unitbuf(ios_base& __base)
;
ios_base&
nounitbuf(ios_base& __base)
;
ios_base&
internal(ios_base& __base)
;
ios_base&
left(ios_base& __base)
;
ios_base&
right(ios_base& __base)
;
ios_base&
dec(ios_base& __base)
;
ios_base&
hex(ios_base& __base)
;
ios_base&
oct(ios_base& __base)
;
ios_base&
fixed(ios_base& __base)
;
ios_base&
scientific(ios_base& __base)
;
}
#define _GLIBXX_STREAMBUF 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
streamsize
__copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
basic_streambuf<_CharT, _Traits>*, bool&);
template<typename _CharT, typename _Traits>
class basic_streambuf
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef basic_streambuf<char_type, traits_type> __streambuf_type;
friend class basic_ios<char_type, traits_type>;
friend class basic_istream<char_type, traits_type>;
friend class basic_ostream<char_type, traits_type>;
friend class istreambuf_iterator<char_type, traits_type>;
friend class ostreambuf_iterator<char_type, traits_type>;
friend streamsize
__copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&);
template<bool _IsMove, typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
_CharT2*>::__type
__copy_move_a2(istreambuf_iterator<_CharT2>,
istreambuf_iterator<_CharT2>, _CharT2*);
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
istreambuf_iterator<_CharT2> >::__type
find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
const _CharT2&);
template<typename _CharT2, typename _Traits2>
friend basic_istream<_CharT2, _Traits2>&
operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
template<typename _CharT2, typename _Traits2, typename _Alloc>
friend basic_istream<_CharT2, _Traits2>&
operator>>(basic_istream<_CharT2, _Traits2>&,
basic_string<_CharT2, _Traits2, _Alloc>&);
template<typename _CharT2, typename _Traits2, typename _Alloc>
friend basic_istream<_CharT2, _Traits2>&
getline(basic_istream<_CharT2, _Traits2>&,
basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);
protected:
char_type* _M_in_beg;
char_type* _M_in_cur;
char_type* _M_in_end;
char_type* _M_out_beg;
char_type* _M_out_cur;
char_type* _M_out_end;
locale _M_buf_locale;
public:
virtual
~basic_streambuf()
;
locale
pubimbue(const locale& __loc)
;
locale
getloc() const
;
basic_streambuf*
pubsetbuf(char_type* __s, streamsize __n)
;
pos_type
pubseekoff(off_type __off, ios_base::seekdir __way,
ios_base::openmode __mode = ios_base::in | ios_base::out)
;
pos_type
pubseekpos(pos_type __sp,
ios_base::openmode __mode = ios_base::in | ios_base::out)
;
int
pubsync() ;
streamsize
in_avail()
;
int_type
snextc()
;
int_type
sbumpc()
;
int_type
sgetc()
;
streamsize
sgetn(char_type* __s, streamsize __n)
;
int_type
sputbackc(char_type __c)
;
int_type
sungetc()
;
int_type
sputc(char_type __c)
;
streamsize
sputn(const char_type* __s, streamsize __n)
;
protected:
basic_streambuf()
;
char_type*
eback() const ;
char_type*
gptr() const ;
char_type*
egptr() const ;
void
gbump(int __n) ;
void
setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
;
char_type*
pbase() const ;
char_type*
pptr() const ;
char_type*
epptr() const ;
void
pbump(int __n) ;
void
setp(char_type* __pbeg, char_type* __pend)
;
virtual void
imbue(const locale& __loc)
;
virtual basic_streambuf<char_type,_Traits>*
setbuf(char_type*, streamsize)
;
virtual pos_type
seekoff(off_type, ios_base::seekdir,
ios_base::openmode = ios_base::in | ios_base::out)
;
virtual pos_type
seekpos(pos_type,
ios_base::openmode = ios_base::in | ios_base::out)
;
virtual int
sync() ;
virtual streamsize
showmanyc() ;
virtual streamsize
xsgetn(char_type* __s, streamsize __n);
virtual int_type
underflow()
;
virtual int_type
uflow()
;
virtual int_type
pbackfail(int_type __c = traits_type::eof())
;
virtual streamsize
xsputn(const char_type* __s, streamsize __n);
virtual int_type
overflow(int_type __c = traits_type::eof())
;
public:
void
stossc()
;
void
__safe_gbump(streamsize __n) ;
void
__safe_pbump(streamsize __n) ;
protected:
basic_streambuf(const basic_streambuf&);
basic_streambuf&
operator=(const basic_streambuf&);
void
swap(basic_streambuf& __sb)
;
};
template<typename _CharT, typename _Traits>
std::basic_streambuf<_CharT, _Traits>::
basic_streambuf(const basic_streambuf&) = default;
template<typename _CharT, typename _Traits>
std::basic_streambuf<_CharT, _Traits>&
std::basic_streambuf<_CharT, _Traits>::
operator=(const basic_streambuf&) = default;
template<>
streamsize
__copy_streambufs_eof(basic_streambuf<char>* __sbin,
basic_streambuf<char>* __sbout, bool& __ineof);
template<>
streamsize
__copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
basic_streambuf<wchar_t>* __sbout, bool& __ineof);
}
#define _STREAMBUF_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
streamsize
__copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
basic_streambuf<_CharT, _Traits>* __sbout,
bool& __ineof)
;
template<typename _CharT, typename _Traits>
streamsize
__copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
basic_streambuf<_CharT, _Traits>* __sbout)
;
extern template class basic_streambuf<char>;
extern template
streamsize
__copy_streambufs(basic_streambuf<char>*,
basic_streambuf<char>*);
extern template
streamsize
__copy_streambufs_eof(basic_streambuf<char>*,
basic_streambuf<char>*, bool&);
extern template class basic_streambuf<wchar_t>;
extern template
streamsize
__copy_streambufs(basic_streambuf<wchar_t>*,
basic_streambuf<wchar_t>*);
extern template
streamsize
__copy_streambufs_eof(basic_streambuf<wchar_t>*,
basic_streambuf<wchar_t>*, bool&);
}
#define _BASIC_IOS_H 1
#define _LOCALE_FACETS_H 1
#define _WCTYPE_H 1
#define __need_wint_t
#undef __need_mbstate_t
#undef __need_wint_t
#undef __need_iswxxx
#define __iswxxx_defined 1
typedef unsigned long int wctype_t;
#define _ISwbit(bit) ((bit) < 8 ? (int) ((1UL << (bit)) << 24) : ((bit) < 16 ? (int) ((1UL << (bit)) << 8) : ((bit) < 24 ? (int) ((1UL << (bit)) >> 8) : (int) ((1UL << (bit)) >> 24))))
enum
{
__ISwupper = 0,
__ISwlower = 1,
__ISwalpha = 2,
__ISwdigit = 3,
__ISwxdigit = 4,
__ISwspace = 5,
__ISwprint = 6,
__ISwgraph = 7,
__ISwblank = 8,
__ISwcntrl = 9,
__ISwpunct = 10,
__ISwalnum = 11,
_ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))),
_ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))),
_ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))),
_ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))),
_ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))),
_ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))),
_ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))),
_ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))),
_ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))),
_ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))),
_ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))),
_ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24))))
};
extern "C" {
extern int iswalnum (wint_t __wc) throw ();
extern int iswalpha (wint_t __wc) throw ();
extern int iswcntrl (wint_t __wc) throw ();
extern int iswdigit (wint_t __wc) throw ();
extern int iswgraph (wint_t __wc) throw ();
extern int iswlower (wint_t __wc) throw ();
extern int iswprint (wint_t __wc) throw ();
extern int iswpunct (wint_t __wc) throw ();
extern int iswspace (wint_t __wc) throw ();
extern int iswupper (wint_t __wc) throw ();
extern int iswxdigit (wint_t __wc) throw ();
extern int iswblank (wint_t __wc) throw ();
extern wctype_t wctype (const char *__property) throw ();
extern int iswctype (wint_t __wc, wctype_t __desc) throw ();
typedef const __int32_t *wctrans_t;
extern wint_t towlower (wint_t __wc) throw ();
extern wint_t towupper (wint_t __wc) throw ();
}
extern "C" {
extern wctrans_t wctrans (const char *__property) throw ();
extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();
extern int iswalnum_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswalpha_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswcntrl_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswdigit_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswgraph_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswlower_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswprint_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswpunct_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswspace_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswupper_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswxdigit_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswblank_l (wint_t __wc, __locale_t __locale) throw ();
extern wctype_t wctype_l (const char *__property, __locale_t __locale)
throw ();
extern int iswctype_l (wint_t __wc, wctype_t __desc, __locale_t __locale)
throw ();
extern wint_t towlower_l (wint_t __wc, __locale_t __locale) throw ();
extern wint_t towupper_l (wint_t __wc, __locale_t __locale) throw ();
extern wctrans_t wctrans_l (const char *__property, __locale_t __locale)
throw ();
extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
__locale_t __locale) throw ();
}
#define _GLIBCXX_CWCTYPE 1
#undef iswalnum
#undef iswalpha
#undef iswblank
#undef iswcntrl
#undef iswctype
#undef iswdigit
#undef iswgraph
#undef iswlower
#undef iswprint
#undef iswpunct
#undef iswspace
#undef iswupper
#undef iswxdigit
#undef towctrans
#undef towlower
#undef towupper
#undef wctrans
#undef wctype
namespace std
{
using ::wctrans_t;
using ::wctype_t;
using ::wint_t;
using ::iswalnum;
using ::iswalpha;
using ::iswblank;
using ::iswcntrl;
using ::iswctype;
using ::iswdigit;
using ::iswgraph;
using ::iswlower;
using ::iswprint;
using ::iswpunct;
using ::iswspace;
using ::iswupper;
using ::iswxdigit;
using ::towctrans;
using ::towlower;
using ::towupper;
using ::wctrans;
using ::wctype;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
struct ctype_base
{
typedef const int* __to_type;
typedef unsigned short mask;
static const mask upper = _ISupper;
static const mask lower = _ISlower;
static const mask alpha = _ISalpha;
static const mask digit = _ISdigit;
static const mask xdigit = _ISxdigit;
static const mask space = _ISspace;
static const mask print = _ISprint;
static const mask graph = _ISalpha | _ISdigit | _ISpunct;
static const mask cntrl = _IScntrl;
static const mask punct = _ISpunct;
static const mask alnum = _ISalpha | _ISdigit;
};
}
#define _STREAMBUF_ITERATOR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
class istreambuf_iterator
: public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
_CharT*,
_CharT>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef typename _Traits::int_type int_type;
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
typedef basic_istream<_CharT, _Traits> istream_type;
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
ostreambuf_iterator<_CharT2> >::__type
copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
ostreambuf_iterator<_CharT2>);
template<bool _IsMove, typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
_CharT2*>::__type
__copy_move_a2(istreambuf_iterator<_CharT2>,
istreambuf_iterator<_CharT2>, _CharT2*);
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
istreambuf_iterator<_CharT2> >::__type
find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
const _CharT2&);
private:
mutable streambuf_type* _M_sbuf;
mutable int_type _M_c;
public:
constexpr istreambuf_iterator() noexcept
: _M_sbuf(0), _M_c(traits_type::eof()) { }
istreambuf_iterator(const istreambuf_iterator&) noexcept = default;
~istreambuf_iterator() = default;
istreambuf_iterator(istream_type& __s) noexcept
: _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
istreambuf_iterator(streambuf_type* __s) noexcept
: _M_sbuf(__s), _M_c(traits_type::eof()) { }
char_type
operator*() const
{
return traits_type::to_char_type(_M_get());
}
istreambuf_iterator&
operator++()
{
;
if (_M_sbuf)
{
_M_sbuf->sbumpc();
_M_c = traits_type::eof();
}
return *this;
}
istreambuf_iterator
operator++(int)
{
;
istreambuf_iterator __old = *this;
if (_M_sbuf)
{
__old._M_c = _M_sbuf->sbumpc();
_M_c = traits_type::eof();
}
return __old;
}
bool
equal(const istreambuf_iterator& __b) const
{ return _M_at_eof() == __b._M_at_eof(); }
private:
int_type
_M_get() const
{
const int_type __eof = traits_type::eof();
int_type __ret = __eof;
if (_M_sbuf)
{
if (!traits_type::eq_int_type(_M_c, __eof))
__ret = _M_c;
else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()),
__eof))
_M_c = __ret;
else
_M_sbuf = 0;
}
return __ret;
}
bool
_M_at_eof() const
{
const int_type __eof = traits_type::eof();
return traits_type::eq_int_type(_M_get(), __eof);
}
};
template<typename _CharT, typename _Traits>
bool
operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
const istreambuf_iterator<_CharT, _Traits>& __b)
;
template<typename _CharT, typename _Traits>
bool
operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
const istreambuf_iterator<_CharT, _Traits>& __b)
;
template<typename _CharT, typename _Traits>
class ostreambuf_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
typedef basic_ostream<_CharT, _Traits> ostream_type;
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
ostreambuf_iterator<_CharT2> >::__type
copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
ostreambuf_iterator<_CharT2>);
private:
streambuf_type* _M_sbuf;
bool _M_failed;
public:
ostreambuf_iterator(ostream_type& __s) noexcept
: _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
ostreambuf_iterator(streambuf_type* __s) noexcept
: _M_sbuf(__s), _M_failed(!_M_sbuf) { }
ostreambuf_iterator&
operator=(_CharT __c)
{
if (!_M_failed &&
_Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
_M_failed = true;
return *this;
}
ostreambuf_iterator&
operator*()
{ return *this; }
ostreambuf_iterator&
operator++(int)
{ return *this; }
ostreambuf_iterator&
operator++()
{ return *this; }
bool
failed() const noexcept
{ return _M_failed; }
ostreambuf_iterator&
_M_put(const _CharT* __ws, streamsize __len)
{
if (__builtin_expect(!_M_failed, true)
&& __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
false))
_M_failed = true;
return *this;
}
};
template<typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
copy(istreambuf_iterator<_CharT> __first,
istreambuf_iterator<_CharT> __last,
ostreambuf_iterator<_CharT> __result)
;
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
__copy_move_a2(_CharT* __first, _CharT* __last,
ostreambuf_iterator<_CharT> __result)
;
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
__copy_move_a2(const _CharT* __first, const _CharT* __last,
ostreambuf_iterator<_CharT> __result)
;
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
_CharT*>::__type
__copy_move_a2(istreambuf_iterator<_CharT> __first,
istreambuf_iterator<_CharT> __last, _CharT* __result)
;
template<typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
istreambuf_iterator<_CharT> >::__type
find(istreambuf_iterator<_CharT> __first,
istreambuf_iterator<_CharT> __last, const _CharT& __val)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
#define _GLIBCXX_NUM_FACETS 28
template<typename _Tp>
void
__convert_to_v(const char*, _Tp&, ios_base::iostate&,
const __c_locale&) throw();
template<>
void
__convert_to_v(const char*, float&, ios_base::iostate&,
const __c_locale&) throw();
template<>
void
__convert_to_v(const char*, double&, ios_base::iostate&,
const __c_locale&) throw();
template<>
void
__convert_to_v(const char*, long double&, ios_base::iostate&,
const __c_locale&) throw();
template<typename _CharT, typename _Traits>
struct __pad
{
static void
_S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
};
template<typename _CharT>
_CharT*
__add_grouping(_CharT* __s, _CharT __sep,
const char* __gbeg, size_t __gsize,
const _CharT* __first, const _CharT* __last);
template<typename _CharT>
ostreambuf_iterator<_CharT>
__write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
;
template<typename _CharT, typename _OutIter>
_OutIter
__write(_OutIter __s, const _CharT* __ws, int __len)
;
template<typename _CharT>
class __ctype_abstract_base : public locale::facet, public ctype_base
{
public:
typedef _CharT char_type;
bool
is(mask __m, char_type __c) const
;
const char_type*
is(const char_type *__lo, const char_type *__hi, mask *__vec) const
;
const char_type*
scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
;
const char_type*
scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
;
char_type
toupper(char_type __c) const
;
const char_type*
toupper(char_type *__lo, const char_type* __hi) const
;
char_type
tolower(char_type __c) const
;
const char_type*
tolower(char_type* __lo, const char_type* __hi) const
;
char_type
widen(char __c) const
;
const char*
widen(const char* __lo, const char* __hi, char_type* __to) const
;
char
narrow(char_type __c, char __dfault) const
;
const char_type*
narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const
;
protected:
explicit
__ctype_abstract_base(size_t __refs = 0) ;
virtual
~__ctype_abstract_base() ;
virtual bool
do_is(mask __m, char_type __c) const = 0;
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi,
mask* __vec) const = 0;
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo,
const char_type* __hi) const = 0;
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const = 0;
virtual char_type
do_toupper(char_type __c) const = 0;
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const = 0;
virtual char_type
do_tolower(char_type __c) const = 0;
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const = 0;
virtual char_type
do_widen(char __c) const = 0;
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
virtual char
do_narrow(char_type __c, char __dfault) const = 0;
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const = 0;
};
template<typename _CharT>
class ctype : public __ctype_abstract_base<_CharT>
{
public:
typedef _CharT char_type;
typedef typename __ctype_abstract_base<_CharT>::mask mask;
static locale::id id;
explicit
ctype(size_t __refs = 0) ;
protected:
virtual
~ctype();
virtual bool
do_is(mask __m, char_type __c) const;
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const;
virtual char_type
do_toupper(char_type __c) const;
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
virtual char_type
do_tolower(char_type __c) const;
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
virtual char_type
do_widen(char __c) const;
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
virtual char
do_narrow(char_type, char __dfault) const;
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const;
};
template<typename _CharT>
locale::id ctype<_CharT>::id;
template<>
class ctype<char> : public locale::facet, public ctype_base
{
public:
typedef char char_type;
protected:
__c_locale _M_c_locale_ctype;
bool _M_del;
__to_type _M_toupper;
__to_type _M_tolower;
const mask* _M_table;
mutable char _M_widen_ok;
mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
mutable char _M_narrow_ok;
public:
static locale::id id;
static const size_t table_size = 1 + static_cast<unsigned char>(-1);
explicit
ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
explicit
ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
size_t __refs = 0);
inline bool
is(mask __m, char __c) const;
inline const char*
is(const char* __lo, const char* __hi, mask* __vec) const;
inline const char*
scan_is(mask __m, const char* __lo, const char* __hi) const;
inline const char*
scan_not(mask __m, const char* __lo, const char* __hi) const;
char_type
toupper(char_type __c) const
;
const char_type*
toupper(char_type *__lo, const char_type* __hi) const
;
char_type
tolower(char_type __c) const
;
const char_type*
tolower(char_type* __lo, const char_type* __hi) const
;
char_type
widen(char __c) const
;
const char*
widen(const char* __lo, const char* __hi, char_type* __to) const
;
char
narrow(char_type __c, char __dfault) const
;
const char_type*
narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const
;
const mask*
table() const throw()
;
static const mask*
classic_table() throw();
protected:
virtual
~ctype();
virtual char_type
do_toupper(char_type __c) const;
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
virtual char_type
do_tolower(char_type __c) const;
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
virtual char_type
do_widen(char __c) const
;
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __to) const
;
virtual char
do_narrow(char_type __c, char __dfault) const
;
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const
;
private:
void _M_narrow_init() const;
void _M_widen_init() const;
};
template<>
class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
{
public:
typedef wchar_t char_type;
typedef wctype_t __wmask_type;
protected:
__c_locale _M_c_locale_ctype;
bool _M_narrow_ok;
char _M_narrow[128];
wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
mask _M_bit[16];
__wmask_type _M_wmask[16];
public:
static locale::id id;
explicit
ctype(size_t __refs = 0);
explicit
ctype(__c_locale __cloc, size_t __refs = 0);
protected:
__wmask_type
_M_convert_to_wmask(const mask __m) const throw();
virtual
~ctype();
virtual bool
do_is(mask __m, char_type __c) const;
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const;
virtual char_type
do_toupper(char_type __c) const;
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
virtual char_type
do_tolower(char_type __c) const;
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
virtual char_type
do_widen(char __c) const;
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __to) const;
virtual char
do_narrow(char_type __c, char __dfault) const;
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const;
void
_M_initialize_ctype() throw();
};
template<typename _CharT>
class ctype_byname : public ctype<_CharT>
{
public:
typedef typename ctype<_CharT>::mask mask;
explicit
ctype_byname(const char* __s, size_t __refs = 0);
protected:
virtual
~ctype_byname() ;;
};
template<>
class ctype_byname<char> : public ctype<char>
{
public:
explicit
ctype_byname(const char* __s, size_t __refs = 0);
protected:
virtual
~ctype_byname();
};
template<>
class ctype_byname<wchar_t> : public ctype<wchar_t>
{
public:
explicit
ctype_byname(const char* __s, size_t __refs = 0);
protected:
virtual
~ctype_byname();
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
}
namespace std __attribute__ ((__visibility__ ("default")))
{
class __num_base
{
public:
enum
{
_S_ominus,
_S_oplus,
_S_ox,
_S_oX,
_S_odigits,
_S_odigits_end = _S_odigits + 16,
_S_oudigits = _S_odigits_end,
_S_oudigits_end = _S_oudigits + 16,
_S_oe = _S_odigits + 14,
_S_oE = _S_oudigits + 14,
_S_oend = _S_oudigits_end
};
static const char* _S_atoms_out;
static const char* _S_atoms_in;
enum
{
_S_iminus,
_S_iplus,
_S_ix,
_S_iX,
_S_izero,
_S_ie = _S_izero + 14,
_S_iE = _S_izero + 20,
_S_iend = 26
};
static void
_S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
};
template<typename _CharT>
struct __numpunct_cache : public locale::facet
{
const char* _M_grouping;
size_t _M_grouping_size;
bool _M_use_grouping;
const _CharT* _M_truename;
size_t _M_truename_size;
const _CharT* _M_falsename;
size_t _M_falsename_size;
_CharT _M_decimal_point;
_CharT _M_thousands_sep;
_CharT _M_atoms_out[__num_base::_S_oend];
_CharT _M_atoms_in[__num_base::_S_iend];
bool _M_allocated;
__numpunct_cache(size_t __refs = 0)
;
~__numpunct_cache();
void
_M_cache(const locale& __loc);
private:
__numpunct_cache&
operator=(const __numpunct_cache&);
explicit
__numpunct_cache(const __numpunct_cache&);
};
template<typename _CharT>
class numpunct : public locale::facet
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
typedef __numpunct_cache<_CharT> __cache_type;
protected:
__cache_type* _M_data;
public:
static locale::id id;
explicit
numpunct(size_t __refs = 0)
;
explicit
numpunct(__cache_type* __cache, size_t __refs = 0)
;
explicit
numpunct(__c_locale __cloc, size_t __refs = 0)
;
char_type
decimal_point() const
;
char_type
thousands_sep() const
;
string
grouping() const
;
string_type
truename() const
;
string_type
falsename() const
;
protected:
virtual
~numpunct();
virtual char_type
do_decimal_point() const
;
virtual char_type
do_thousands_sep() const
;
virtual string
do_grouping() const
;
virtual string_type
do_truename() const
;
virtual string_type
do_falsename() const
;
void
_M_initialize_numpunct(__c_locale __cloc = 0);
};
template<typename _CharT>
locale::id numpunct<_CharT>::id;
template<>
numpunct<char>::~numpunct();
template<>
void
numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
template<>
numpunct<wchar_t>::~numpunct();
template<>
void
numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
template<typename _CharT>
class numpunct_byname : public numpunct<_CharT>
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
explicit
numpunct_byname(const char* __s, size_t __refs = 0)
;
protected:
virtual
~numpunct_byname() ;
};
template<typename _CharT, typename _InIter>
class num_get : public locale::facet
{
public:
typedef _CharT char_type;
typedef _InIter iter_type;
static locale::id id;
explicit
num_get(size_t __refs = 0) ;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, bool& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned short& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned int& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long long& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long long& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, float& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, double& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long double& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, void*& __v) const
;
protected:
virtual ~num_get() ;
iter_type
_M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
string&) const;
template<typename _ValueT>
iter_type
_M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
_ValueT&) const;
template<typename _CharT2>
typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
_M_find(const _CharT2*, size_t __len, _CharT2 __c) const
;
template<typename _CharT2>
typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
int>::__type
_M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
;
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long& __v) const
;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned short& __v) const
;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned int& __v) const
;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long& __v) const
;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long long& __v) const
;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long long& __v) const
;
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
double&) const;
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
long double&) const;
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
};
template<typename _CharT, typename _InIter>
locale::id num_get<_CharT, _InIter>::id;
template<typename _CharT, typename _OutIter>
class num_put : public locale::facet
{
public:
typedef _CharT char_type;
typedef _OutIter iter_type;
static locale::id id;
explicit
num_put(size_t __refs = 0) ;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long long __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
long double __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
const void* __v) const
;
protected:
template<typename _ValueT>
iter_type
_M_insert_float(iter_type, ios_base& __io, char_type __fill,
char __mod, _ValueT __v) const;
void
_M_group_float(const char* __grouping, size_t __grouping_size,
char_type __sep, const char_type* __p, char_type* __new,
char_type* __cs, int& __len) const;
template<typename _ValueT>
iter_type
_M_insert_int(iter_type, ios_base& __io, char_type __fill,
_ValueT __v) const;
void
_M_group_int(const char* __grouping, size_t __grouping_size,
char_type __sep, ios_base& __io, char_type* __new,
char_type* __cs, int& __len) const;
void
_M_pad(char_type __fill, streamsize __w, ios_base& __io,
char_type* __new, const char_type* __cs, int& __len) const;
virtual
~num_put() ;;
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const;
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
;
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long __v) const
;
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
long long __v) const
;
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long long __v) const
;
virtual iter_type
do_put(iter_type, ios_base&, char_type, double) const;
virtual iter_type
do_put(iter_type, ios_base&, char_type, long double) const;
virtual iter_type
do_put(iter_type, ios_base&, char_type, const void*) const;
};
template <typename _CharT, typename _OutIter>
locale::id num_put<_CharT, _OutIter>::id;
template<typename _CharT>
bool
isspace(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isprint(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
iscntrl(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isupper(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
islower(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isalpha(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isdigit(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
ispunct(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isxdigit(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isalnum(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isgraph(_CharT __c, const locale& __loc)
;
template<typename _CharT>
_CharT
toupper(_CharT __c, const locale& __loc)
;
template<typename _CharT>
_CharT
tolower(_CharT __c, const locale& __loc)
;
}
#define _LOCALE_FACETS_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Facet>
struct __use_cache
{
const _Facet*
operator() (const locale& __loc) const;
};
template<typename _CharT>
struct __use_cache<__numpunct_cache<_CharT> >
{
const __numpunct_cache<_CharT>*
operator() (const locale& __loc) const
;
};
__attribute__ ((__pure__)) bool
__verify_grouping(const char* __grouping, size_t __grouping_size,
const string& __grouping_tmp) throw ();
template<typename _CharT, typename _ValueT>
int
__int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
ios_base::fmtflags __flags, bool __dec)
;
template<typename _CharT>
_CharT*
__add_grouping(_CharT* __s, _CharT __sep,
const char* __gbeg, size_t __gsize,
const _CharT* __first, const _CharT* __last)
;
extern template class numpunct<char>;
extern template class numpunct_byname<char>;
extern template class num_get<char>;
extern template class num_put<char>;
extern template class ctype_byname<char>;
extern template
const ctype<char>&
use_facet<ctype<char> >(const locale&);
extern template
const numpunct<char>&
use_facet<numpunct<char> >(const locale&);
extern template
const num_put<char>&
use_facet<num_put<char> >(const locale&);
extern template
const num_get<char>&
use_facet<num_get<char> >(const locale&);
extern template
bool
has_facet<ctype<char> >(const locale&);
extern template
bool
has_facet<numpunct<char> >(const locale&);
extern template
bool
has_facet<num_put<char> >(const locale&);
extern template
bool
has_facet<num_get<char> >(const locale&);
extern template class numpunct<wchar_t>;
extern template class numpunct_byname<wchar_t>;
extern template class num_get<wchar_t>;
extern template class num_put<wchar_t>;
extern template class ctype_byname<wchar_t>;
extern template
const ctype<wchar_t>&
use_facet<ctype<wchar_t> >(const locale&);
extern template
const numpunct<wchar_t>&
use_facet<numpunct<wchar_t> >(const locale&);
extern template
const num_put<wchar_t>&
use_facet<num_put<wchar_t> >(const locale&);
extern template
const num_get<wchar_t>&
use_facet<num_get<wchar_t> >(const locale&);
extern template
bool
has_facet<ctype<wchar_t> >(const locale&);
extern template
bool
has_facet<numpunct<wchar_t> >(const locale&);
extern template
bool
has_facet<num_put<wchar_t> >(const locale&);
extern template
bool
has_facet<num_get<wchar_t> >(const locale&);
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Facet>
const _Facet&
__check_facet(const _Facet* __f)
;
template<typename _CharT, typename _Traits>
class basic_ios : public ios_base
{
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef ctype<_CharT> __ctype_type;
typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
__num_put_type;
typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
__num_get_type;
protected:
basic_ostream<_CharT, _Traits>* _M_tie;
mutable char_type _M_fill;
mutable bool _M_fill_init;
basic_streambuf<_CharT, _Traits>* _M_streambuf;
const __ctype_type* _M_ctype;
const __num_put_type* _M_num_put;
const __num_get_type* _M_num_get;
public:
explicit operator bool() const
;
bool
operator!() const
;
iostate
rdstate() const
;
void
clear(iostate __state = goodbit);
void
setstate(iostate __state)
;
void
_M_setstate(iostate __state)
;
bool
good() const
;
bool
eof() const
;
bool
fail() const
;
bool
bad() const
;
iostate
exceptions() const
;
void
exceptions(iostate __except)
;
explicit
basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
;
virtual
~basic_ios() ;
basic_ostream<_CharT, _Traits>*
tie() const
;
basic_ostream<_CharT, _Traits>*
tie(basic_ostream<_CharT, _Traits>* __tiestr)
;
basic_streambuf<_CharT, _Traits>*
rdbuf() const
;
basic_streambuf<_CharT, _Traits>*
rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
basic_ios&
copyfmt(const basic_ios& __rhs);
char_type
fill() const
;
char_type
fill(char_type __ch)
;
locale
imbue(const locale& __loc);
char
narrow(char_type __c, char __dfault) const
;
char_type
widen(char __c) const
;
protected:
basic_ios()
;
void
init(basic_streambuf<_CharT, _Traits>* __sb);
basic_ios(const basic_ios&) = delete;
basic_ios& operator=(const basic_ios&) = delete;
void
move(basic_ios& __rhs)
;
void
move(basic_ios&& __rhs)
;
void
swap(basic_ios& __rhs) noexcept
{
ios_base::_M_swap(__rhs);
_M_cache_locale(_M_ios_locale);
__rhs._M_cache_locale(__rhs._M_ios_locale);
std::swap(_M_tie, __rhs._M_tie);
std::swap(_M_fill, __rhs._M_fill);
std::swap(_M_fill_init, __rhs._M_fill_init);
}
void
set_rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
{ _M_streambuf = __sb; }
void
_M_cache_locale(const locale& __loc);
};
}
#define _BASIC_IOS_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
extern template class basic_ios<char>;
extern template class basic_ios<wchar_t>;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
class basic_ostream : virtual public basic_ios<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_ios<_CharT, _Traits> __ios_type;
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
__num_put_type;
typedef ctype<_CharT> __ctype_type;
explicit
basic_ostream(__streambuf_type* __sb)
;
virtual
~basic_ostream() ;
class sentry;
friend class sentry;
__ostream_type&
operator<<(__ostream_type& (*__pf)(__ostream_type&))
;
__ostream_type&
operator<<(__ios_type& (*__pf)(__ios_type&))
;
__ostream_type&
operator<<(ios_base& (*__pf) (ios_base&))
;
__ostream_type&
operator<<(long __n)
;
__ostream_type&
operator<<(unsigned long __n)
;
__ostream_type&
operator<<(bool __n)
;
__ostream_type&
operator<<(short __n);
__ostream_type&
operator<<(unsigned short __n)
;
__ostream_type&
operator<<(int __n);
__ostream_type&
operator<<(unsigned int __n)
;
__ostream_type&
operator<<(long long __n)
;
__ostream_type&
operator<<(unsigned long long __n)
;
__ostream_type&
operator<<(double __f)
;
__ostream_type&
operator<<(float __f)
;
__ostream_type&
operator<<(long double __f)
;
__ostream_type&
operator<<(const void* __p)
;
__ostream_type&
operator<<(__streambuf_type* __sb);
__ostream_type&
put(char_type __c);
void
_M_write(const char_type* __s, streamsize __n)
;
__ostream_type&
write(const char_type* __s, streamsize __n);
__ostream_type&
flush();
pos_type
tellp();
__ostream_type&
seekp(pos_type);
__ostream_type&
seekp(off_type, ios_base::seekdir);
protected:
basic_ostream()
;
basic_ostream(basic_iostream<_CharT, _Traits>&) ;
basic_ostream(const basic_ostream&) = delete;
basic_ostream(basic_ostream&& __rhs)
;
basic_ostream& operator=(const basic_ostream&) = delete;
basic_ostream&
operator=(basic_ostream&& __rhs)
;
void
swap(basic_ostream& __rhs)
;
template<typename _ValueT>
__ostream_type&
_M_insert(_ValueT __v);
};
template <typename _CharT, typename _Traits>
class basic_ostream<_CharT, _Traits>::sentry
{
bool _M_ok;
basic_ostream<_CharT, _Traits>& _M_os;
public:
explicit
sentry(basic_ostream<_CharT, _Traits>& __os);
~sentry()
;
explicit
operator bool() const
;
};
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
;
template <class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, char __c)
;
template<class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
;
template<class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits> &
operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
template<class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
;
template<class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
;
template<class _Traits>
basic_ostream<char, _Traits> &
operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
endl(basic_ostream<_CharT, _Traits>& __os)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
ends(basic_ostream<_CharT, _Traits>& __os)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
flush(basic_ostream<_CharT, _Traits>& __os)
;
template<typename _CharT, typename _Traits, typename _Tp>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp& __x)
;
}
#define _OSTREAM_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
;
extern template class basic_ostream<char>;
extern template ostream& endl(ostream&);
extern template ostream& ends(ostream&);
extern template ostream& flush(ostream&);
extern template ostream& operator<<(ostream&, char);
extern template ostream& operator<<(ostream&, unsigned char);
extern template ostream& operator<<(ostream&, signed char);
extern template ostream& operator<<(ostream&, const char*);
extern template ostream& operator<<(ostream&, const unsigned char*);
extern template ostream& operator<<(ostream&, const signed char*);
extern template ostream& ostream::_M_insert(long);
extern template ostream& ostream::_M_insert(unsigned long);
extern template ostream& ostream::_M_insert(bool);
extern template ostream& ostream::_M_insert(long long);
extern template ostream& ostream::_M_insert(unsigned long long);
extern template ostream& ostream::_M_insert(double);
extern template ostream& ostream::_M_insert(long double);
extern template ostream& ostream::_M_insert(const void*);
extern template class basic_ostream<wchar_t>;
extern template wostream& endl(wostream&);
extern template wostream& ends(wostream&);
extern template wostream& flush(wostream&);
extern template wostream& operator<<(wostream&, wchar_t);
extern template wostream& operator<<(wostream&, char);
extern template wostream& operator<<(wostream&, const wchar_t*);
extern template wostream& operator<<(wostream&, const char*);
extern template wostream& wostream::_M_insert(long);
extern template wostream& wostream::_M_insert(unsigned long);
extern template wostream& wostream::_M_insert(bool);
extern template wostream& wostream::_M_insert(long long);
extern template wostream& wostream::_M_insert(unsigned long long);
extern template wostream& wostream::_M_insert(double);
extern template wostream& wostream::_M_insert(long double);
extern template wostream& wostream::_M_insert(const void*);
}
#define _GLIBCXX_ISTREAM 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
class basic_istream : virtual public basic_ios<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_ios<_CharT, _Traits> __ios_type;
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
__num_get_type;
typedef ctype<_CharT> __ctype_type;
protected:
streamsize _M_gcount;
public:
explicit
basic_istream(__streambuf_type* __sb)
;
virtual
~basic_istream()
;
class sentry;
friend class sentry;
__istream_type&
operator>>(__istream_type& (*__pf)(__istream_type&))
;
__istream_type&
operator>>(__ios_type& (*__pf)(__ios_type&))
;
__istream_type&
operator>>(ios_base& (*__pf)(ios_base&))
;
__istream_type&
operator>>(bool& __n)
;
__istream_type&
operator>>(short& __n);
__istream_type&
operator>>(unsigned short& __n)
;
__istream_type&
operator>>(int& __n);
__istream_type&
operator>>(unsigned int& __n)
;
__istream_type&
operator>>(long& __n)
;
__istream_type&
operator>>(unsigned long& __n)
;
__istream_type&
operator>>(long long& __n)
;
__istream_type&
operator>>(unsigned long long& __n)
;
__istream_type&
operator>>(float& __f)
;
__istream_type&
operator>>(double& __f)
;
__istream_type&
operator>>(long double& __f)
;
__istream_type&
operator>>(void*& __p)
;
__istream_type&
operator>>(__streambuf_type* __sb);
streamsize
gcount() const
;
int_type
get();
__istream_type&
get(char_type& __c);
__istream_type&
get(char_type* __s, streamsize __n, char_type __delim);
__istream_type&
get(char_type* __s, streamsize __n)
;
__istream_type&
get(__streambuf_type& __sb, char_type __delim);
__istream_type&
get(__streambuf_type& __sb)
;
__istream_type&
getline(char_type* __s, streamsize __n, char_type __delim);
__istream_type&
getline(char_type* __s, streamsize __n)
;
__istream_type&
ignore(streamsize __n, int_type __delim);
__istream_type&
ignore(streamsize __n);
__istream_type&
ignore();
int_type
peek();
__istream_type&
read(char_type* __s, streamsize __n);
streamsize
readsome(char_type* __s, streamsize __n);
__istream_type&
putback(char_type __c);
__istream_type&
unget();
int
sync();
pos_type
tellg();
__istream_type&
seekg(pos_type);
__istream_type&
seekg(off_type, ios_base::seekdir);
protected:
basic_istream()
;
basic_istream(const basic_istream&) = delete;
basic_istream(basic_istream&& __rhs)
;
basic_istream& operator=(const basic_istream&) = delete;
basic_istream&
operator=(basic_istream&& __rhs)
;
void
swap(basic_istream& __rhs)
;
template<typename _ValueT>
__istream_type&
_M_extract(_ValueT& __v);
};
template<>
basic_istream<char>&
basic_istream<char>::
getline(char_type* __s, streamsize __n, char_type __delim);
template<>
basic_istream<char>&
basic_istream<char>::
ignore(streamsize __n);
template<>
basic_istream<char>&
basic_istream<char>::
ignore(streamsize __n, int_type __delim);
template<>
basic_istream<wchar_t>&
basic_istream<wchar_t>::
getline(char_type* __s, streamsize __n, char_type __delim);
template<>
basic_istream<wchar_t>&
basic_istream<wchar_t>::
ignore(streamsize __n);
template<>
basic_istream<wchar_t>&
basic_istream<wchar_t>::
ignore(streamsize __n, int_type __delim);
template<typename _CharT, typename _Traits>
class basic_istream<_CharT, _Traits>::sentry
{
bool _M_ok;
public:
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef typename __istream_type::__ctype_type __ctype_type;
typedef typename _Traits::int_type __int_type;
explicit
sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
explicit
operator bool() const
;
};
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
template<class _Traits>
basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
;
template<class _Traits>
basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
;
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
template<>
basic_istream<char>&
operator>>(basic_istream<char>& __in, char* __s);
template<class _Traits>
basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
;
template<class _Traits>
basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
;
template<typename _CharT, typename _Traits>
class basic_iostream
: public basic_istream<_CharT, _Traits>,
public basic_ostream<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_ostream<_CharT, _Traits> __ostream_type;
explicit
basic_iostream(basic_streambuf<_CharT, _Traits>* __sb) ;
virtual
~basic_iostream() ;
protected:
basic_iostream() ;
basic_iostream(const basic_iostream&) = delete;
basic_iostream(basic_iostream&& __rhs)
;
basic_iostream& operator=(const basic_iostream&) = delete;
basic_iostream&
operator=(basic_iostream&& __rhs)
;
void
swap(basic_iostream& __rhs)
;
};
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
ws(basic_istream<_CharT, _Traits>& __is);
template<typename _CharT, typename _Traits, typename _Tp>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x)
;
}
#define _ISTREAM_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
;
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
;
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
ws(basic_istream<_CharT, _Traits>& __in)
;
extern template class basic_istream<char>;
extern template istream& ws(istream&);
extern template istream& operator>>(istream&, char&);
extern template istream& operator>>(istream&, char*);
extern template istream& operator>>(istream&, unsigned char&);
extern template istream& operator>>(istream&, signed char&);
extern template istream& operator>>(istream&, unsigned char*);
extern template istream& operator>>(istream&, signed char*);
extern template istream& istream::_M_extract(unsigned short&);
extern template istream& istream::_M_extract(unsigned int&);
extern template istream& istream::_M_extract(long&);
extern template istream& istream::_M_extract(unsigned long&);
extern template istream& istream::_M_extract(bool&);
extern template istream& istream::_M_extract(long long&);
extern template istream& istream::_M_extract(unsigned long long&);
extern template istream& istream::_M_extract(float&);
extern template istream& istream::_M_extract(double&);
extern template istream& istream::_M_extract(long double&);
extern template istream& istream::_M_extract(void*&);
extern template class basic_iostream<char>;
extern template class basic_istream<wchar_t>;
extern template wistream& ws(wistream&);
extern template wistream& operator>>(wistream&, wchar_t&);
extern template wistream& operator>>(wistream&, wchar_t*);
extern template wistream& wistream::_M_extract(unsigned short&);
extern template wistream& wistream::_M_extract(unsigned int&);
extern template wistream& wistream::_M_extract(long&);
extern template wistream& wistream::_M_extract(unsigned long&);
extern template wistream& wistream::_M_extract(bool&);
extern template wistream& wistream::_M_extract(long long&);
extern template wistream& wistream::_M_extract(unsigned long long&);
extern template wistream& wistream::_M_extract(float&);
extern template wistream& wistream::_M_extract(double&);
extern template wistream& wistream::_M_extract(long double&);
extern template wistream& wistream::_M_extract(void*&);
extern template class basic_iostream<wchar_t>;
}
#define _STREAM_ITERATOR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp, typename _CharT = char,
typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
class istream_iterator
: public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef basic_istream<_CharT, _Traits> istream_type;
private:
istream_type* _M_stream;
_Tp _M_value;
bool _M_ok;
public:
constexpr istream_iterator()
: _M_stream(0), _M_value(), _M_ok(false) {}
istream_iterator(istream_type& __s)
;
istream_iterator(const istream_iterator& __obj)
;
const _Tp&
operator*() const
;
const _Tp*
operator->() const ;
istream_iterator&
operator++()
;
istream_iterator
operator++(int)
;
bool
_M_equal(const istream_iterator& __x) const
;
private:
void
_M_read()
;
};
template<typename _Tp, typename _CharT, typename _Traits, typename _Dist>
bool
operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
;
template <class _Tp, class _CharT, class _Traits, class _Dist>
bool
operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
;
template<typename _Tp, typename _CharT = char,
typename _Traits = char_traits<_CharT> >
class ostream_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef basic_ostream<_CharT, _Traits> ostream_type;
private:
ostream_type* _M_stream;
const _CharT* _M_string;
public:
ostream_iterator(ostream_type& __s) ;
ostream_iterator(ostream_type& __s, const _CharT* __c) ;
ostream_iterator(const ostream_iterator& __obj) ;
ostream_iterator&
operator=(const _Tp& __value)
;
ostream_iterator&
operator*()
;
ostream_iterator&
operator++()
;
ostream_iterator&
operator++(int)
;
};
}
namespace boost
{
namespace detail {
template <class Category, class T, class Distance, class Pointer, class Reference>
struct iterator_base : std::iterator<Category, T, Distance, Pointer, Reference> {};
}
template <class Category, class T, class Distance = std::ptrdiff_t,
class Pointer = T*, class Reference = T&>
struct iterator : boost::detail::iterator_base<Category, T, Distance, Pointer, Reference> {};
}
#define WORKAROUND_DWA2002126_HPP
#define __BORLANDC___WORKAROUND_GUARD 1
#define __CODEGEARC___WORKAROUND_GUARD 1
#define _MSC_VER_WORKAROUND_GUARD 1
#define _MSC_FULL_VER_WORKAROUND_GUARD 1
#define BOOST_MSVC_WORKAROUND_GUARD 1
#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 1
#define __GNUC___WORKAROUND_GUARD 0
#define __GNUC_MINOR___WORKAROUND_GUARD 0
#define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 0
#define __IBMCPP___WORKAROUND_GUARD 1
#define __SUNPRO_CC_WORKAROUND_GUARD 1
#define __DECCXX_VER_WORKAROUND_GUARD 1
#define __MWERKS___WORKAROUND_GUARD 1
#define __EDG___WORKAROUND_GUARD 1
#define __EDG_VERSION___WORKAROUND_GUARD 1
#define __HP_aCC_WORKAROUND_GUARD 1
#define __hpxstd98_WORKAROUND_GUARD 1
#define _CRAYC_WORKAROUND_GUARD 1
#define __DMC___WORKAROUND_GUARD 1
#define MPW_CPLUS_WORKAROUND_GUARD 1
#define __COMO___WORKAROUND_GUARD 1
#define __COMO_VERSION___WORKAROUND_GUARD 1
#define __INTEL_COMPILER_WORKAROUND_GUARD 1
#define __ICL_WORKAROUND_GUARD 1
#define _COMPILER_VERSION_WORKAROUND_GUARD 1
#define _RWSTD_VER_WORKAROUND_GUARD 1
#define BOOST_RWSTD_VER_WORKAROUND_GUARD 1
#define __GLIBCPP___WORKAROUND_GUARD 1
#define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 1
#define __SGI_STL_PORT_WORKAROUND_GUARD 1
#define _STLPORT_VERSION_WORKAROUND_GUARD 1
#define __LIBCOMO_VERSION___WORKAROUND_GUARD 1
#define _CPPLIB_VER_WORKAROUND_GUARD 1
#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 1
#define BOOST_INTEL_WIN_WORKAROUND_GUARD 1
#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 1
#define BOOST_INTEL_WORKAROUND_GUARD 1
#define BOOST_MPL_CFG_GCC_WORKAROUND_GUARD 0
#define BOOST_WORKAROUND(symbol,test) ((symbol ## _WORKAROUND_GUARD + 0 == 0) && (symbol != 0) && (1 % (( (symbol test) ) + 1)))
#define BOOST_TESTED_AT(value) != ((value)-(value))
namespace boost {
namespace detail {
template <typename T> class empty_base {
};
}
}
namespace boost
{
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct less_than_comparable2 : B
{
friend bool operator<=(const T& x, const U& y) ;
friend bool operator>=(const T& x, const U& y) ;
friend bool operator>(const U& x, const T& y) ;
friend bool operator<(const U& x, const T& y) ;
friend bool operator<=(const U& x, const T& y) ;
friend bool operator>=(const U& x, const T& y) ;
};
template <class T, class B = ::boost::detail::empty_base<T> >
struct less_than_comparable1 : B
{
friend bool operator>(const T& x, const T& y) ;
friend bool operator<=(const T& x, const T& y) ;
friend bool operator>=(const T& x, const T& y) ;
};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct equality_comparable2 : B
{
friend bool operator==(const U& y, const T& x) ;
friend bool operator!=(const U& y, const T& x) ;
friend bool operator!=(const T& y, const U& x) ;
};
template <class T, class B = ::boost::detail::empty_base<T> >
struct equality_comparable1 : B
{
friend bool operator!=(const T& x, const T& y) ;
};
#define BOOST_OPERATOR2_LEFT(name) name ##2 ##_ ##left
#define BOOST_BINARY_OPERATOR_COMMUTATIVE(NAME,OP) template <class T, class U, class B = ::boost::detail::empty_base<T> > struct NAME ##2 : B { friend T operator OP( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } friend T operator OP( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv OP ##= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct NAME ##1 : B { friend T operator OP( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } };
#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE(NAME,OP) template <class T, class U, class B = ::boost::detail::empty_base<T> > struct NAME ##2 : B { friend T operator OP( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct BOOST_OPERATOR2_LEFT(NAME) : B { friend T operator OP( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct NAME ##1 : B { friend T operator OP( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct multipliable2 : B { friend T operator *( const T& lhs, const U& rhs ) ; friend T operator *( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct multipliable1 : B { friend T operator *( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct addable2 : B { friend T operator +( const T& lhs, const U& rhs ) ; friend T operator +( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct addable1 : B { friend T operator +( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct subtractable2 : B { friend T operator -( const T& lhs, const U& rhs ) ; }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct subtractable2_left : B { friend T operator -( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct subtractable1 : B { friend T operator -( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct dividable2 : B { friend T operator /( const T& lhs, const U& rhs ) ; }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct dividable2_left : B { friend T operator /( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct dividable1 : B { friend T operator /( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct modable2 : B { friend T operator %( const T& lhs, const U& rhs ) ; }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct modable2_left : B { friend T operator %( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct modable1 : B { friend T operator %( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct xorable2 : B { friend T operator ^( const T& lhs, const U& rhs ) ; friend T operator ^( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct xorable1 : B { friend T operator ^( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct andable2 : B { friend T operator &( const T& lhs, const U& rhs ) ; friend T operator &( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct andable1 : B { friend T operator &( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct orable2 : B { friend T operator |( const T& lhs, const U& rhs ) ; friend T operator |( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct orable1 : B { friend T operator |( const T& lhs, const T& rhs ) ; };
#undef BOOST_BINARY_OPERATOR_COMMUTATIVE
#undef BOOST_BINARY_OPERATOR_NON_COMMUTATIVE
#undef BOOST_OPERATOR2_LEFT
template <class T, class B = ::boost::detail::empty_base<T> >
struct incrementable : B
{
friend T operator++(T& x, int)
;
private:
typedef T incrementable_type;
};
template <class T, class B = ::boost::detail::empty_base<T> >
struct decrementable : B
{
friend T operator--(T& x, int)
;
private:
typedef T decrementable_type;
};
template <class T, class P, class B = ::boost::detail::empty_base<T> >
struct dereferenceable : B
{
P operator->() const
;
};
template <class T, class I, class R, class B = ::boost::detail::empty_base<T> >
struct indexable : B
{
R operator[](I n) const
;
};
#define BOOST_BINARY_OPERATOR(NAME,OP) template <class T, class U, class B = ::boost::detail::empty_base<T> > struct NAME ##2 : B { friend T operator OP( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct NAME ##1 : B { friend T operator OP( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct left_shiftable2 : B { friend T operator <<( const T& lhs, const U& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct left_shiftable1 : B { friend T operator <<( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct right_shiftable2 : B { friend T operator >>( const T& lhs, const U& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct right_shiftable1 : B { friend T operator >>( const T& lhs, const T& rhs ) ; };
#undef BOOST_BINARY_OPERATOR
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct equivalent2 : B
{
friend bool operator==(const T& x, const U& y)
;
};
template <class T, class B = ::boost::detail::empty_base<T> >
struct equivalent1 : B
{
friend bool operator==(const T&x, const T&y)
;
};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct partially_ordered2 : B
{
friend bool operator<=(const T& x, const U& y)
;
friend bool operator>=(const T& x, const U& y)
;
friend bool operator>(const U& x, const T& y)
;
friend bool operator<(const U& x, const T& y)
;
friend bool operator<=(const U& x, const T& y)
;
friend bool operator>=(const U& x, const T& y)
;
};
template <class T, class B = ::boost::detail::empty_base<T> >
struct partially_ordered1 : B
{
friend bool operator>(const T& x, const T& y)
;
friend bool operator<=(const T& x, const T& y)
;
friend bool operator>=(const T& x, const T& y)
;
};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct totally_ordered2
: less_than_comparable2<T, U
, equality_comparable2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct totally_ordered1
: less_than_comparable1<T
, equality_comparable1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct additive2
: addable2<T, U
, subtractable2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct additive1
: addable1<T
, subtractable1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct multiplicative2
: multipliable2<T, U
, dividable2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct multiplicative1
: multipliable1<T
, dividable1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct integer_multiplicative2
: multiplicative2<T, U
, modable2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct integer_multiplicative1
: multiplicative1<T
, modable1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct arithmetic2
: additive2<T, U
, multiplicative2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct arithmetic1
: additive1<T
, multiplicative1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct integer_arithmetic2
: additive2<T, U
, integer_multiplicative2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct integer_arithmetic1
: additive1<T
, integer_multiplicative1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct bitwise2
: xorable2<T, U
, andable2<T, U
, orable2<T, U, B
> > > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct bitwise1
: xorable1<T
, andable1<T
, orable1<T, B
> > > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct unit_steppable
: incrementable<T
, decrementable<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct shiftable2
: left_shiftable2<T, U
, right_shiftable2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct shiftable1
: left_shiftable1<T
, right_shiftable1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ring_operators2
: additive2<T, U
, subtractable2_left<T, U
, multipliable2<T, U, B
> > > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct ring_operators1
: additive1<T
, multipliable1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ordered_ring_operators2
: ring_operators2<T, U
, totally_ordered2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct ordered_ring_operators1
: ring_operators1<T
, totally_ordered1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct field_operators2
: ring_operators2<T, U
, dividable2<T, U
, dividable2_left<T, U, B
> > > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct field_operators1
: ring_operators1<T
, dividable1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ordered_field_operators2
: field_operators2<T, U
, totally_ordered2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct ordered_field_operators1
: field_operators1<T
, totally_ordered1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct euclidian_ring_operators2
: ring_operators2<T, U
, dividable2<T, U
, dividable2_left<T, U
, modable2<T, U
, modable2_left<T, U, B
> > > > > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct euclidian_ring_operators1
: ring_operators1<T
, dividable1<T
, modable1<T, B
> > > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ordered_euclidian_ring_operators2
: totally_ordered2<T, U
, euclidian_ring_operators2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct ordered_euclidian_ring_operators1
: totally_ordered1<T
, euclidian_ring_operators1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct euclidean_ring_operators2
: ring_operators2<T, U
, dividable2<T, U
, dividable2_left<T, U
, modable2<T, U
, modable2_left<T, U, B
> > > > > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct euclidean_ring_operators1
: ring_operators1<T
, dividable1<T
, modable1<T, B
> > > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ordered_euclidean_ring_operators2
: totally_ordered2<T, U
, euclidean_ring_operators2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct ordered_euclidean_ring_operators1
: totally_ordered1<T
, euclidean_ring_operators1<T, B
> > {};
template <class T, class P, class B = ::boost::detail::empty_base<T> >
struct input_iteratable
: equality_comparable1<T
, incrementable<T
, dereferenceable<T, P, B
> > > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct output_iteratable
: incrementable<T, B
> {};
template <class T, class P, class B = ::boost::detail::empty_base<T> >
struct forward_iteratable
: input_iteratable<T, P, B
> {};
template <class T, class P, class B = ::boost::detail::empty_base<T> >
struct bidirectional_iteratable
: forward_iteratable<T, P
, decrementable<T, B
> > {};
template <class T, class P, class D, class R, class B = ::boost::detail::empty_base<T> >
struct random_access_iteratable
: bidirectional_iteratable<T, P
, less_than_comparable1<T
, additive2<T, D
, indexable<T, D, R, B
> > > > {};
}
#define BOOST_IMPORT_TEMPLATE4(template_name)
#define BOOST_IMPORT_TEMPLATE3(template_name)
#define BOOST_IMPORT_TEMPLATE2(template_name)
#define BOOST_IMPORT_TEMPLATE1(template_name)
namespace boost {
namespace detail {
struct true_t {};
struct false_t {};
}
template<class T> struct is_chained_base {
typedef ::boost::detail::false_t value;
};
}
#define BOOST_OPERATOR_TEMPLATE4(template_name4) BOOST_IMPORT_TEMPLATE4(template_name4) template<class T, class U, class V, class W, class B> struct is_chained_base< ::boost::template_name4<T, U, V, W, B> > { typedef ::boost::detail::true_t value; };
#define BOOST_OPERATOR_TEMPLATE3(template_name3) BOOST_IMPORT_TEMPLATE3(template_name3) template<class T, class U, class V, class B> struct is_chained_base< ::boost::template_name3<T, U, V, B> > { typedef ::boost::detail::true_t value; };
#define BOOST_OPERATOR_TEMPLATE2(template_name2) BOOST_IMPORT_TEMPLATE2(template_name2) template<class T, class U, class B> struct is_chained_base< ::boost::template_name2<T, U, B> > { typedef ::boost::detail::true_t value; };
#define BOOST_OPERATOR_TEMPLATE1(template_name1) BOOST_IMPORT_TEMPLATE1(template_name1) template<class T, class B> struct is_chained_base< ::boost::template_name1<T, B> > { typedef ::boost::detail::true_t value; };
#define BOOST_OPERATOR_TEMPLATE(template_name) template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct template_name : template_name ##2<T, U, B> {}; template<class T, class U, class B> struct template_name<T, U, B, ::boost::detail::true_t> : template_name ##1<T, U> {}; template <class T, class B> struct template_name<T, T, B, ::boost::detail::false_t> : template_name ##1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::template_name<T, U, B, O> > { typedef ::boost::detail::true_t value; }; BOOST_OPERATOR_TEMPLATE2(template_name ##2) BOOST_OPERATOR_TEMPLATE1(template_name ##1)
namespace boost {
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct less_than_comparable : less_than_comparable2<T, U, B> {}; template<class T, class U, class B> struct less_than_comparable<T, U, B, ::boost::detail::true_t> : less_than_comparable1<T, U> {}; template <class T, class B> struct less_than_comparable<T, T, B, ::boost::detail::false_t> : less_than_comparable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::less_than_comparable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::less_than_comparable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::less_than_comparable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct equality_comparable : equality_comparable2<T, U, B> {}; template<class T, class U, class B> struct equality_comparable<T, U, B, ::boost::detail::true_t> : equality_comparable1<T, U> {}; template <class T, class B> struct equality_comparable<T, T, B, ::boost::detail::false_t> : equality_comparable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::equality_comparable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::equality_comparable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::equality_comparable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct multipliable : multipliable2<T, U, B> {}; template<class T, class U, class B> struct multipliable<T, U, B, ::boost::detail::true_t> : multipliable1<T, U> {}; template <class T, class B> struct multipliable<T, T, B, ::boost::detail::false_t> : multipliable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::multipliable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::multipliable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::multipliable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct addable : addable2<T, U, B> {}; template<class T, class U, class B> struct addable<T, U, B, ::boost::detail::true_t> : addable1<T, U> {}; template <class T, class B> struct addable<T, T, B, ::boost::detail::false_t> : addable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::addable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::addable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::addable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct subtractable : subtractable2<T, U, B> {}; template<class T, class U, class B> struct subtractable<T, U, B, ::boost::detail::true_t> : subtractable1<T, U> {}; template <class T, class B> struct subtractable<T, T, B, ::boost::detail::false_t> : subtractable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::subtractable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::subtractable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::subtractable1<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< ::boost::subtractable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct dividable : dividable2<T, U, B> {}; template<class T, class U, class B> struct dividable<T, U, B, ::boost::detail::true_t> : dividable1<T, U> {}; template <class T, class B> struct dividable<T, T, B, ::boost::detail::false_t> : dividable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::dividable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::dividable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::dividable1<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< ::boost::dividable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct modable : modable2<T, U, B> {}; template<class T, class U, class B> struct modable<T, U, B, ::boost::detail::true_t> : modable1<T, U> {}; template <class T, class B> struct modable<T, T, B, ::boost::detail::false_t> : modable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::modable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::modable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::modable1<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< ::boost::modable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct xorable : xorable2<T, U, B> {}; template<class T, class U, class B> struct xorable<T, U, B, ::boost::detail::true_t> : xorable1<T, U> {}; template <class T, class B> struct xorable<T, T, B, ::boost::detail::false_t> : xorable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::xorable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::xorable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::xorable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct andable : andable2<T, U, B> {}; template<class T, class U, class B> struct andable<T, U, B, ::boost::detail::true_t> : andable1<T, U> {}; template <class T, class B> struct andable<T, T, B, ::boost::detail::false_t> : andable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::andable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::andable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::andable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct orable : orable2<T, U, B> {}; template<class T, class U, class B> struct orable<T, U, B, ::boost::detail::true_t> : orable1<T, U> {}; template <class T, class B> struct orable<T, T, B, ::boost::detail::false_t> : orable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::orable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::orable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::orable1<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class B> struct is_chained_base< ::boost::incrementable<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class B> struct is_chained_base< ::boost::decrementable<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< ::boost::dereferenceable<T, U, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class V, class B> struct is_chained_base< ::boost::indexable<T, U, V, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct left_shiftable : left_shiftable2<T, U, B> {}; template<class T, class U, class B> struct left_shiftable<T, U, B, ::boost::detail::true_t> : left_shiftable1<T, U> {}; template <class T, class B> struct left_shiftable<T, T, B, ::boost::detail::false_t> : left_shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::left_shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::left_shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::left_shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct right_shiftable : right_shiftable2<T, U, B> {}; template<class T, class U, class B> struct right_shiftable<T, U, B, ::boost::detail::true_t> : right_shiftable1<T, U> {}; template <class T, class B> struct right_shiftable<T, T, B, ::boost::detail::false_t> : right_shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::right_shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::right_shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::right_shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct equivalent : equivalent2<T, U, B> {}; template<class T, class U, class B> struct equivalent<T, U, B, ::boost::detail::true_t> : equivalent1<T, U> {}; template <class T, class B> struct equivalent<T, T, B, ::boost::detail::false_t> : equivalent1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::equivalent<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::equivalent2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::equivalent1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct partially_ordered : partially_ordered2<T, U, B> {}; template<class T, class U, class B> struct partially_ordered<T, U, B, ::boost::detail::true_t> : partially_ordered1<T, U> {}; template <class T, class B> struct partially_ordered<T, T, B, ::boost::detail::false_t> : partially_ordered1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::partially_ordered<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::partially_ordered2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::partially_ordered1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct totally_ordered : totally_ordered2<T, U, B> {}; template<class T, class U, class B> struct totally_ordered<T, U, B, ::boost::detail::true_t> : totally_ordered1<T, U> {}; template <class T, class B> struct totally_ordered<T, T, B, ::boost::detail::false_t> : totally_ordered1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::totally_ordered<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::totally_ordered2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::totally_ordered1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct additive : additive2<T, U, B> {}; template<class T, class U, class B> struct additive<T, U, B, ::boost::detail::true_t> : additive1<T, U> {}; template <class T, class B> struct additive<T, T, B, ::boost::detail::false_t> : additive1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::additive<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::additive2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::additive1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct multiplicative : multiplicative2<T, U, B> {}; template<class T, class U, class B> struct multiplicative<T, U, B, ::boost::detail::true_t> : multiplicative1<T, U> {}; template <class T, class B> struct multiplicative<T, T, B, ::boost::detail::false_t> : multiplicative1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::multiplicative<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::multiplicative2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::multiplicative1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct integer_multiplicative : integer_multiplicative2<T, U, B> {}; template<class T, class U, class B> struct integer_multiplicative<T, U, B, ::boost::detail::true_t> : integer_multiplicative1<T, U> {}; template <class T, class B> struct integer_multiplicative<T, T, B, ::boost::detail::false_t> : integer_multiplicative1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::integer_multiplicative<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::integer_multiplicative2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::integer_multiplicative1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct arithmetic : arithmetic2<T, U, B> {}; template<class T, class U, class B> struct arithmetic<T, U, B, ::boost::detail::true_t> : arithmetic1<T, U> {}; template <class T, class B> struct arithmetic<T, T, B, ::boost::detail::false_t> : arithmetic1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::arithmetic<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::arithmetic2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::arithmetic1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct integer_arithmetic : integer_arithmetic2<T, U, B> {}; template<class T, class U, class B> struct integer_arithmetic<T, U, B, ::boost::detail::true_t> : integer_arithmetic1<T, U> {}; template <class T, class B> struct integer_arithmetic<T, T, B, ::boost::detail::false_t> : integer_arithmetic1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::integer_arithmetic<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::integer_arithmetic2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::integer_arithmetic1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct bitwise : bitwise2<T, U, B> {}; template<class T, class U, class B> struct bitwise<T, U, B, ::boost::detail::true_t> : bitwise1<T, U> {}; template <class T, class B> struct bitwise<T, T, B, ::boost::detail::false_t> : bitwise1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::bitwise<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::bitwise2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::bitwise1<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class B> struct is_chained_base< ::boost::unit_steppable<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct shiftable : shiftable2<T, U, B> {}; template<class T, class U, class B> struct shiftable<T, U, B, ::boost::detail::true_t> : shiftable1<T, U> {}; template <class T, class B> struct shiftable<T, T, B, ::boost::detail::false_t> : shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ring_operators : ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ring_operators<T, U, B, ::boost::detail::true_t> : ring_operators1<T, U> {}; template <class T, class B> struct ring_operators<T, T, B, ::boost::detail::false_t> : ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_ring_operators : ordered_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_ring_operators1<T, U> {}; template <class T, class B> struct ordered_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct field_operators : field_operators2<T, U, B> {}; template<class T, class U, class B> struct field_operators<T, U, B, ::boost::detail::true_t> : field_operators1<T, U> {}; template <class T, class B> struct field_operators<T, T, B, ::boost::detail::false_t> : field_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::field_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::field_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::field_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_field_operators : ordered_field_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_field_operators<T, U, B, ::boost::detail::true_t> : ordered_field_operators1<T, U> {}; template <class T, class B> struct ordered_field_operators<T, T, B, ::boost::detail::false_t> : ordered_field_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_field_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_field_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_field_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct euclidian_ring_operators : euclidian_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct euclidian_ring_operators<T, U, B, ::boost::detail::true_t> : euclidian_ring_operators1<T, U> {}; template <class T, class B> struct euclidian_ring_operators<T, T, B, ::boost::detail::false_t> : euclidian_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::euclidian_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::euclidian_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::euclidian_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_euclidian_ring_operators : ordered_euclidian_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_euclidian_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_euclidian_ring_operators1<T, U> {}; template <class T, class B> struct ordered_euclidian_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_euclidian_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_euclidian_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_euclidian_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_euclidian_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct euclidean_ring_operators : euclidean_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct euclidean_ring_operators<T, U, B, ::boost::detail::true_t> : euclidean_ring_operators1<T, U> {}; template <class T, class B> struct euclidean_ring_operators<T, T, B, ::boost::detail::false_t> : euclidean_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::euclidean_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::euclidean_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::euclidean_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_euclidean_ring_operators : ordered_euclidean_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_euclidean_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_euclidean_ring_operators1<T, U> {}; template <class T, class B> struct ordered_euclidean_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_euclidean_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_euclidean_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_euclidean_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_euclidean_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< ::boost::input_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
template<class T, class B> struct is_chained_base< ::boost::output_iteratable<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< ::boost::forward_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< ::boost::bidirectional_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class V, class W, class B> struct is_chained_base< ::boost::random_access_iteratable<T, U, V, W, B> > { typedef ::boost::detail::true_t value; };
#undef BOOST_OPERATOR_TEMPLATE
#undef BOOST_OPERATOR_TEMPLATE4
#undef BOOST_OPERATOR_TEMPLATE3
#undef BOOST_OPERATOR_TEMPLATE2
#undef BOOST_OPERATOR_TEMPLATE1
#undef BOOST_IMPORT_TEMPLATE1
#undef BOOST_IMPORT_TEMPLATE2
#undef BOOST_IMPORT_TEMPLATE3
#undef BOOST_IMPORT_TEMPLATE4
template <class T, class U>
struct operators2
: totally_ordered2<T,U
, integer_arithmetic2<T,U
, bitwise2<T,U
> > > {};
template <class T, class U = T>
struct operators : operators2<T, U> {};
template <class T> struct operators<T, T>
: totally_ordered<T
, integer_arithmetic<T
, bitwise<T
, unit_steppable<T
> > > > {};
template <class T,
class V,
class D = std::ptrdiff_t,
class P = V const *,
class R = V const &>
struct input_iterator_helper
: input_iteratable<T, P
, boost::iterator<std::input_iterator_tag, V, D, P, R
> > {};
template<class T>
struct output_iterator_helper
: output_iteratable<T
, boost::iterator<std::output_iterator_tag, void, void, void, void
> >
{
T& operator*() ;
T& operator++() ;
};
template <class T,
class V,
class D = std::ptrdiff_t,
class P = V*,
class R = V&>
struct forward_iterator_helper
: forward_iteratable<T, P
, boost::iterator<std::forward_iterator_tag, V, D, P, R
> > {};
template <class T,
class V,
class D = std::ptrdiff_t,
class P = V*,
class R = V&>
struct bidirectional_iterator_helper
: bidirectional_iteratable<T, P
, boost::iterator<std::bidirectional_iterator_tag, V, D, P, R
> > {};
template <class T,
class V,
class D = std::ptrdiff_t,
class P = V*,
class R = V&>
struct random_access_iterator_helper
: random_access_iteratable<T, P, D, R
, boost::iterator<std::random_access_iterator_tag, V, D, P, R
> >
{
friend D requires_difference_operator(const T& x, const T& y) ;
};
}
#define BOOST_NONCOPYABLE_HPP_INCLUDED
namespace boost {
namespace noncopyable_
{
class noncopyable
{
protected:
constexpr noncopyable() = default;
~noncopyable() = default;
noncopyable( const noncopyable& ) = delete;
noncopyable& operator=( const noncopyable& ) = delete;
};
}
typedef noncopyable_::noncopyable noncopyable;
}
#define BOOST_UTILITY_ENABLE_IF_HPP
namespace boost
{
template <bool B, class T = void>
struct enable_if_c {
typedef T type;
};
template <class T>
struct enable_if_c<false, T> {};
template <class Cond, class T = void>
struct enable_if : public enable_if_c<Cond::value, T> {};
template <bool B, class T>
struct lazy_enable_if_c {
typedef typename T::type type;
};
template <class T>
struct lazy_enable_if_c<false, T> {};
template <class Cond, class T>
struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
template <bool B, class T = void>
struct disable_if_c {
typedef T type;
};
template <class T>
struct disable_if_c<true, T> {};
template <class Cond, class T = void>
struct disable_if : public disable_if_c<Cond::value, T> {};
template <bool B, class T>
struct lazy_disable_if_c {
typedef typename T::type type;
};
template <class T>
struct lazy_disable_if_c<true, T> {};
template <class Cond, class T>
struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
}
#define BOOST_CERRNO_HPP
#undef __need_error_t
#define BOOST_CONFIG_ABI_PREFIX_HPP
#define BOOST_SYSTEM_NOEXCEPT BOOST_NOEXCEPT
namespace boost
{
namespace system
{
class error_code;
class error_condition;
template< class T >
struct is_error_code_enum { static const bool value = false; };
template< class T >
struct is_error_condition_enum { static const bool value = false; };
namespace errc
{
enum errc_t
{
success = 0,
address_family_not_supported = 97,
address_in_use = 98,
address_not_available = 99,
already_connected = 106,
argument_list_too_long = 7,
argument_out_of_domain = 33,
bad_address = 14,
bad_file_descriptor = 9,
bad_message = 74,
broken_pipe = 32,
connection_aborted = 103,
connection_already_in_progress = 114,
connection_refused = 111,
connection_reset = 104,
cross_device_link = 18,
destination_address_required = 89,
device_or_resource_busy = 16,
directory_not_empty = 39,
executable_format_error = 8,
file_exists = 17,
file_too_large = 27,
filename_too_long = 36,
function_not_supported = 38,
host_unreachable = 113,
identifier_removed = 43,
illegal_byte_sequence = 84,
inappropriate_io_control_operation = 25,
interrupted = 4,
invalid_argument = 22,
invalid_seek = 29,
io_error = 5,
is_a_directory = 21,
message_size = 90,
network_down = 100,
network_reset = 102,
network_unreachable = 101,
no_buffer_space = 105,
no_child_process = 10,
no_link = 67,
no_lock_available = 37,
no_message_available = 61,
no_message = 42,
no_protocol_option = 92,
no_space_on_device = 28,
no_stream_resources = 63,
no_such_device_or_address = 6,
no_such_device = 19,
no_such_file_or_directory = 2,
no_such_process = 3,
not_a_directory = 20,
not_a_socket = 88,
not_a_stream = 60,
not_connected = 107,
not_enough_memory = 12,
not_supported = 95,
operation_canceled = 125,
operation_in_progress = 115,
operation_not_permitted = 1,
operation_not_supported = 95,
operation_would_block = 11,
owner_dead = 130,
permission_denied = 13,
protocol_error = 71,
protocol_not_supported = 93,
read_only_file_system = 30,
resource_deadlock_would_occur = 35,
resource_unavailable_try_again = 11,
result_out_of_range = 34,
state_not_recoverable = 131,
stream_timeout = 62,
text_file_busy = 26,
timed_out = 110,
too_many_files_open_in_system = 23,
too_many_files_open = 24,
too_many_links = 31,
too_many_symbolic_link_levels = 40,
value_too_large = 75,
wrong_protocol_type = 91
};
}
namespace posix = errc;
namespace posix_error = errc;
template<> struct is_error_condition_enum<errc::errc_t>
{ static const bool value = true; };
class error_category : public noncopyable
{
public:
virtual ~error_category();
virtual const char * name() const noexcept = 0;
virtual std::string message( int ev ) const = 0;
inline virtual error_condition default_error_condition( int ev ) const noexcept;
inline virtual bool equivalent( int code,
const error_condition & condition ) const noexcept;
inline virtual bool equivalent( const error_code & code,
int condition ) const noexcept;
bool operator==(const error_category & rhs) const noexcept { return this == &rhs; }
bool operator!=(const error_category & rhs) const noexcept { return this != &rhs; }
bool operator<( const error_category & rhs ) const noexcept
{
return std::less<const error_category*>()( this, &rhs );
}
};
const error_category & system_category() noexcept;
const error_category & generic_category() noexcept;
const error_category & get_system_category() ;
const error_category & get_generic_category() ;
const error_category & get_posix_category() ;
static const error_category & posix_category = generic_category();
static const error_category & errno_ecat = generic_category();
static const error_category & native_ecat = system_category();
class error_condition
{
public:
error_condition() noexcept : m_val(0), m_cat(&generic_category()) {}
error_condition( int val, const error_category & cat ) noexcept : m_val(val), m_cat(&cat) {}
template <class ErrorConditionEnum>
error_condition(ErrorConditionEnum e,
typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum> >::type* = 0) noexcept
{
*this = make_error_condition(e);
}
void assign( int val, const error_category & cat ) noexcept
{
m_val = val;
m_cat = &cat;
}
template<typename ErrorConditionEnum>
typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum>, error_condition>::type &
operator=( ErrorConditionEnum val ) noexcept
{
*this = make_error_condition(val);
return *this;
}
void clear() noexcept
{
m_val = 0;
m_cat = &generic_category();
}
int value() const noexcept { return m_val; }
const error_category & category() const noexcept { return *m_cat; }
std::string message() const { return m_cat->message(value()); }
typedef void (*unspecified_bool_type)();
static void unspecified_bool_true() ;
operator unspecified_bool_type() const noexcept
{
return m_val == 0 ? 0 : unspecified_bool_true;
}
bool operator!() const noexcept
{
return m_val == 0;
}
inline friend bool operator==( const error_condition & lhs,
const error_condition & rhs ) noexcept
{
return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
}
inline friend bool operator<( const error_condition & lhs,
const error_condition & rhs ) noexcept
{
return lhs.m_cat < rhs.m_cat
|| (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
}
private:
int m_val;
const error_category * m_cat;
};
class error_code
{
public:
error_code() noexcept : m_val(0), m_cat(&system_category()) {}
error_code( int val, const error_category & cat ) noexcept : m_val(val), m_cat(&cat) {}
template <class ErrorCodeEnum>
error_code(ErrorCodeEnum e,
typename boost::enable_if<is_error_code_enum<ErrorCodeEnum> >::type* = 0) noexcept
{
*this = make_error_code(e);
}
void assign( int val, const error_category & cat ) noexcept
{
m_val = val;
m_cat = &cat;
}
template<typename ErrorCodeEnum>
typename boost::enable_if<is_error_code_enum<ErrorCodeEnum>, error_code>::type &
operator=( ErrorCodeEnum val ) noexcept
{
*this = make_error_code(val);
return *this;
}
void clear() noexcept
{
m_val = 0;
m_cat = &system_category();
}
int value() const noexcept { return m_val; }
const error_category & category() const noexcept { return *m_cat; }
error_condition default_error_condition() const noexcept { return m_cat->default_error_condition(value()); }
std::string message() const { return m_cat->message(value()); }
typedef void (*unspecified_bool_type)();
static void unspecified_bool_true() ;
operator unspecified_bool_type() const noexcept
{
return m_val == 0 ? 0 : unspecified_bool_true;
}
bool operator!() const noexcept
{
return m_val == 0;
}
inline friend bool operator==( const error_code & lhs,
const error_code & rhs ) noexcept
{
return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
}
inline friend bool operator<( const error_code & lhs,
const error_code & rhs ) noexcept
{
return lhs.m_cat < rhs.m_cat
|| (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
}
private:
int m_val;
const error_category * m_cat;
};
extern error_code throws;
}
namespace detail { system::error_code * throws() ; }
system::error_code & throws()
;
namespace system
{
inline bool operator!=( const error_code & lhs,
const error_code & rhs ) noexcept
{
return !(lhs == rhs);
}
inline bool operator!=( const error_condition & lhs,
const error_condition & rhs ) noexcept
{
return !(lhs == rhs);
}
inline bool operator==( const error_code & code,
const error_condition & condition ) noexcept
{
return code.category().equivalent( code.value(), condition )
|| condition.category().equivalent( code, condition.value() );
}
inline bool operator!=( const error_code & lhs,
const error_condition & rhs ) noexcept
{
return !(lhs == rhs);
}
inline bool operator==( const error_condition & condition,
const error_code & code ) noexcept
{
return condition.category().equivalent( code, condition.value() )
|| code.category().equivalent( code.value(), condition );
}
inline bool operator!=( const error_condition & lhs,
const error_code & rhs ) noexcept
{
return !(lhs == rhs);
}
template <class charT, class traits>
inline std::basic_ostream<charT,traits>&
operator<< (std::basic_ostream<charT,traits>& os, error_code ec)
{
os << ec.category().name() << ':' << ec.value();
return os;
}
inline std::size_t hash_value( const error_code & ec )
{
return static_cast<std::size_t>(ec.value())
+ reinterpret_cast<std::size_t>(&ec.category());
}
namespace errc
{
inline error_code make_error_code( errc_t e ) noexcept
{ return error_code( e, generic_category() ); }
inline error_condition make_error_condition( errc_t e ) noexcept
{ return error_condition( e, generic_category() ); }
}
error_condition error_category::default_error_condition( int ev ) const noexcept
{
return error_condition( ev, *this );
}
bool error_category::equivalent( int code,
const error_condition & condition ) const noexcept
{
return default_error_condition( code ) == condition;
}
bool error_category::equivalent( const error_code & code,
int condition ) const noexcept
{
return *this == code.category() && code.value() == condition;
}
}
}
#undef BOOST_CONFIG_ABI_PREFIX_HPP
namespace boost {
namespace asio {
namespace detail {
inline void do_throw_error(const boost::system::error_code& err);
inline void do_throw_error(const boost::system::error_code& err,
const char* location);
void throw_error(const boost::system::error_code& err)
;
void throw_error(const boost::system::error_code& err,
const char* location)
;
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_THROW_ERROR_IPP
#define BOOST_ASIO_DETAIL_THROW_EXCEPTION_HPP
#define UUID_AA15E74A856F11E08B8D93F24824019B
#define UUID_61531AB0680611DEADD5846855D89593
#define BOOST_ATTRIBUTE_NORETURN __attribute__((__noreturn__))
#define UUID_274DA366004E11DCB1DDFE2E56D89593
namespace
boost
{
namespace
exception_detail
{
template <class T>
class
refcount_ptr
{
public:
refcount_ptr()
;
~refcount_ptr()
;
refcount_ptr( refcount_ptr const & x )
;
refcount_ptr &
operator=( refcount_ptr const & x )
;
void
adopt( T * px )
;
T *
get() const
;
private:
T * px_;
void
add_ref()
;
void
release()
;
};
}
template <class Tag,class T>
class error_info;
typedef error_info<struct throw_function_,char const *> throw_function;
typedef error_info<struct throw_file_,char const *> throw_file;
typedef error_info<struct throw_line_,int> throw_line;
template <>
class
error_info<throw_function_,char const *>
{
public:
typedef char const * value_type;
value_type v_;
explicit
error_info( value_type v )
;
};
template <>
class
error_info<throw_file_,char const *>
{
public:
typedef char const * value_type;
value_type v_;
explicit
error_info( value_type v )
;
};
template <>
class
error_info<throw_line_,int>
{
public:
typedef int value_type;
value_type v_;
explicit
error_info( value_type v )
;
};
#pragma GCC visibility push (default)
class exception;
#pragma GCC visibility pop
template <class T>
class shared_ptr;
namespace
exception_detail
{
class error_info_base;
struct type_info_;
struct
error_info_container
{
virtual char const * diagnostic_information( char const * ) const = 0;
virtual shared_ptr<error_info_base> get( type_info_ const & ) const = 0;
virtual void set( shared_ptr<error_info_base> const &, type_info_ const & ) = 0;
virtual void add_ref() const = 0;
virtual bool release() const = 0;
virtual refcount_ptr<exception_detail::error_info_container> clone() const = 0;
protected:
~error_info_container() throw()
;
};
template <class>
struct get_info;
template <>
struct get_info<throw_function>;
template <>
struct get_info<throw_file>;
template <>
struct get_info<throw_line>;
char const * get_diagnostic_information( exception const &, char const * );
void copy_boost_exception( exception *, exception const * );
template <class E,class Tag,class T>
E const & set_info( E const &, error_info<Tag,T> const & );
template <class E>
E const & set_info( E const &, throw_function const & );
template <class E>
E const & set_info( E const &, throw_file const & );
template <class E>
E const & set_info( E const &, throw_line const & );
}
#pragma GCC visibility push (default)
class
exception
{
protected:
exception()
;
virtual ~exception() throw()
= 0
;
private:
template <class E>
friend E const & exception_detail::set_info( E const &, throw_function const & );
template <class E>
friend E const & exception_detail::set_info( E const &, throw_file const & );
template <class E>
friend E const & exception_detail::set_info( E const &, throw_line const & );
template <class E,class Tag,class T>
friend E const & exception_detail::set_info( E const &, error_info<Tag,T> const & );
friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );
template <class>
friend struct exception_detail::get_info;
friend struct exception_detail::get_info<throw_function>;
friend struct exception_detail::get_info<throw_file>;
friend struct exception_detail::get_info<throw_line>;
friend void exception_detail::copy_boost_exception( exception *, exception const * );
mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
mutable char const * throw_function_;
mutable char const * throw_file_;
mutable int throw_line_;
};
#pragma GCC visibility pop
namespace
exception_detail
{
template <class E>
E const &
set_info( E const & x, throw_function const & y )
;
template <class E>
E const &
set_info( E const & x, throw_file const & y )
;
template <class E>
E const &
set_info( E const & x, throw_line const & y )
;
}
namespace
exception_detail
{
#pragma GCC visibility push (default)
template <class T>
struct
error_info_injector:
public T,
public exception
{
explicit
error_info_injector( T const & x )
;
~error_info_injector() throw()
;
};
#pragma GCC visibility pop
struct large_size { char c[256]; };
large_size dispatch_boost_exception( exception const * );
struct small_size { };
small_size dispatch_boost_exception( void const * );
template <class,int>
struct enable_error_info_helper;
template <class T>
struct
enable_error_info_helper<T,sizeof(large_size)>
{
typedef T type;
};
template <class T>
struct
enable_error_info_helper<T,sizeof(small_size)>
{
typedef error_info_injector<T> type;
};
template <class T>
struct
enable_error_info_return_type
{
typedef typename enable_error_info_helper<T,sizeof(exception_detail::dispatch_boost_exception(static_cast<T *>(0)))>::type type;
};
}
template <class T>
typename
exception_detail::enable_error_info_return_type<T>::type
enable_error_info( T const & x )
;
namespace
exception_detail
{
#pragma GCC visibility push (default)
class
clone_base
{
public:
virtual clone_base const * clone() const = 0;
virtual void rethrow() const = 0;
virtual
~clone_base() throw()
;
};
#pragma GCC visibility pop
void
copy_boost_exception( exception * a, exception const * b )
;
void
copy_boost_exception( void *, void const * )
;
template <class T>
class
clone_impl:
public T,
public virtual clone_base
{
struct clone_tag { };
clone_impl( clone_impl const & x, clone_tag )
;
public:
explicit
clone_impl( T const & x )
;
~clone_impl() throw()
;
private:
clone_base const *
clone() const
;
void
rethrow() const
;
};
}
template <class T>
exception_detail::clone_impl<T>
enable_current_exception( T const & x )
;
}
#define BOOST_CURRENT_FUNCTION_HPP_INCLUDED
namespace boost
{
namespace detail
{
void current_function_helper()
;
}
}
#define BOOST_THROW_EXCEPTION_CURRENT_FUNCTION BOOST_CURRENT_FUNCTION
#define BOOST_THROW_EXCEPTION(x) ::boost::exception_detail::throw_exception_(x,BOOST_THROW_EXCEPTION_CURRENT_FUNCTION,__FILE__,__LINE__)
namespace boost
{
void throw_exception_assert_compatibility( std::exception const & ) ;
template<class E> __attribute__((__noreturn__)) void throw_exception( E const & e )
;
namespace
exception_detail
{
template <class E>
__attribute__((__noreturn__))
void
throw_exception_( E const & x, char const * current_function, char const * file, int line )
;
}
}
namespace boost {
namespace asio {
namespace detail {
using boost::throw_exception;
}
}
}
#define BOOST_SYSTEM_ERROR_HPP
#undef _ASSERT_H
#undef assert
#undef __ASSERT_VOID_CAST
#undef assert_perror
#define _ASSERT_H 1
#define __ASSERT_VOID_CAST static_cast<void>
#define assert(expr) (__ASSERT_VOID_CAST (0))
#define assert_perror(errnum) (__ASSERT_VOID_CAST (0))
namespace boost
{
namespace system
{
class __attribute__((__visibility__("default"))) system_error : public std::runtime_error
{
public:
system_error( error_code ec ) ;
system_error( error_code ec, const std::string & what_arg ) ;
system_error( error_code ec, const char* what_arg ) ;
system_error( int ev, const error_category & ecat )
: std::runtime_error(""), m_error_code(ev,ecat) {}
system_error( int ev, const error_category & ecat,
const std::string & what_arg )
: std::runtime_error(what_arg), m_error_code(ev,ecat) {}
system_error( int ev, const error_category & ecat,
const char * what_arg )
: std::runtime_error(what_arg), m_error_code(ev,ecat) {}
virtual ~system_error() throw() ;
const error_code & code() const throw() ;
const char * what() const throw();
private:
error_code m_error_code;
mutable std::string m_what;
};
}
}
namespace boost {
namespace asio {
namespace detail {
void do_throw_error(const boost::system::error_code& err)
;
void do_throw_error(const boost::system::error_code& err, const char* location)
;
}
}
}
#define BOOST_ASIO_ERROR_HPP
#undef __need_error_t
#define _NETDB_H 1
#define _NETINET_IN_H 1
#define _SYS_SOCKET_H 1
extern "C" {
#define _SYS_UIO_H 1
extern "C" {
#define _BITS_UIO_H 1
#define UIO_MAXIOV 1024
struct iovec
{
void *iov_base;
size_t iov_len;
};
#define _BITS_UIO_H_FOR_SYS_UIO_H 1
extern "C" {
extern ssize_t process_vm_readv (pid_t __pid, const struct iovec *__lvec,
unsigned long int __liovcnt,
const struct iovec *__rvec,
unsigned long int __riovcnt,
unsigned long int __flags)
throw ();
extern ssize_t process_vm_writev (pid_t __pid, const struct iovec *__lvec,
unsigned long int __liovcnt,
const struct iovec *__rvec,
unsigned long int __riovcnt,
unsigned long int __flags)
throw ();
}
extern ssize_t readv (int __fd, const struct iovec *__iovec, int __count)
;
extern ssize_t writev (int __fd, const struct iovec *__iovec, int __count)
;
extern ssize_t preadv (int __fd, const struct iovec *__iovec, int __count,
__off_t __offset) ;
extern ssize_t pwritev (int __fd, const struct iovec *__iovec, int __count,
__off_t __offset) ;
extern ssize_t preadv64 (int __fd, const struct iovec *__iovec, int __count,
__off64_t __offset) ;
extern ssize_t pwritev64 (int __fd, const struct iovec *__iovec, int __count,
__off64_t __offset) ;
}
#define __need_size_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define __BITS_SOCKET_H
#define __need_size_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
enum __socket_type
{
SOCK_STREAM = 1,
#define SOCK_STREAM SOCK_STREAM
SOCK_DGRAM = 2,
#define SOCK_DGRAM SOCK_DGRAM
SOCK_RAW = 3,
#define SOCK_RAW SOCK_RAW
SOCK_RDM = 4,
#define SOCK_RDM SOCK_RDM
SOCK_SEQPACKET = 5,
#define SOCK_SEQPACKET SOCK_SEQPACKET
SOCK_DCCP = 6,
#define SOCK_DCCP SOCK_DCCP
SOCK_PACKET = 10,
#define SOCK_PACKET SOCK_PACKET
SOCK_CLOEXEC = 02000000,
#define SOCK_CLOEXEC SOCK_CLOEXEC
SOCK_NONBLOCK = 00004000
#define SOCK_NONBLOCK SOCK_NONBLOCK
};
#define PF_UNSPEC 0
#define PF_LOCAL 1
#define PF_UNIX PF_LOCAL
#define PF_FILE PF_LOCAL
#define PF_INET 2
#define PF_AX25 3
#define PF_IPX 4
#define PF_APPLETALK 5
#define PF_NETROM 6
#define PF_BRIDGE 7
#define PF_ATMPVC 8
#define PF_X25 9
#define PF_INET6 10
#define PF_ROSE 11
#define PF_DECnet 12
#define PF_NETBEUI 13
#define PF_SECURITY 14
#define PF_KEY 15
#define PF_NETLINK 16
#define PF_ROUTE PF_NETLINK
#define PF_PACKET 17
#define PF_ASH 18
#define PF_ECONET 19
#define PF_ATMSVC 20
#define PF_RDS 21
#define PF_SNA 22
#define PF_IRDA 23
#define PF_PPPOX 24
#define PF_WANPIPE 25
#define PF_LLC 26
#define PF_CAN 29
#define PF_TIPC 30
#define PF_BLUETOOTH 31
#define PF_IUCV 32
#define PF_RXRPC 33
#define PF_ISDN 34
#define PF_PHONET 35
#define PF_IEEE802154 36
#define PF_CAIF 37
#define PF_ALG 38
#define PF_NFC 39
#define PF_VSOCK 40
#define PF_MAX 41
#define AF_UNSPEC PF_UNSPEC
#define AF_LOCAL PF_LOCAL
#define AF_UNIX PF_UNIX
#define AF_FILE PF_FILE
#define AF_INET PF_INET
#define AF_AX25 PF_AX25
#define AF_IPX PF_IPX
#define AF_APPLETALK PF_APPLETALK
#define AF_NETROM PF_NETROM
#define AF_BRIDGE PF_BRIDGE
#define AF_ATMPVC PF_ATMPVC
#define AF_X25 PF_X25
#define AF_INET6 PF_INET6
#define AF_ROSE PF_ROSE
#define AF_DECnet PF_DECnet
#define AF_NETBEUI PF_NETBEUI
#define AF_SECURITY PF_SECURITY
#define AF_KEY PF_KEY
#define AF_NETLINK PF_NETLINK
#define AF_ROUTE PF_ROUTE
#define AF_PACKET PF_PACKET
#define AF_ASH PF_ASH
#define AF_ECONET PF_ECONET
#define AF_ATMSVC PF_ATMSVC
#define AF_RDS PF_RDS
#define AF_SNA PF_SNA
#define AF_IRDA PF_IRDA
#define AF_PPPOX PF_PPPOX
#define AF_WANPIPE PF_WANPIPE
#define AF_LLC PF_LLC
#define AF_CAN PF_CAN
#define AF_TIPC PF_TIPC
#define AF_BLUETOOTH PF_BLUETOOTH
#define AF_IUCV PF_IUCV
#define AF_RXRPC PF_RXRPC
#define AF_ISDN PF_ISDN
#define AF_PHONET PF_PHONET
#define AF_IEEE802154 PF_IEEE802154
#define AF_CAIF PF_CAIF
#define AF_ALG PF_ALG
#define AF_NFC PF_NFC
#define AF_VSOCK PF_VSOCK
#define AF_MAX PF_MAX
#define SOL_RAW 255
#define SOL_DECNET 261
#define SOL_X25 262
#define SOL_PACKET 263
#define SOL_ATM 264
#define SOL_AAL 265
#define SOL_IRDA 266
#define SOMAXCONN 128
#define _BITS_SOCKADDR_H 1
typedef unsigned short int sa_family_t;
#define __SOCKADDR_COMMON(sa_prefix) sa_family_t sa_prefix ##family
#define __SOCKADDR_COMMON_SIZE (sizeof (unsigned short int))
struct sockaddr
{
sa_family_t sa_family;
char sa_data[14];
};
#define __ss_aligntype unsigned long int
#define _SS_SIZE 128
#define _SS_PADSIZE (_SS_SIZE - (2 * sizeof (__ss_aligntype)))
struct sockaddr_storage
{
sa_family_t ss_family;
unsigned long int __ss_align;
char __ss_padding[(128 - (2 * sizeof (unsigned long int)))];
};
enum
{
MSG_OOB = 0x01,
#define MSG_OOB MSG_OOB
MSG_PEEK = 0x02,
#define MSG_PEEK MSG_PEEK
MSG_DONTROUTE = 0x04,
#define MSG_DONTROUTE MSG_DONTROUTE
MSG_TRYHARD = MSG_DONTROUTE,
#define MSG_TRYHARD MSG_DONTROUTE
MSG_CTRUNC = 0x08,
#define MSG_CTRUNC MSG_CTRUNC
MSG_PROXY = 0x10,
#define MSG_PROXY MSG_PROXY
MSG_TRUNC = 0x20,
#define MSG_TRUNC MSG_TRUNC
MSG_DONTWAIT = 0x40,
#define MSG_DONTWAIT MSG_DONTWAIT
MSG_EOR = 0x80,
#define MSG_EOR MSG_EOR
MSG_WAITALL = 0x100,
#define MSG_WAITALL MSG_WAITALL
MSG_FIN = 0x200,
#define MSG_FIN MSG_FIN
MSG_SYN = 0x400,
#define MSG_SYN MSG_SYN
MSG_CONFIRM = 0x800,
#define MSG_CONFIRM MSG_CONFIRM
MSG_RST = 0x1000,
#define MSG_RST MSG_RST
MSG_ERRQUEUE = 0x2000,
#define MSG_ERRQUEUE MSG_ERRQUEUE
MSG_NOSIGNAL = 0x4000,
#define MSG_NOSIGNAL MSG_NOSIGNAL
MSG_MORE = 0x8000,
#define MSG_MORE MSG_MORE
MSG_WAITFORONE = 0x10000,
#define MSG_WAITFORONE MSG_WAITFORONE
MSG_FASTOPEN = 0x20000000,
#define MSG_FASTOPEN MSG_FASTOPEN
MSG_CMSG_CLOEXEC = 0x40000000
#define MSG_CMSG_CLOEXEC MSG_CMSG_CLOEXEC
};
struct msghdr
{
void *msg_name;
socklen_t msg_namelen;
struct iovec *msg_iov;
size_t msg_iovlen;
void *msg_control;
size_t msg_controllen;
int msg_flags;
};
struct cmsghdr
{
size_t cmsg_len;
int cmsg_level;
int cmsg_type;
};
#define CMSG_DATA(cmsg) ((unsigned char *) ((struct cmsghdr *) (cmsg) + 1))
#define CMSG_NXTHDR(mhdr,cmsg) __cmsg_nxthdr (mhdr, cmsg)
#define CMSG_FIRSTHDR(mhdr) ((size_t) (mhdr)->msg_controllen >= sizeof (struct cmsghdr) ? (struct cmsghdr *) (mhdr)->msg_control : (struct cmsghdr *) 0)
#define CMSG_ALIGN(len) (((len) + sizeof (size_t) - 1) & (size_t) ~(sizeof (size_t) - 1))
#define CMSG_SPACE(len) (CMSG_ALIGN (len) + CMSG_ALIGN (sizeof (struct cmsghdr)))
#define CMSG_LEN(len) (CMSG_ALIGN (sizeof (struct cmsghdr)) + (len))
extern struct cmsghdr *__cmsg_nxthdr (struct msghdr *__mhdr,
struct cmsghdr *__cmsg) throw ();
enum
{
SCM_RIGHTS = 0x01
#define SCM_RIGHTS SCM_RIGHTS
, SCM_CREDENTIALS = 0x02
#define SCM_CREDENTIALS SCM_CREDENTIALS
};
struct ucred
{
pid_t pid;
uid_t uid;
gid_t gid;
};
#define __ASM_GENERIC_SOCKET_H
#define __ASM_GENERIC_SOCKIOS_H
#define FIOSETOWN 0x8901
#define SIOCSPGRP 0x8902
#define FIOGETOWN 0x8903
#define SIOCGPGRP 0x8904
#define SIOCATMARK 0x8905
#define SIOCGSTAMP 0x8906
#define SIOCGSTAMPNS 0x8907
#define SOL_SOCKET 1
#define SO_DEBUG 1
#define SO_REUSEADDR 2
#define SO_TYPE 3
#define SO_ERROR 4
#define SO_DONTROUTE 5
#define SO_BROADCAST 6
#define SO_SNDBUF 7
#define SO_RCVBUF 8
#define SO_SNDBUFFORCE 32
#define SO_RCVBUFFORCE 33
#define SO_KEEPALIVE 9
#define SO_OOBINLINE 10
#define SO_NO_CHECK 11
#define SO_PRIORITY 12
#define SO_LINGER 13
#define SO_BSDCOMPAT 14
#define SO_REUSEPORT 15
#define SO_PASSCRED 16
#define SO_PEERCRED 17
#define SO_RCVLOWAT 18
#define SO_SNDLOWAT 19
#define SO_RCVTIMEO 20
#define SO_SNDTIMEO 21
#define SO_SECURITY_AUTHENTICATION 22
#define SO_SECURITY_ENCRYPTION_TRANSPORT 23
#define SO_SECURITY_ENCRYPTION_NETWORK 24
#define SO_BINDTODEVICE 25
#define SO_ATTACH_FILTER 26
#define SO_DETACH_FILTER 27
#define SO_GET_FILTER SO_ATTACH_FILTER
#define SO_PEERNAME 28
#define SO_TIMESTAMP 29
#define SCM_TIMESTAMP SO_TIMESTAMP
#define SO_ACCEPTCONN 30
#define SO_PEERSEC 31
#define SO_PASSSEC 34
#define SO_TIMESTAMPNS 35
#define SCM_TIMESTAMPNS SO_TIMESTAMPNS
#define SO_MARK 36
#define SO_TIMESTAMPING 37
#define SCM_TIMESTAMPING SO_TIMESTAMPING
#define SO_PROTOCOL 38
#define SO_DOMAIN 39
#define SO_RXQ_OVFL 40
#define SO_WIFI_STATUS 41
#define SCM_WIFI_STATUS SO_WIFI_STATUS
#define SO_PEEK_OFF 42
#define SO_NOFCS 43
#define SO_LOCK_FILTER 44
#define SO_SELECT_ERR_QUEUE 45
#define SO_BUSY_POLL 46
#define SO_MAX_PACING_RATE 47
#define SO_BPF_EXTENSIONS 48
struct linger
{
int l_onoff;
int l_linger;
};
struct osockaddr
{
unsigned short int sa_family;
unsigned char sa_data[14];
};
enum
{
SHUT_RD = 0,
#define SHUT_RD SHUT_RD
SHUT_WR,
#define SHUT_WR SHUT_WR
SHUT_RDWR
#define SHUT_RDWR SHUT_RDWR
};
#define __SOCKADDR_ARG struct sockaddr *__restrict
#define __CONST_SOCKADDR_ARG const struct sockaddr *
struct mmsghdr
{
struct msghdr msg_hdr;
unsigned int msg_len;
};
extern int socket (int __domain, int __type, int __protocol) throw ();
extern int socketpair (int __domain, int __type, int __protocol,
int __fds[2]) throw ();
extern int bind (int __fd, const struct sockaddr * __addr, socklen_t __len)
throw ();
extern int getsockname (int __fd, struct sockaddr *__restrict __addr,
socklen_t *__restrict __len) throw ();
extern int connect (int __fd, const struct sockaddr * __addr, socklen_t __len);
extern int getpeername (int __fd, struct sockaddr *__restrict __addr,
socklen_t *__restrict __len) throw ();
extern ssize_t send (int __fd, const void *__buf, size_t __n, int __flags);
extern ssize_t recv (int __fd, void *__buf, size_t __n, int __flags);
extern ssize_t sendto (int __fd, const void *__buf, size_t __n,
int __flags, const struct sockaddr * __addr,
socklen_t __addr_len);
extern ssize_t recvfrom (int __fd, void *__restrict __buf, size_t __n,
int __flags, struct sockaddr *__restrict __addr,
socklen_t *__restrict __addr_len);
extern ssize_t sendmsg (int __fd, const struct msghdr *__message,
int __flags);
extern int sendmmsg (int __fd, struct mmsghdr *__vmessages,
unsigned int __vlen, int __flags);
extern ssize_t recvmsg (int __fd, struct msghdr *__message, int __flags);
extern int recvmmsg (int __fd, struct mmsghdr *__vmessages,
unsigned int __vlen, int __flags,
const struct timespec *__tmo);
extern int getsockopt (int __fd, int __level, int __optname,
void *__restrict __optval,
socklen_t *__restrict __optlen) throw ();
extern int setsockopt (int __fd, int __level, int __optname,
const void *__optval, socklen_t __optlen) throw ();
extern int listen (int __fd, int __n) throw ();
extern int accept (int __fd, struct sockaddr *__restrict __addr,
socklen_t *__restrict __addr_len);
extern int accept4 (int __fd, struct sockaddr *__restrict __addr,
socklen_t *__restrict __addr_len, int __flags);
extern int shutdown (int __fd, int __how) throw ();
extern int sockatmark (int __fd) throw ();
extern int isfdtype (int __fd, int __fdtype) throw ();
}
extern "C" {
typedef uint32_t in_addr_t;
struct in_addr
{
in_addr_t s_addr;
};
#define IP_OPTIONS 4
#define IP_HDRINCL 3
#define IP_TOS 1
#define IP_TTL 2
#define IP_RECVOPTS 6
#define IP_RECVRETOPTS IP_RETOPTS
#define IP_RETOPTS 7
#define IP_MULTICAST_IF 32
#define IP_MULTICAST_TTL 33
#define IP_MULTICAST_LOOP 34
#define IP_ADD_MEMBERSHIP 35
#define IP_DROP_MEMBERSHIP 36
#define IP_UNBLOCK_SOURCE 37
#define IP_BLOCK_SOURCE 38
#define IP_ADD_SOURCE_MEMBERSHIP 39
#define IP_DROP_SOURCE_MEMBERSHIP 40
#define IP_MSFILTER 41
#define MCAST_JOIN_GROUP 42
#define MCAST_BLOCK_SOURCE 43
#define MCAST_UNBLOCK_SOURCE 44
#define MCAST_LEAVE_GROUP 45
#define MCAST_JOIN_SOURCE_GROUP 46
#define MCAST_LEAVE_SOURCE_GROUP 47
#define MCAST_MSFILTER 48
#define IP_MULTICAST_ALL 49
#define IP_UNICAST_IF 50
#define MCAST_EXCLUDE 0
#define MCAST_INCLUDE 1
#define IP_ROUTER_ALERT 5
#define IP_PKTINFO 8
#define IP_PKTOPTIONS 9
#define IP_PMTUDISC 10
#define IP_MTU_DISCOVER 10
#define IP_RECVERR 11
#define IP_RECVTTL 12
#define IP_RECVTOS 13
#define IP_MTU 14
#define IP_FREEBIND 15
#define IP_IPSEC_POLICY 16
#define IP_XFRM_POLICY 17
#define IP_PASSSEC 18
#define IP_TRANSPARENT 19
#define IP_MULTICAST_ALL 49
#define IP_ORIGDSTADDR 20
#define IP_RECVORIGDSTADDR IP_ORIGDSTADDR
#define IP_MINTTL 21
#define IP_PMTUDISC_DONT 0
#define IP_PMTUDISC_WANT 1
#define IP_PMTUDISC_DO 2
#define IP_PMTUDISC_PROBE 3
#define SOL_IP 0
#define IP_DEFAULT_MULTICAST_TTL 1
#define IP_DEFAULT_MULTICAST_LOOP 1
#define IP_MAX_MEMBERSHIPS 20
struct ip_opts
{
struct in_addr ip_dst;
char ip_opts[40];
};
struct ip_mreqn
{
struct in_addr imr_multiaddr;
struct in_addr imr_address;
int imr_ifindex;
};
struct in_pktinfo
{
int ipi_ifindex;
struct in_addr ipi_spec_dst;
struct in_addr ipi_addr;
};
#define IPV6_ADDRFORM 1
#define IPV6_2292PKTINFO 2
#define IPV6_2292HOPOPTS 3
#define IPV6_2292DSTOPTS 4
#define IPV6_2292RTHDR 5
#define IPV6_2292PKTOPTIONS 6
#define IPV6_CHECKSUM 7
#define IPV6_2292HOPLIMIT 8
#define SCM_SRCRT IPV6_RXSRCRT
#define IPV6_NEXTHOP 9
#define IPV6_AUTHHDR 10
#define IPV6_UNICAST_HOPS 16
#define IPV6_MULTICAST_IF 17
#define IPV6_MULTICAST_HOPS 18
#define IPV6_MULTICAST_LOOP 19
#define IPV6_JOIN_GROUP 20
#define IPV6_LEAVE_GROUP 21
#define IPV6_ROUTER_ALERT 22
#define IPV6_MTU_DISCOVER 23
#define IPV6_MTU 24
#define IPV6_RECVERR 25
#define IPV6_V6ONLY 26
#define IPV6_JOIN_ANYCAST 27
#define IPV6_LEAVE_ANYCAST 28
#define IPV6_IPSEC_POLICY 34
#define IPV6_XFRM_POLICY 35
#define IPV6_RECVPKTINFO 49
#define IPV6_PKTINFO 50
#define IPV6_RECVHOPLIMIT 51
#define IPV6_HOPLIMIT 52
#define IPV6_RECVHOPOPTS 53
#define IPV6_HOPOPTS 54
#define IPV6_RTHDRDSTOPTS 55
#define IPV6_RECVRTHDR 56
#define IPV6_RTHDR 57
#define IPV6_RECVDSTOPTS 58
#define IPV6_DSTOPTS 59
#define IPV6_RECVTCLASS 66
#define IPV6_TCLASS 67
#define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
#define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP
#define IPV6_RXHOPOPTS IPV6_HOPOPTS
#define IPV6_RXDSTOPTS IPV6_DSTOPTS
#define IPV6_PMTUDISC_DONT 0
#define IPV6_PMTUDISC_WANT 1
#define IPV6_PMTUDISC_DO 2
#define IPV6_PMTUDISC_PROBE 3
#define SOL_IPV6 41
#define SOL_ICMPV6 58
#define IPV6_RTHDR_LOOSE 0
#define IPV6_RTHDR_STRICT 1
#define IPV6_RTHDR_TYPE_0 0
enum
{
IPPROTO_IP = 0,
#define IPPROTO_IP IPPROTO_IP
IPPROTO_ICMP = 1,
#define IPPROTO_ICMP IPPROTO_ICMP
IPPROTO_IGMP = 2,
#define IPPROTO_IGMP IPPROTO_IGMP
IPPROTO_IPIP = 4,
#define IPPROTO_IPIP IPPROTO_IPIP
IPPROTO_TCP = 6,
#define IPPROTO_TCP IPPROTO_TCP
IPPROTO_EGP = 8,
#define IPPROTO_EGP IPPROTO_EGP
IPPROTO_PUP = 12,
#define IPPROTO_PUP IPPROTO_PUP
IPPROTO_UDP = 17,
#define IPPROTO_UDP IPPROTO_UDP
IPPROTO_IDP = 22,
#define IPPROTO_IDP IPPROTO_IDP
IPPROTO_TP = 29,
#define IPPROTO_TP IPPROTO_TP
IPPROTO_DCCP = 33,
#define IPPROTO_DCCP IPPROTO_DCCP
IPPROTO_IPV6 = 41,
#define IPPROTO_IPV6 IPPROTO_IPV6
IPPROTO_RSVP = 46,
#define IPPROTO_RSVP IPPROTO_RSVP
IPPROTO_GRE = 47,
#define IPPROTO_GRE IPPROTO_GRE
IPPROTO_ESP = 50,
#define IPPROTO_ESP IPPROTO_ESP
IPPROTO_AH = 51,
#define IPPROTO_AH IPPROTO_AH
IPPROTO_MTP = 92,
#define IPPROTO_MTP IPPROTO_MTP
IPPROTO_BEETPH = 94,
#define IPPROTO_BEETPH IPPROTO_BEETPH
IPPROTO_ENCAP = 98,
#define IPPROTO_ENCAP IPPROTO_ENCAP
IPPROTO_PIM = 103,
#define IPPROTO_PIM IPPROTO_PIM
IPPROTO_COMP = 108,
#define IPPROTO_COMP IPPROTO_COMP
IPPROTO_SCTP = 132,
#define IPPROTO_SCTP IPPROTO_SCTP
IPPROTO_UDPLITE = 136,
#define IPPROTO_UDPLITE IPPROTO_UDPLITE
IPPROTO_RAW = 255,
#define IPPROTO_RAW IPPROTO_RAW
IPPROTO_MAX
};
enum
{
IPPROTO_HOPOPTS = 0,
#define IPPROTO_HOPOPTS IPPROTO_HOPOPTS
IPPROTO_ROUTING = 43,
#define IPPROTO_ROUTING IPPROTO_ROUTING
IPPROTO_FRAGMENT = 44,
#define IPPROTO_FRAGMENT IPPROTO_FRAGMENT
IPPROTO_ICMPV6 = 58,
#define IPPROTO_ICMPV6 IPPROTO_ICMPV6
IPPROTO_NONE = 59,
#define IPPROTO_NONE IPPROTO_NONE
IPPROTO_DSTOPTS = 60,
#define IPPROTO_DSTOPTS IPPROTO_DSTOPTS
IPPROTO_MH = 135
#define IPPROTO_MH IPPROTO_MH
};
typedef uint16_t in_port_t;
enum
{
IPPORT_ECHO = 7,
IPPORT_DISCARD = 9,
IPPORT_SYSTAT = 11,
IPPORT_DAYTIME = 13,
IPPORT_NETSTAT = 15,
IPPORT_FTP = 21,
IPPORT_TELNET = 23,
IPPORT_SMTP = 25,
IPPORT_TIMESERVER = 37,
IPPORT_NAMESERVER = 42,
IPPORT_WHOIS = 43,
IPPORT_MTP = 57,
IPPORT_TFTP = 69,
IPPORT_RJE = 77,
IPPORT_FINGER = 79,
IPPORT_TTYLINK = 87,
IPPORT_SUPDUP = 95,
IPPORT_EXECSERVER = 512,
IPPORT_LOGINSERVER = 513,
IPPORT_CMDSERVER = 514,
IPPORT_EFSSERVER = 520,
IPPORT_BIFFUDP = 512,
IPPORT_WHOSERVER = 513,
IPPORT_ROUTESERVER = 520,
IPPORT_RESERVED = 1024,
IPPORT_USERRESERVED = 5000
};
#define IN_CLASSA(a) ((((in_addr_t)(a)) & 0x80000000) == 0)
#define IN_CLASSA_NET 0xff000000
#define IN_CLASSA_NSHIFT 24
#define IN_CLASSA_HOST (0xffffffff & ~IN_CLASSA_NET)
#define IN_CLASSA_MAX 128
#define IN_CLASSB(a) ((((in_addr_t)(a)) & 0xc0000000) == 0x80000000)
#define IN_CLASSB_NET 0xffff0000
#define IN_CLASSB_NSHIFT 16
#define IN_CLASSB_HOST (0xffffffff & ~IN_CLASSB_NET)
#define IN_CLASSB_MAX 65536
#define IN_CLASSC(a) ((((in_addr_t)(a)) & 0xe0000000) == 0xc0000000)
#define IN_CLASSC_NET 0xffffff00
#define IN_CLASSC_NSHIFT 8
#define IN_CLASSC_HOST (0xffffffff & ~IN_CLASSC_NET)
#define IN_CLASSD(a) ((((in_addr_t)(a)) & 0xf0000000) == 0xe0000000)
#define IN_MULTICAST(a) IN_CLASSD(a)
#define IN_EXPERIMENTAL(a) ((((in_addr_t)(a)) & 0xe0000000) == 0xe0000000)
#define IN_BADCLASS(a) ((((in_addr_t)(a)) & 0xf0000000) == 0xf0000000)
#define INADDR_ANY ((in_addr_t) 0x00000000)
#define INADDR_BROADCAST ((in_addr_t) 0xffffffff)
#define INADDR_NONE ((in_addr_t) 0xffffffff)
#define IN_LOOPBACKNET 127
#define INADDR_LOOPBACK ((in_addr_t) 0x7f000001)
#define INADDR_UNSPEC_GROUP ((in_addr_t) 0xe0000000)
#define INADDR_ALLHOSTS_GROUP ((in_addr_t) 0xe0000001)
#define INADDR_ALLRTRS_GROUP ((in_addr_t) 0xe0000002)
#define INADDR_MAX_LOCAL_GROUP ((in_addr_t) 0xe00000ff)
struct in6_addr
{
union
{
uint8_t __u6_addr8[16];
uint16_t __u6_addr16[8];
uint32_t __u6_addr32[4];
} __in6_u;
#define s6_addr __in6_u.__u6_addr8
#define s6_addr16 __in6_u.__u6_addr16
#define s6_addr32 __in6_u.__u6_addr32
};
extern const struct in6_addr in6addr_any;
extern const struct in6_addr in6addr_loopback;
#define IN6ADDR_ANY_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } } }
#define IN6ADDR_LOOPBACK_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 } } }
#define INET_ADDRSTRLEN 16
#define INET6_ADDRSTRLEN 46
struct sockaddr_in
{
sa_family_t sin_family;
in_port_t sin_port;
struct in_addr sin_addr;
unsigned char sin_zero[sizeof (struct sockaddr) -
(sizeof (unsigned short int)) -
sizeof (in_port_t) -
sizeof (struct in_addr)];
};
struct sockaddr_in6
{
sa_family_t sin6_family;
in_port_t sin6_port;
uint32_t sin6_flowinfo;
struct in6_addr sin6_addr;
uint32_t sin6_scope_id;
};
struct ip_mreq
{
struct in_addr imr_multiaddr;
struct in_addr imr_interface;
};
struct ip_mreq_source
{
struct in_addr imr_multiaddr;
struct in_addr imr_interface;
struct in_addr imr_sourceaddr;
};
struct ipv6_mreq
{
struct in6_addr ipv6mr_multiaddr;
unsigned int ipv6mr_interface;
};
struct group_req
{
uint32_t gr_interface;
struct sockaddr_storage gr_group;
};
struct group_source_req
{
uint32_t gsr_interface;
struct sockaddr_storage gsr_group;
struct sockaddr_storage gsr_source;
};
struct ip_msfilter
{
struct in_addr imsf_multiaddr;
struct in_addr imsf_interface;
uint32_t imsf_fmode;
uint32_t imsf_numsrc;
struct in_addr imsf_slist[1];
};
#define IP_MSFILTER_SIZE(numsrc) (sizeof (struct ip_msfilter) - sizeof (struct in_addr) + (numsrc) * sizeof (struct in_addr))
struct group_filter
{
uint32_t gf_interface;
struct sockaddr_storage gf_group;
uint32_t gf_fmode;
uint32_t gf_numsrc;
struct sockaddr_storage gf_slist[1];
};
#define GROUP_FILTER_SIZE(numsrc) (sizeof (struct group_filter) - sizeof (struct sockaddr_storage) + ((numsrc) * sizeof (struct sockaddr_storage)))
extern uint32_t ntohl (uint32_t __netlong) throw () __attribute__ ((__const__));
extern uint16_t ntohs (uint16_t __netshort)
throw () __attribute__ ((__const__));
extern uint32_t htonl (uint32_t __hostlong)
throw () __attribute__ ((__const__));
extern uint16_t htons (uint16_t __hostshort)
throw () __attribute__ ((__const__));
#define IN6_IS_ADDR_UNSPECIFIED(a) (__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); __a->s6_addr32[0] == 0 && __a->s6_addr32[1] == 0 && __a->s6_addr32[2] == 0 && __a->s6_addr32[3] == 0; }))
#define IN6_IS_ADDR_LOOPBACK(a) (__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); __a->s6_addr32[0] == 0 && __a->s6_addr32[1] == 0 && __a->s6_addr32[2] == 0 && __a->s6_addr32[3] == htonl (1); }))
#define IN6_IS_ADDR_LINKLOCAL(a) (__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); (__a->s6_addr32[0] & htonl (0xffc00000)) == htonl (0xfe800000); }))
#define IN6_IS_ADDR_SITELOCAL(a) (__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); (__a->s6_addr32[0] & htonl (0xffc00000)) == htonl (0xfec00000); }))
#define IN6_IS_ADDR_V4MAPPED(a) (__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); __a->s6_addr32[0] == 0 && __a->s6_addr32[1] == 0 && __a->s6_addr32[2] == htonl (0xffff); }))
#define IN6_IS_ADDR_V4COMPAT(a) (__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); __a->s6_addr32[0] == 0 && __a->s6_addr32[1] == 0 && __a->s6_addr32[2] == 0 && ntohl (__a->s6_addr32[3]) > 1; }))
#define IN6_ARE_ADDR_EQUAL(a,b) (__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); const struct in6_addr *__b = (const struct in6_addr *) (b); __a->s6_addr32[0] == __b->s6_addr32[0] && __a->s6_addr32[1] == __b->s6_addr32[1] && __a->s6_addr32[2] == __b->s6_addr32[2] && __a->s6_addr32[3] == __b->s6_addr32[3]; }))
#define IN6_IS_ADDR_MULTICAST(a) (((const uint8_t *) (a))[0] == 0xff)
extern int bindresvport (int __sockfd, struct sockaddr_in *__sock_in) throw ();
extern int bindresvport6 (int __sockfd, struct sockaddr_in6 *__sock_in)
throw ();
#define IN6_IS_ADDR_MC_NODELOCAL(a) (IN6_IS_ADDR_MULTICAST(a) && ((((const uint8_t *) (a))[1] & 0xf) == 0x1))
#define IN6_IS_ADDR_MC_LINKLOCAL(a) (IN6_IS_ADDR_MULTICAST(a) && ((((const uint8_t *) (a))[1] & 0xf) == 0x2))
#define IN6_IS_ADDR_MC_SITELOCAL(a) (IN6_IS_ADDR_MULTICAST(a) && ((((const uint8_t *) (a))[1] & 0xf) == 0x5))
#define IN6_IS_ADDR_MC_ORGLOCAL(a) (IN6_IS_ADDR_MULTICAST(a) && ((((const uint8_t *) (a))[1] & 0xf) == 0x8))
#define IN6_IS_ADDR_MC_GLOBAL(a) (IN6_IS_ADDR_MULTICAST(a) && ((((const uint8_t *) (a))[1] & 0xf) == 0xe))
struct cmsghdr;
struct in6_pktinfo
{
struct in6_addr ipi6_addr;
unsigned int ipi6_ifindex;
};
struct ip6_mtuinfo
{
struct sockaddr_in6 ip6m_addr;
uint32_t ip6m_mtu;
};
extern int inet6_option_space (int __nbytes)
throw () __attribute__ ((__deprecated__));
extern int inet6_option_init (void *__bp, struct cmsghdr **__cmsgp,
int __type) throw () __attribute__ ((__deprecated__));
extern int inet6_option_append (struct cmsghdr *__cmsg,
const uint8_t *__typep, int __multx,
int __plusy) throw () __attribute__ ((__deprecated__));
extern uint8_t *inet6_option_alloc (struct cmsghdr *__cmsg, int __datalen,
int __multx, int __plusy)
throw () __attribute__ ((__deprecated__));
extern int inet6_option_next (const struct cmsghdr *__cmsg,
uint8_t **__tptrp)
throw () __attribute__ ((__deprecated__));
extern int inet6_option_find (const struct cmsghdr *__cmsg,
uint8_t **__tptrp, int __type)
throw () __attribute__ ((__deprecated__));
extern int inet6_opt_init (void *__extbuf, socklen_t __extlen) throw ();
extern int inet6_opt_append (void *__extbuf, socklen_t __extlen, int __offset,
uint8_t __type, socklen_t __len, uint8_t __align,
void **__databufp) throw ();
extern int inet6_opt_finish (void *__extbuf, socklen_t __extlen, int __offset)
throw ();
extern int inet6_opt_set_val (void *__databuf, int __offset, void *__val,
socklen_t __vallen) throw ();
extern int inet6_opt_next (void *__extbuf, socklen_t __extlen, int __offset,
uint8_t *__typep, socklen_t *__lenp,
void **__databufp) throw ();
extern int inet6_opt_find (void *__extbuf, socklen_t __extlen, int __offset,
uint8_t __type, socklen_t *__lenp,
void **__databufp) throw ();
extern int inet6_opt_get_val (void *__databuf, int __offset, void *__val,
socklen_t __vallen) throw ();
extern socklen_t inet6_rth_space (int __type, int __segments) throw ();
extern void *inet6_rth_init (void *__bp, socklen_t __bp_len, int __type,
int __segments) throw ();
extern int inet6_rth_add (void *__bp, const struct in6_addr *__addr) throw ();
extern int inet6_rth_reverse (const void *__in, void *__out) throw ();
extern int inet6_rth_segments (const void *__bp) throw ();
extern struct in6_addr *inet6_rth_getaddr (const void *__bp, int __index)
throw ();
extern int getipv4sourcefilter (int __s, struct in_addr __interface_addr,
struct in_addr __group, uint32_t *__fmode,
uint32_t *__numsrc, struct in_addr *__slist)
throw ();
extern int setipv4sourcefilter (int __s, struct in_addr __interface_addr,
struct in_addr __group, uint32_t __fmode,
uint32_t __numsrc,
const struct in_addr *__slist)
throw ();
extern int getsourcefilter (int __s, uint32_t __interface_addr,
const struct sockaddr *__group,
socklen_t __grouplen, uint32_t *__fmode,
uint32_t *__numsrc,
struct sockaddr_storage *__slist) throw ();
extern int setsourcefilter (int __s, uint32_t __interface_addr,
const struct sockaddr *__group,
socklen_t __grouplen, uint32_t __fmode,
uint32_t __numsrc,
const struct sockaddr_storage *__slist) throw ();
}
#define _RPC_NETDB_H 1
#define __need_size_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
extern "C" {
struct rpcent
{
char *r_name;
char **r_aliases;
int r_number;
};
extern void setrpcent (int __stayopen) throw ();
extern void endrpcent (void) throw ();
extern struct rpcent *getrpcbyname (const char *__name) throw ();
extern struct rpcent *getrpcbynumber (int __number) throw ();
extern struct rpcent *getrpcent (void) throw ();
extern int getrpcbyname_r (const char *__name, struct rpcent *__result_buf,
char *__buffer, size_t __buflen,
struct rpcent **__result) throw ();
extern int getrpcbynumber_r (int __number, struct rpcent *__result_buf,
char *__buffer, size_t __buflen,
struct rpcent **__result) throw ();
extern int getrpcent_r (struct rpcent *__result_buf, char *__buffer,
size_t __buflen, struct rpcent **__result) throw ();
}
#define __need_sigevent_t
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
#define __have_sigval_t 1
typedef union sigval
{
int sival_int;
void *sival_ptr;
} sigval_t;
#define __have_sigevent_t 1
#define __SIGEV_MAX_SIZE 64
#define __SIGEV_PAD_SIZE ((__SIGEV_MAX_SIZE / sizeof (int)) - 4)
typedef struct sigevent
{
sigval_t sigev_value;
int sigev_signo;
int sigev_notify;
union
{
int _pad[((64 / sizeof (int)) - 4)];
__pid_t _tid;
struct
{
void (*_function) (sigval_t);
pthread_attr_t *_attribute;
} _sigev_thread;
} _sigev_un;
} sigevent_t;
#define sigev_notify_function _sigev_un._sigev_thread._function
#define sigev_notify_attributes _sigev_un._sigev_thread._attribute
enum
{
SIGEV_SIGNAL = 0,
#define SIGEV_SIGNAL SIGEV_SIGNAL
SIGEV_NONE,
#define SIGEV_NONE SIGEV_NONE
SIGEV_THREAD,
#define SIGEV_THREAD SIGEV_THREAD
SIGEV_THREAD_ID = 4
#define SIGEV_THREAD_ID SIGEV_THREAD_ID
};
#define __need_timespec
struct netent
{
char *n_name;
char **n_aliases;
int n_addrtype;
uint32_t n_net;
};
#define _PATH_HEQUIV "/etc/hosts.equiv"
#define _PATH_HOSTS "/etc/hosts"
#define _PATH_NETWORKS "/etc/networks"
#define _PATH_NSSWITCH_CONF "/etc/nsswitch.conf"
#define _PATH_PROTOCOLS "/etc/protocols"
#define _PATH_SERVICES "/etc/services"
extern "C" {
#define h_errno (*__h_errno_location ())
extern int *__h_errno_location (void) throw () __attribute__ ((__const__));
#define HOST_NOT_FOUND 1
#define TRY_AGAIN 2
#define NO_RECOVERY 3
#define NO_DATA 4
#define NETDB_INTERNAL -1
#define NETDB_SUCCESS 0
#define NO_ADDRESS NO_DATA
#define IPPORT_RESERVED 1024
#define SCOPE_DELIMITER '%'
extern void herror (const char *__str) throw ();
extern const char *hstrerror (int __err_num) throw ();
struct hostent
{
char *h_name;
char **h_aliases;
int h_addrtype;
int h_length;
char **h_addr_list;
#define h_addr h_addr_list[0]
};
extern void sethostent (int __stay_open);
extern void endhostent (void);
extern struct hostent *gethostent (void);
extern struct hostent *gethostbyaddr (const void *__addr, __socklen_t __len,
int __type);
extern struct hostent *gethostbyname (const char *__name);
extern struct hostent *gethostbyname2 (const char *__name, int __af);
extern int gethostent_r (struct hostent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct hostent **__restrict __result,
int *__restrict __h_errnop);
extern int gethostbyaddr_r (const void *__restrict __addr, __socklen_t __len,
int __type,
struct hostent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct hostent **__restrict __result,
int *__restrict __h_errnop);
extern int gethostbyname_r (const char *__restrict __name,
struct hostent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct hostent **__restrict __result,
int *__restrict __h_errnop);
extern int gethostbyname2_r (const char *__restrict __name, int __af,
struct hostent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct hostent **__restrict __result,
int *__restrict __h_errnop);
extern void setnetent (int __stay_open);
extern void endnetent (void);
extern struct netent *getnetent (void);
extern struct netent *getnetbyaddr (uint32_t __net, int __type);
extern struct netent *getnetbyname (const char *__name);
extern int getnetent_r (struct netent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct netent **__restrict __result,
int *__restrict __h_errnop);
extern int getnetbyaddr_r (uint32_t __net, int __type,
struct netent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct netent **__restrict __result,
int *__restrict __h_errnop);
extern int getnetbyname_r (const char *__restrict __name,
struct netent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct netent **__restrict __result,
int *__restrict __h_errnop);
struct servent
{
char *s_name;
char **s_aliases;
int s_port;
char *s_proto;
};
extern void setservent (int __stay_open);
extern void endservent (void);
extern struct servent *getservent (void);
extern struct servent *getservbyname (const char *__name, const char *__proto);
extern struct servent *getservbyport (int __port, const char *__proto);
extern int getservent_r (struct servent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct servent **__restrict __result);
extern int getservbyname_r (const char *__restrict __name,
const char *__restrict __proto,
struct servent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct servent **__restrict __result);
extern int getservbyport_r (int __port, const char *__restrict __proto,
struct servent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct servent **__restrict __result);
struct protoent
{
char *p_name;
char **p_aliases;
int p_proto;
};
extern void setprotoent (int __stay_open);
extern void endprotoent (void);
extern struct protoent *getprotoent (void);
extern struct protoent *getprotobyname (const char *__name);
extern struct protoent *getprotobynumber (int __proto);
extern int getprotoent_r (struct protoent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct protoent **__restrict __result);
extern int getprotobyname_r (const char *__restrict __name,
struct protoent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct protoent **__restrict __result);
extern int getprotobynumber_r (int __proto,
struct protoent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct protoent **__restrict __result);
extern int setnetgrent (const char *__netgroup);
extern void endnetgrent (void);
extern int getnetgrent (char **__restrict __hostp,
char **__restrict __userp,
char **__restrict __domainp);
extern int innetgr (const char *__netgroup, const char *__host,
const char *__user, const char *__domain);
extern int getnetgrent_r (char **__restrict __hostp,
char **__restrict __userp,
char **__restrict __domainp,
char *__restrict __buffer, size_t __buflen);
extern int rcmd (char **__restrict __ahost, unsigned short int __rport,
const char *__restrict __locuser,
const char *__restrict __remuser,
const char *__restrict __cmd, int *__restrict __fd2p);
extern int rcmd_af (char **__restrict __ahost, unsigned short int __rport,
const char *__restrict __locuser,
const char *__restrict __remuser,
const char *__restrict __cmd, int *__restrict __fd2p,
sa_family_t __af);
extern int rexec (char **__restrict __ahost, int __rport,
const char *__restrict __name,
const char *__restrict __pass,
const char *__restrict __cmd, int *__restrict __fd2p);
extern int rexec_af (char **__restrict __ahost, int __rport,
const char *__restrict __name,
const char *__restrict __pass,
const char *__restrict __cmd, int *__restrict __fd2p,
sa_family_t __af);
extern int ruserok (const char *__rhost, int __suser,
const char *__remuser, const char *__locuser);
extern int ruserok_af (const char *__rhost, int __suser,
const char *__remuser, const char *__locuser,
sa_family_t __af);
extern int iruserok (uint32_t __raddr, int __suser,
const char *__remuser, const char *__locuser);
extern int iruserok_af (const void *__raddr, int __suser,
const char *__remuser, const char *__locuser,
sa_family_t __af);
extern int rresvport (int *__alport);
extern int rresvport_af (int *__alport, sa_family_t __af);
struct addrinfo
{
int ai_flags;
int ai_family;
int ai_socktype;
int ai_protocol;
socklen_t ai_addrlen;
struct sockaddr *ai_addr;
char *ai_canonname;
struct addrinfo *ai_next;
};
struct gaicb
{
const char *ar_name;
const char *ar_service;
const struct addrinfo *ar_request;
struct addrinfo *ar_result;
int __return;
int __glibc_reserved[5];
};
#define GAI_WAIT 0
#define GAI_NOWAIT 1
#define AI_PASSIVE 0x0001
#define AI_CANONNAME 0x0002
#define AI_NUMERICHOST 0x0004
#define AI_V4MAPPED 0x0008
#define AI_ALL 0x0010
#define AI_ADDRCONFIG 0x0020
#define AI_IDN 0x0040
#define AI_CANONIDN 0x0080
#define AI_IDN_ALLOW_UNASSIGNED 0x0100
#define AI_IDN_USE_STD3_ASCII_RULES 0x0200
#define AI_NUMERICSERV 0x0400
#define EAI_BADFLAGS -1
#define EAI_NONAME -2
#define EAI_AGAIN -3
#define EAI_FAIL -4
#define EAI_FAMILY -6
#define EAI_SOCKTYPE -7
#define EAI_SERVICE -8
#define EAI_MEMORY -10
#define EAI_SYSTEM -11
#define EAI_OVERFLOW -12
#define EAI_NODATA -5
#define EAI_ADDRFAMILY -9
#define EAI_INPROGRESS -100
#define EAI_CANCELED -101
#define EAI_NOTCANCELED -102
#define EAI_ALLDONE -103
#define EAI_INTR -104
#define EAI_IDN_ENCODE -105
#define NI_MAXHOST 1025
#define NI_MAXSERV 32
#define NI_NUMERICHOST 1
#define NI_NUMERICSERV 2
#define NI_NOFQDN 4
#define NI_NAMEREQD 8
#define NI_DGRAM 16
#define NI_IDN 32
#define NI_IDN_ALLOW_UNASSIGNED 64
#define NI_IDN_USE_STD3_ASCII_RULES 128
extern int getaddrinfo (const char *__restrict __name,
const char *__restrict __service,
const struct addrinfo *__restrict __req,
struct addrinfo **__restrict __pai);
extern void freeaddrinfo (struct addrinfo *__ai) throw ();
extern const char *gai_strerror (int __ecode) throw ();
extern int getnameinfo (const struct sockaddr *__restrict __sa,
socklen_t __salen, char *__restrict __host,
socklen_t __hostlen, char *__restrict __serv,
socklen_t __servlen, int __flags);
extern int getaddrinfo_a (int __mode, struct gaicb *__list[],
int __ent, struct sigevent *__restrict __sig);
extern int gai_suspend (const struct gaicb *const __list[], int __ent,
const struct timespec *__timeout);
extern int gai_error (struct gaicb *__req) throw ();
extern int gai_cancel (struct gaicb *__gaicbp) throw ();
}
#define BOOST_ASIO_NATIVE_ERROR(e) e
#define BOOST_ASIO_SOCKET_ERROR(e) e
#define BOOST_ASIO_NETDB_ERROR(e) e
#define BOOST_ASIO_GETADDRINFO_ERROR(e) e
#define BOOST_ASIO_WIN_OR_POSIX(e_win,e_posix) e_posix
namespace boost {
namespace asio {
namespace error {
enum basic_errors
{
access_denied = 13,
address_family_not_supported = 97,
address_in_use = 98,
already_connected = 106,
already_started = 114,
broken_pipe = 32,
connection_aborted = 103,
connection_refused = 111,
connection_reset = 104,
bad_descriptor = 9,
fault = 14,
host_unreachable = 113,
in_progress = 115,
interrupted = 4,
invalid_argument = 22,
message_size = 90,
name_too_long = 36,
network_down = 100,
network_reset = 102,
network_unreachable = 101,
no_descriptors = 24,
no_buffer_space = 105,
no_memory = 12,
no_permission = 1,
no_protocol_option = 92,
not_connected = 107,
not_socket = 88,
operation_aborted = 125,
operation_not_supported = 95,
shut_down = 108,
timed_out = 110,
try_again = 11,
would_block = 11
};
enum netdb_errors
{
host_not_found = 1,
host_not_found_try_again = 2,
no_data = 4,
no_recovery = 3
};
enum addrinfo_errors
{
service_not_found = -8,
socket_type_not_supported = -7
};
enum misc_errors
{
already_open = 1,
eof,
not_found,
fd_set_failure
};
const boost::system::error_category& get_system_category()
;
extern inline
const boost::system::error_category& get_netdb_category();
extern inline
const boost::system::error_category& get_addrinfo_category();
extern inline
const boost::system::error_category& get_misc_category();
static const boost::system::error_category& system_category
= boost::asio::error::get_system_category();
static const boost::system::error_category& netdb_category
= boost::asio::error::get_netdb_category();
static const boost::system::error_category& addrinfo_category
= boost::asio::error::get_addrinfo_category();
static const boost::system::error_category& misc_category
= boost::asio::error::get_misc_category();
}
}
}
namespace boost {
namespace system {
template<> struct is_error_code_enum<boost::asio::error::basic_errors>
{
static const bool value = true;
};
template<> struct is_error_code_enum<boost::asio::error::netdb_errors>
{
static const bool value = true;
};
template<> struct is_error_code_enum<boost::asio::error::addrinfo_errors>
{
static const bool value = true;
};
template<> struct is_error_code_enum<boost::asio::error::misc_errors>
{
static const bool value = true;
};
}
}
namespace boost {
namespace asio {
namespace error {
boost::system::error_code make_error_code(basic_errors e)
;
boost::system::error_code make_error_code(netdb_errors e)
;
boost::system::error_code make_error_code(addrinfo_errors e)
;
boost::system::error_code make_error_code(misc_errors e)
;
}
}
}
#undef BOOST_ASIO_NATIVE_ERROR
#undef BOOST_ASIO_SOCKET_ERROR
#undef BOOST_ASIO_NETDB_ERROR
#undef BOOST_ASIO_GETADDRINFO_ERROR
#undef BOOST_ASIO_WIN_OR_POSIX
#define BOOST_ASIO_IMPL_ERROR_IPP
namespace boost {
namespace asio {
namespace error {
namespace detail {
class netdb_category : public boost::system::error_category
{
public:
const char* name() const noexcept
{
return "asio.netdb";
}
std::string message(int value) const
{
if (value == error::host_not_found)
return "Host not found (authoritative)";
if (value == error::host_not_found_try_again)
return "Host not found (non-authoritative), try again later";
if (value == error::no_data)
return "The query is valid, but it does not have associated data";
if (value == error::no_recovery)
return "A non-recoverable error occurred during database lookup";
return "asio.netdb error";
}
};
}
const boost::system::error_category& get_netdb_category()
;
namespace detail {
class addrinfo_category : public boost::system::error_category
{
public:
const char* name() const noexcept
{
return "asio.addrinfo";
}
std::string message(int value) const
{
if (value == error::service_not_found)
return "Service not found";
if (value == error::socket_type_not_supported)
return "Socket type not supported";
return "asio.addrinfo error";
}
};
}
const boost::system::error_category& get_addrinfo_category()
;
namespace detail {
class misc_category : public boost::system::error_category
{
public:
const char* name() const noexcept
{
return "asio.misc";
}
std::string message(int value) const
{
if (value == error::already_open)
return "Already open";
if (value == error::eof)
return "End of file";
if (value == error::not_found)
return "Element not found";
if (value == error::fd_set_failure)
return "The descriptor does not fit into the select call's fd_set";
return "asio.misc error";
}
};
}
const boost::system::error_category& get_misc_category()
;
}
}
}
namespace boost {
namespace asio {
namespace detail {
}
}
}
namespace boost {
namespace asio {
namespace detail {
typedef posix_event event;
}
}
}
#define BOOST_ASIO_DETAIL_OP_QUEUE_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Operation>
class op_queue;
class op_queue_access
{
public:
template <typename Operation>
static Operation* next(Operation* o)
;
template <typename Operation1, typename Operation2>
static void next(Operation1*& o1, Operation2* o2)
;
template <typename Operation>
static void destroy(Operation* o)
;
template <typename Operation>
static Operation*& front(op_queue<Operation>& q)
;
template <typename Operation>
static Operation*& back(op_queue<Operation>& q)
;
};
template <typename Operation>
class op_queue
: private noncopyable
{
public:
op_queue()
;
~op_queue()
;
Operation* front()
;
void pop()
;
void push(Operation* h)
;
template <typename OtherOperation>
void push(op_queue<OtherOperation>& q)
;
bool empty() const
;
private:
friend class op_queue_access;
Operation* front_;
Operation* back_;
};
}
}
}
#define BOOST_ASIO_DETAIL_THREAD_INFO_BASE_HPP
#define _GCC_LIMITS_H_
#define _GCC_NEXT_LIMITS_H
#define _LIBC_LIMITS_H_ 1
#define MB_LEN_MAX 16
#define LLONG_MIN (-LLONG_MAX-1)
#define LLONG_MAX __LONG_LONG_MAX__
#define ULLONG_MAX (LLONG_MAX * 2ULL + 1)
#define _BITS_POSIX1_LIM_H 1
#define _POSIX_AIO_LISTIO_MAX 2
#define _POSIX_AIO_MAX 1
#define _POSIX_ARG_MAX 4096
#define _POSIX_CHILD_MAX 25
#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_FD_SETSIZE _POSIX_OPEN_MAX
#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_SYMLINK_MAX 255
#define _POSIX_SYMLOOP_MAX 8
#define _POSIX_TIMER_MAX 32
#define _POSIX_TTY_NAME_MAX 9
#define _POSIX_TZNAME_MAX 6
#define _POSIX_QLIMIT 1
#define _POSIX_HIWAT _POSIX_PIPE_BUF
#define _POSIX_UIO_MAXIOV 16
#define _POSIX_CLOCKRES_MIN 20000000
#define __undef_NR_OPEN
#define __undef_LINK_MAX
#define __undef_OPEN_MAX
#define __undef_ARG_MAX
#define _LINUX_LIMITS_H
#define NR_OPEN 1024
#define NGROUPS_MAX 65536
#define ARG_MAX 131072
#define LINK_MAX 127
#define MAX_CANON 255
#define MAX_INPUT 255
#define NAME_MAX 255
#define PATH_MAX 4096
#define PIPE_BUF 4096
#define XATTR_NAME_MAX 255
#define XATTR_SIZE_MAX 65536
#define XATTR_LIST_MAX 65536
#define RTSIG_MAX 32
#undef NR_OPEN
#undef __undef_NR_OPEN
#undef LINK_MAX
#undef __undef_LINK_MAX
#undef OPEN_MAX
#undef __undef_OPEN_MAX
#undef ARG_MAX
#undef __undef_ARG_MAX
#define _POSIX_THREAD_KEYS_MAX 128
#define PTHREAD_KEYS_MAX 1024
#define _POSIX_THREAD_DESTRUCTOR_ITERATIONS 4
#define PTHREAD_DESTRUCTOR_ITERATIONS _POSIX_THREAD_DESTRUCTOR_ITERATIONS
#define _POSIX_THREAD_THREADS_MAX 64
#undef PTHREAD_THREADS_MAX
#define AIO_PRIO_DELTA_MAX 20
#define PTHREAD_STACK_MIN 16384
#define DELAYTIMER_MAX 2147483647
#define TTY_NAME_MAX 32
#define LOGIN_NAME_MAX 256
#define HOST_NAME_MAX 64
#define MQ_PRIO_MAX 32768
#define SEM_VALUE_MAX (2147483647)
#define SSIZE_MAX LONG_MAX
#define _BITS_POSIX2_LIM_H 1
#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_COLL_WEIGHTS_MAX 2
#define _POSIX2_EXPR_NEST_MAX 32
#define _POSIX2_LINE_MAX 2048
#define _POSIX2_RE_DUP_MAX 255
#define _POSIX2_CHARCLASS_NAME_MAX 14
#define BC_BASE_MAX _POSIX2_BC_BASE_MAX
#define BC_DIM_MAX _POSIX2_BC_DIM_MAX
#define BC_SCALE_MAX _POSIX2_BC_SCALE_MAX
#define BC_STRING_MAX _POSIX2_BC_STRING_MAX
#define COLL_WEIGHTS_MAX 255
#define EXPR_NEST_MAX _POSIX2_EXPR_NEST_MAX
#define LINE_MAX _POSIX2_LINE_MAX
#define CHARCLASS_NAME_MAX 2048
#define RE_DUP_MAX (0x7fff)
#define _XOPEN_LIM_H 1
#define __need_IOV_MAX
#define L_tmpnam 20
#define TMP_MAX 238328
#define FILENAME_MAX 4096
#define L_ctermid 9
#define L_cuserid 9
#undef FOPEN_MAX
#define FOPEN_MAX 16
#define IOV_MAX 1024
#define _XOPEN_IOV_MAX _POSIX_UIO_MAXIOV
#define NL_ARGMAX _POSIX_ARG_MAX
#define NL_LANGMAX _POSIX2_LINE_MAX
#define NL_MSGMAX INT_MAX
#define NL_NMAX INT_MAX
#define NL_SETMAX INT_MAX
#define NL_TEXTMAX INT_MAX
#define NZERO 20
#define WORD_BIT 32
#define LONG_BIT 64
#undef _GCC_NEXT_LIMITS_H
#define _LIMITS_H___
#undef CHAR_BIT
#define CHAR_BIT __CHAR_BIT__
#undef SCHAR_MIN
#define SCHAR_MIN (-SCHAR_MAX - 1)
#undef SCHAR_MAX
#define SCHAR_MAX __SCHAR_MAX__
#undef UCHAR_MAX
#define UCHAR_MAX (SCHAR_MAX * 2 + 1)
#undef CHAR_MIN
#define CHAR_MIN SCHAR_MIN
#undef CHAR_MAX
#define CHAR_MAX SCHAR_MAX
#undef SHRT_MIN
#define SHRT_MIN (-SHRT_MAX - 1)
#undef SHRT_MAX
#define SHRT_MAX __SHRT_MAX__
#undef USHRT_MAX
#define USHRT_MAX (SHRT_MAX * 2 + 1)
#undef INT_MIN
#define INT_MIN (-INT_MAX - 1)
#undef INT_MAX
#define INT_MAX __INT_MAX__
#undef UINT_MAX
#define UINT_MAX (INT_MAX * 2U + 1U)
#undef LONG_MIN
#define LONG_MIN (-LONG_MAX - 1L)
#undef LONG_MAX
#define LONG_MAX __LONG_MAX__
#undef ULONG_MAX
#define ULONG_MAX (LONG_MAX * 2UL + 1UL)
#undef LONG_LONG_MIN
#define LONG_LONG_MIN (-LONG_LONG_MAX - 1LL)
#undef LONG_LONG_MAX
#define LONG_LONG_MAX __LONG_LONG_MAX__
#undef ULONG_LONG_MAX
#define ULONG_LONG_MAX (LONG_LONG_MAX * 2ULL + 1ULL)
#define _GLIBCXX_CLIMITS 1
namespace boost {
namespace asio {
namespace detail {
class thread_info_base
: private noncopyable
{
public:
thread_info_base()
;
~thread_info_base()
;
static void* allocate(thread_info_base* this_thread, std::size_t size)
;
static void deallocate(thread_info_base* this_thread,
void* pointer, std::size_t size)
;
private:
void* reusable_memory_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
class task_io_service;
class task_io_service_operation;
struct task_io_service_thread_info : public thread_info_base
{
event* wakeup_event;
op_queue<task_io_service_operation> private_op_queue;
long private_outstanding_work;
task_io_service_thread_info* next;
};
}
}
}
namespace boost {
namespace asio {
void* asio_handler_allocate(std::size_t size, ...)
;
void asio_handler_deallocate(void* pointer, std::size_t size, ...)
;
}
}
namespace boost_asio_handler_alloc_helpers {
template <typename Handler>
void* allocate(std::size_t s, Handler& h)
;
template <typename Handler>
void deallocate(void* p, std::size_t s, Handler& h)
;
}
#define BOOST_ASIO_DEFINE_HANDLER_PTR(op) struct ptr { Handler* h; void* v; op* p; ~ptr() { reset(); } void reset() { if (p) { p->~op(); p = 0; } if (v) { boost_asio_handler_alloc_helpers::deallocate(v, sizeof(op), *h); v = 0; } } }
#define BOOST_ASIO_DETAIL_HANDLER_CONT_HELPERS_HPP
#define BOOST_ASIO_HANDLER_CONTINUATION_HOOK_HPP
namespace boost {
namespace asio {
bool asio_handler_is_continuation(...)
;
}
}
namespace boost_asio_handler_cont_helpers {
template <typename Context>
bool is_continuation(Context& context)
;
}
#define BOOST_ASIO_DETAIL_HANDLER_INVOKE_HELPERS_HPP
#define BOOST_ASIO_HANDLER_INVOKE_HOOK_HPP
namespace boost {
namespace asio {
template <typename Function>
void asio_handler_invoke(Function& function, ...)
;
template <typename Function>
void asio_handler_invoke(const Function& function, ...)
;
}
}
namespace boost_asio_handler_invoke_helpers {
template <typename Function, typename Context>
void invoke(Function& function, Context& context)
;
template <typename Function, typename Context>
void invoke(const Function& function, Context& context)
;
}
namespace boost {
namespace asio {
namespace detail {
template <typename Handler, typename Arg1>
class binder1
{
public:
binder1(const Handler& handler, const Arg1& arg1)
;
binder1(Handler& handler, const Arg1& arg1)
;
void operator()()
;
void operator()() const
;
Handler handler_;
Arg1 arg1_;
};
template <typename Handler, typename Arg1>
void* asio_handler_allocate(std::size_t size,
binder1<Handler, Arg1>* this_handler)
;
template <typename Handler, typename Arg1>
void asio_handler_deallocate(void* pointer, std::size_t size,
binder1<Handler, Arg1>* this_handler)
;
template <typename Handler, typename Arg1>
inline bool asio_handler_is_continuation(
binder1<Handler, Arg1>* this_handler)
{
return boost_asio_handler_cont_helpers::is_continuation(
this_handler->handler_);
}
template <typename Function, typename Handler, typename Arg1>
inline void asio_handler_invoke(Function& function,
binder1<Handler, Arg1>* this_handler)
{
boost_asio_handler_invoke_helpers::invoke(
function, this_handler->handler_);
}
template <typename Function, typename Handler, typename Arg1>
inline void asio_handler_invoke(const Function& function,
binder1<Handler, Arg1>* this_handler)
{
boost_asio_handler_invoke_helpers::invoke(
function, this_handler->handler_);
}
template <typename Handler, typename Arg1>
inline binder1<Handler, Arg1> bind_handler(Handler handler,
const Arg1& arg1)
{
return binder1<Handler, Arg1>(handler, arg1);
}
template <typename Handler, typename Arg1, typename Arg2>
class binder2
{
public:
binder2(const Handler& handler, const Arg1& arg1, const Arg2& arg2)
;
binder2(Handler& handler, const Arg1& arg1, const Arg2& arg2)
;
void operator()()
;
void operator()() const
;
Handler handler_;
Arg1 arg1_;
Arg2 arg2_;
};
template <typename Handler, typename Arg1, typename Arg2>
void* asio_handler_allocate(std::size_t size,
binder2<Handler, Arg1, Arg2>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2>
void asio_handler_deallocate(void* pointer, std::size_t size,
binder2<Handler, Arg1, Arg2>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2>
bool asio_handler_is_continuation(
binder2<Handler, Arg1, Arg2>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2>
void asio_handler_invoke(Function& function,
binder2<Handler, Arg1, Arg2>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2>
void asio_handler_invoke(const Function& function,
binder2<Handler, Arg1, Arg2>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2>
binder2<Handler, Arg1, Arg2> bind_handler(Handler handler,
const Arg1& arg1, const Arg2& arg2)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
class binder3
{
public:
binder3(const Handler& handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3)
;
binder3(Handler& handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3)
;
void operator()()
;
void operator()() const
;
Handler handler_;
Arg1 arg1_;
Arg2 arg2_;
Arg3 arg3_;
};
template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
void* asio_handler_allocate(std::size_t size,
binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
void asio_handler_deallocate(void* pointer, std::size_t size,
binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
bool asio_handler_is_continuation(
binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2,
typename Arg3>
void asio_handler_invoke(Function& function,
binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2,
typename Arg3>
void asio_handler_invoke(const Function& function,
binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
binder3<Handler, Arg1, Arg2, Arg3> bind_handler(Handler handler,
const Arg1& arg1, const Arg2& arg2, const Arg3& arg3)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4>
class binder4
{
public:
binder4(const Handler& handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3, const Arg4& arg4)
;
binder4(Handler& handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3, const Arg4& arg4)
;
void operator()()
;
void operator()() const
;
Handler handler_;
Arg1 arg1_;
Arg2 arg2_;
Arg3 arg3_;
Arg4 arg4_;
};
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4>
void* asio_handler_allocate(std::size_t size,
binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4>
void asio_handler_deallocate(void* pointer, std::size_t size,
binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4>
bool asio_handler_is_continuation(
binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2,
typename Arg3, typename Arg4>
void asio_handler_invoke(Function& function,
binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2,
typename Arg3, typename Arg4>
void asio_handler_invoke(const Function& function,
binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4>
binder4<Handler, Arg1, Arg2, Arg3, Arg4> bind_handler(
Handler handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3, const Arg4& arg4)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5>
class binder5
{
public:
binder5(const Handler& handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
;
binder5(Handler& handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
;
void operator()()
;
void operator()() const
;
Handler handler_;
Arg1 arg1_;
Arg2 arg2_;
Arg3 arg3_;
Arg4 arg4_;
Arg5 arg5_;
};
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5>
void* asio_handler_allocate(std::size_t size,
binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5>
void asio_handler_deallocate(void* pointer, std::size_t size,
binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5>
bool asio_handler_is_continuation(
binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2,
typename Arg3, typename Arg4, typename Arg5>
void asio_handler_invoke(Function& function,
binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2,
typename Arg3, typename Arg4, typename Arg5>
void asio_handler_invoke(const Function& function,
binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5>
binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5> bind_handler(
Handler handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
;
}
}
}
namespace boost {
namespace asio {
namespace detail {
struct is_continuation_delegated
{
template <typename Dispatcher, typename Handler>
bool operator()(Dispatcher&, Handler& handler) const
;
};
struct is_continuation_if_running
{
template <typename Dispatcher, typename Handler>
bool operator()(Dispatcher& dispatcher, Handler&) const
;
};
template <typename Dispatcher, typename Handler,
typename IsContinuation = is_continuation_delegated>
class wrapped_handler
{
public:
typedef void result_type;
wrapped_handler(Dispatcher dispatcher, Handler& handler)
;
wrapped_handler(const wrapped_handler& other)
;
wrapped_handler(wrapped_handler&& other)
;
void operator()()
;
void operator()() const
;
template <typename Arg1>
void operator()(const Arg1& arg1)
;
template <typename Arg1>
void operator()(const Arg1& arg1) const
;
template <typename Arg1, typename Arg2>
void operator()(const Arg1& arg1, const Arg2& arg2)
;
template <typename Arg1, typename Arg2>
void operator()(const Arg1& arg1, const Arg2& arg2) const
;
template <typename Arg1, typename Arg2, typename Arg3>
void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3)
;
template <typename Arg1, typename Arg2, typename Arg3>
void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3) const
;
template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
const Arg4& arg4)
;
template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
const Arg4& arg4) const
;
template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
typename Arg5>
void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
const Arg4& arg4, const Arg5& arg5)
;
template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
typename Arg5>
void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
const Arg4& arg4, const Arg5& arg5) const
;
Dispatcher dispatcher_;
Handler handler_;
};
template <typename Handler, typename Context>
class rewrapped_handler
{
public:
explicit rewrapped_handler(Handler& handler, const Context& context)
;
explicit rewrapped_handler(const Handler& handler, const Context& context)
;
rewrapped_handler(const rewrapped_handler& other)
;
rewrapped_handler(rewrapped_handler&& other)
;
void operator()()
;
void operator()() const
;
Context context_;
Handler handler_;
};
template <typename Dispatcher, typename Handler, typename IsContinuation>
void* asio_handler_allocate(std::size_t size,
wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
;
template <typename Dispatcher, typename Handler, typename IsContinuation>
void asio_handler_deallocate(void* pointer, std::size_t size,
wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
;
template <typename Dispatcher, typename Handler, typename IsContinuation>
bool asio_handler_is_continuation(
wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
;
template <typename Function, typename Dispatcher,
typename Handler, typename IsContinuation>
void asio_handler_invoke(Function& function,
wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
;
template <typename Function, typename Dispatcher,
typename Handler, typename IsContinuation>
void asio_handler_invoke(const Function& function,
wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
;
template <typename Handler, typename Context>
void* asio_handler_allocate(std::size_t size,
rewrapped_handler<Handler, Context>* this_handler)
;
template <typename Handler, typename Context>
void asio_handler_deallocate(void* pointer, std::size_t size,
rewrapped_handler<Handler, Context>* this_handler)
;
template <typename Dispatcher, typename Context>
bool asio_handler_is_continuation(
rewrapped_handler<Dispatcher, Context>* this_handler)
;
template <typename Function, typename Handler, typename Context>
void asio_handler_invoke(Function& function,
rewrapped_handler<Handler, Context>* this_handler)
;
template <typename Function, typename Handler, typename Context>
void asio_handler_invoke(const Function& function,
rewrapped_handler<Handler, Context>* this_handler)
;
}
}
}
namespace boost {
namespace asio {
class io_service;
template <typename Service> Service& use_service(io_service& ios);
template <typename Service> void add_service(io_service& ios, Service* svc);
template <typename Service> bool has_service(io_service& ios);
namespace detail {
typedef class task_io_service io_service_impl;
class service_registry;
}
class io_service
: private noncopyable
{
private:
typedef detail::io_service_impl impl_type;
public:
class work;
friend class work;
class id;
class service;
class strand;
inline io_service();
inline explicit io_service(std::size_t concurrency_hint);
inline ~io_service();
inline std::size_t run();
inline std::size_t run(boost::system::error_code& ec);
inline std::size_t run_one();
inline std::size_t run_one(boost::system::error_code& ec);
inline std::size_t poll();
inline std::size_t poll(boost::system::error_code& ec);
inline std::size_t poll_one();
inline std::size_t poll_one(boost::system::error_code& ec);
inline void stop();
inline bool stopped() const;
inline void reset();
template <typename CompletionHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<CompletionHandler, void ()>::type>::type
dispatch(CompletionHandler&& handler);
template <typename CompletionHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<CompletionHandler, void ()>::type>::type
post(CompletionHandler&& handler);
template <typename Handler>
detail::wrapped_handler<io_service&, Handler>
wrap(Handler handler);
enum fork_event
{
fork_prepare,
fork_parent,
fork_child
};
inline void notify_fork(boost::asio::io_service::fork_event event);
template <typename Service>
friend Service& use_service(io_service& ios);
template <typename Service>
friend void add_service(io_service& ios, Service* svc);
template <typename Service>
friend bool has_service(io_service& ios);
private:
boost::asio::detail::service_registry* service_registry_;
impl_type& impl_;
};
class io_service::work
{
public:
explicit work(boost::asio::io_service& io_service);
work(const work& other);
~work();
boost::asio::io_service& get_io_service();
private:
void operator=(const work& other);
detail::io_service_impl& io_service_impl_;
};
class io_service::id
: private noncopyable
{
public:
id() ;
};
class io_service::service
: private noncopyable
{
public:
boost::asio::io_service& get_io_service();
protected:
inline service(boost::asio::io_service& owner);
inline virtual ~service();
private:
virtual void shutdown_service() = 0;
inline virtual void fork_service(
boost::asio::io_service::fork_event event);
friend class boost::asio::detail::service_registry;
struct key
{
key() ;
const std::type_info* type_info_;
const boost::asio::io_service::id* id_;
} key_;
boost::asio::io_service& owner_;
service* next_;
};
class service_already_exists
: public std::logic_error
{
public:
inline service_already_exists();
};
class invalid_service_owner
: public std::logic_error
{
public:
inline invalid_service_owner();
};
namespace detail {
template <typename Type>
class service_id
: public boost::asio::io_service::id
{
};
template <typename Type>
class service_base
: public boost::asio::io_service::service
{
public:
static boost::asio::detail::service_id<Type> id;
service_base(boost::asio::io_service& io_service)
;
};
template <typename Type>
boost::asio::detail::service_id<Type> service_base<Type>::id;
}
}
}
#define BOOST_ASIO_IMPL_IO_SERVICE_HPP
#define BOOST_ASIO_DETAIL_HANDLER_TYPE_REQUIREMENTS_HPP
#define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS 1
#define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1
#define BOOST_ASIO_UNUSED_TYPEDEF __attribute__((__unused__))
namespace boost {
namespace asio {
namespace detail {
template <typename Handler>
auto zero_arg_handler_test(Handler h, void*)
-> decltype(
sizeof(Handler(static_cast<const Handler&>(h))),
((h)()),
char(0));
template <typename Handler>
char (&zero_arg_handler_test(Handler, ...))[2];
template <typename Handler, typename Arg1>
auto one_arg_handler_test(Handler h, Arg1* a1)
-> decltype(
sizeof(Handler(static_cast<const Handler&>(h))),
((h)(*a1)),
char(0));
template <typename Handler>
char (&one_arg_handler_test(Handler h, ...))[2];
template <typename Handler, typename Arg1, typename Arg2>
auto two_arg_handler_test(Handler h, Arg1* a1, Arg2* a2)
-> decltype(
sizeof(Handler(static_cast<const Handler&>(h))),
((h)(*a1, *a2)),
char(0));
template <typename Handler>
char (&two_arg_handler_test(Handler, ...))[2];
#define BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT(expr,msg) static_assert(expr, msg);
template <typename T> T& lvref();
template <typename T> T& lvref(T);
template <typename T> const T& clvref();
template <typename T> const T& clvref(T);
template <typename T> char argbyv(T);
template <int>
struct handler_type_requirements
{
};
#define BOOST_ASIO_COMPLETION_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void()) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::zero_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), 0)) == 1, "CompletionHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()(), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_READ_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code, std::size_t)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_WRITE_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code, std::size_t)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_ACCEPT_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "AcceptHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_CONNECT_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "ConnectHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK(handler_type,handler,iter_type) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code, iter_type)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const iter_type*>(0))) == 1, "ComposedConnectHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const iter_type>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_RESOLVE_HANDLER_CHECK(handler_type,handler,iter_type) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code, iter_type)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const iter_type*>(0))) == 1, "ResolveHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const iter_type>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_WAIT_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "WaitHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_SIGNAL_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code, int)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const int*>(0))) == 1, "SignalHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const int>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_HANDSHAKE_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "HandshakeHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_BUFFERED_HANDSHAKE_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code, std::size_t)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "BufferedHandshakeHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_SHUTDOWN_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "ShutdownHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
}
}
}
#define BOOST_ASIO_DETAIL_SERVICE_REGISTRY_HPP
#define BOOST_ASIO_DETAIL_MUTEX_HPP
#define BOOST_ASIO_DETAIL_POSIX_MUTEX_HPP
#define BOOST_ASIO_DETAIL_SCOPED_LOCK_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Mutex>
class scoped_lock
: private noncopyable
{
public:
enum adopt_lock_t { adopt_lock };
scoped_lock(Mutex& m, adopt_lock_t)
;
explicit scoped_lock(Mutex& m)
;
~scoped_lock()
;
void lock()
;
void unlock()
;
bool locked() const
;
Mutex& mutex()
;
private:
Mutex& mutex_;
bool locked_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
class posix_event;
class posix_mutex
: private noncopyable
{
public:
typedef boost::asio::detail::scoped_lock<posix_mutex> scoped_lock;
inline posix_mutex();
~posix_mutex()
;
void lock()
;
void unlock()
;
private:
friend class posix_event;
::pthread_mutex_t mutex_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_POSIX_MUTEX_IPP
namespace boost {
namespace asio {
namespace detail {
}
}
}
namespace boost {
namespace asio {
namespace detail {
typedef posix_mutex mutex;
}
}
}
namespace boost {
namespace asio {
namespace detail {
#pragma GCC visibility push (default)
template <typename T>
class typeid_wrapper {};
#pragma GCC visibility pop
class service_registry
: private noncopyable
{
public:
template <typename Service, typename Arg>
service_registry(boost::asio::io_service& o,
Service* initial_service, Arg arg);
inline ~service_registry();
inline void notify_fork(boost::asio::io_service::fork_event fork_ev);
template <typename Service>
Service& first_service();
template <typename Service>
Service& use_service();
template <typename Service>
void add_service(Service* new_service);
template <typename Service>
bool has_service() const;
private:
inline static void init_key(
boost::asio::io_service::service::key& key,
const boost::asio::io_service::id& id);
template <typename Service>
static void init_key(boost::asio::io_service::service::key& key,
const boost::asio::detail::service_id<Service>& );
inline static bool keys_match(
const boost::asio::io_service::service::key& key1,
const boost::asio::io_service::service::key& key2);
typedef boost::asio::io_service::service*
(*factory_type)(boost::asio::io_service&);
template <typename Service>
static boost::asio::io_service::service* create(
boost::asio::io_service& owner);
inline static void destroy(
boost::asio::io_service::service* service);
struct auto_service_ptr;
friend struct auto_service_ptr;
struct auto_service_ptr
{
boost::asio::io_service::service* ptr_;
~auto_service_ptr() ;
};
inline boost::asio::io_service::service* do_use_service(
const boost::asio::io_service::service::key& key,
factory_type factory);
inline void do_add_service(
const boost::asio::io_service::service::key& key,
boost::asio::io_service::service* new_service);
inline bool do_has_service(
const boost::asio::io_service::service::key& key) const;
mutable boost::asio::detail::mutex mutex_;
boost::asio::io_service& owner_;
boost::asio::io_service::service* first_service_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_SERVICE_REGISTRY_HPP
namespace boost {
namespace asio {
namespace detail {
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_SERVICE_REGISTRY_IPP
#define _GLIBCXX_VECTOR 1
#define _STL_VECTOR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp, typename _Alloc>
struct _Vector_base
{
typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
rebind<_Tp>::other _Tp_alloc_type;
typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer
pointer;
struct _Vector_impl
: public _Tp_alloc_type
{
pointer _M_start;
pointer _M_finish;
pointer _M_end_of_storage;
_Vector_impl()
;
_Vector_impl(_Tp_alloc_type const& __a) noexcept
: _Tp_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage()
{ }
_Vector_impl(_Tp_alloc_type&& __a) noexcept
: _Tp_alloc_type(std::move(__a)),
_M_start(), _M_finish(), _M_end_of_storage()
{ }
void _M_swap_data(_Vector_impl& __x) noexcept
{
std::swap(_M_start, __x._M_start);
std::swap(_M_finish, __x._M_finish);
std::swap(_M_end_of_storage, __x._M_end_of_storage);
}
};
public:
typedef _Alloc allocator_type;
_Tp_alloc_type&
_M_get_Tp_allocator() noexcept
{ return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
const _Tp_alloc_type&
_M_get_Tp_allocator() const noexcept
{ return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
allocator_type
get_allocator() const noexcept
{ return allocator_type(_M_get_Tp_allocator()); }
_Vector_base()
: _M_impl() { }
_Vector_base(const allocator_type& __a) noexcept
: _M_impl(__a) { }
_Vector_base(size_t __n)
: _M_impl()
{ _M_create_storage(__n); }
_Vector_base(size_t __n, const allocator_type& __a)
: _M_impl(__a)
{ _M_create_storage(__n); }
_Vector_base(_Tp_alloc_type&& __a) noexcept
: _M_impl(std::move(__a)) { }
_Vector_base(_Vector_base&& __x) noexcept
: _M_impl(std::move(__x._M_get_Tp_allocator()))
{ this->_M_impl._M_swap_data(__x._M_impl); }
_Vector_base(_Vector_base&& __x, const allocator_type& __a)
: _M_impl(__a)
{
if (__x.get_allocator() == __a)
this->_M_impl._M_swap_data(__x._M_impl);
else
{
size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start;
_M_create_storage(__n);
}
}
~_Vector_base() noexcept
{ _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage
- this->_M_impl._M_start); }
public:
_Vector_impl _M_impl;
pointer
_M_allocate(size_t __n)
;
void
_M_deallocate(pointer __p, size_t __n)
;
private:
void
_M_create_storage(size_t __n)
;
};
template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
class vector : protected _Vector_base<_Tp, _Alloc>
{
typedef typename _Alloc::value_type _Alloc_value_type;
typedef _Vector_base<_Tp, _Alloc> _Base;
typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;
public:
typedef _Tp value_type;
typedef typename _Base::pointer pointer;
typedef typename _Alloc_traits::const_pointer const_pointer;
typedef typename _Alloc_traits::reference reference;
typedef typename _Alloc_traits::const_reference const_reference;
typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
const_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef _Alloc allocator_type;
protected:
using _Base::_M_allocate;
using _Base::_M_deallocate;
using _Base::_M_impl;
using _Base::_M_get_Tp_allocator;
public:
vector()
noexcept(is_nothrow_default_constructible<_Alloc>::value)
: _Base() { }
explicit
vector(const allocator_type& __a) noexcept
: _Base(__a) { }
explicit
vector(size_type __n, const allocator_type& __a = allocator_type())
: _Base(__n, __a)
{ _M_default_initialize(__n); }
vector(size_type __n, const value_type& __value,
const allocator_type& __a = allocator_type())
: _Base(__n, __a)
{ _M_fill_initialize(__n, __value); }
vector(const vector& __x)
: _Base(__x.size(),
_Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
{ this->_M_impl._M_finish =
std::__uninitialized_copy_a(__x.begin(), __x.end(),
this->_M_impl._M_start,
_M_get_Tp_allocator());
}
vector(vector&& __x) noexcept
: _Base(std::move(__x)) { }
vector(const vector& __x, const allocator_type& __a)
: _Base(__x.size(), __a)
{ this->_M_impl._M_finish =
std::__uninitialized_copy_a(__x.begin(), __x.end(),
this->_M_impl._M_start,
_M_get_Tp_allocator());
}
vector(vector&& __rv, const allocator_type& __m)
noexcept(_Alloc_traits::_S_always_equal())
: _Base(std::move(__rv), __m)
{
if (__rv.get_allocator() != __m)
{
this->_M_impl._M_finish =
std::__uninitialized_move_a(__rv.begin(), __rv.end(),
this->_M_impl._M_start,
_M_get_Tp_allocator());
__rv.clear();
}
}
vector(initializer_list<value_type> __l,
const allocator_type& __a = allocator_type())
: _Base(__a)
{
_M_range_initialize(__l.begin(), __l.end(),
random_access_iterator_tag());
}
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
vector(_InputIterator __first, _InputIterator __last,
const allocator_type& __a = allocator_type())
: _Base(__a)
{ _M_initialize_dispatch(__first, __last, __false_type()); }
~vector() noexcept
{ std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator()); }
vector&
operator=(const vector& __x);
vector&
operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
{
constexpr bool __move_storage =
_Alloc_traits::_S_propagate_on_move_assign()
|| _Alloc_traits::_S_always_equal();
_M_move_assign(std::move(__x),
integral_constant<bool, __move_storage>());
return *this;
}
vector&
operator=(initializer_list<value_type> __l)
{
this->assign(__l.begin(), __l.end());
return *this;
}
void
assign(size_type __n, const value_type& __val)
{ _M_fill_assign(__n, __val); }
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
void
assign(_InputIterator __first, _InputIterator __last)
{ _M_assign_dispatch(__first, __last, __false_type()); }
void
assign(initializer_list<value_type> __l)
{ this->assign(__l.begin(), __l.end()); }
using _Base::get_allocator;
iterator
begin() noexcept
{ return iterator(this->_M_impl._M_start); }
const_iterator
begin() const noexcept
{ return const_iterator(this->_M_impl._M_start); }
iterator
end() noexcept
{ return iterator(this->_M_impl._M_finish); }
const_iterator
end() const noexcept
{ return const_iterator(this->_M_impl._M_finish); }
reverse_iterator
rbegin() noexcept
{ return reverse_iterator(end()); }
const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(end()); }
reverse_iterator
rend() noexcept
{ return reverse_iterator(begin()); }
const_reverse_iterator
rend() const noexcept
{ return const_reverse_iterator(begin()); }
const_iterator
cbegin() const noexcept
{ return const_iterator(this->_M_impl._M_start); }
const_iterator
cend() const noexcept
{ return const_iterator(this->_M_impl._M_finish); }
const_reverse_iterator
crbegin() const noexcept
{ return const_reverse_iterator(end()); }
const_reverse_iterator
crend() const noexcept
{ return const_reverse_iterator(begin()); }
size_type
size() const noexcept
{ return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
size_type
max_size() const noexcept
{ return _Alloc_traits::max_size(_M_get_Tp_allocator()); }
void
resize(size_type __new_size)
{
if (__new_size > size())
_M_default_append(__new_size - size());
else if (__new_size < size())
_M_erase_at_end(this->_M_impl._M_start + __new_size);
}
void
resize(size_type __new_size, const value_type& __x)
{
if (__new_size > size())
insert(end(), __new_size - size(), __x);
else if (__new_size < size())
_M_erase_at_end(this->_M_impl._M_start + __new_size);
}
void
shrink_to_fit()
{ _M_shrink_to_fit(); }
size_type
capacity() const noexcept
{ return size_type(this->_M_impl._M_end_of_storage
- this->_M_impl._M_start); }
bool
empty() const noexcept
{ return begin() == end(); }
void
reserve(size_type __n);
reference
operator[](size_type __n) noexcept
{ return *(this->_M_impl._M_start + __n); }
const_reference
operator[](size_type __n) const noexcept
{ return *(this->_M_impl._M_start + __n); }
protected:
void
_M_range_check(size_type __n) const
{
if (__n >= this->size())
__throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"),
__n, this->size());
}
public:
reference
at(size_type __n)
{
_M_range_check(__n);
return (*this)[__n];
}
const_reference
at(size_type __n) const
{
_M_range_check(__n);
return (*this)[__n];
}
reference
front() noexcept
{ return *begin(); }
const_reference
front() const noexcept
{ return *begin(); }
reference
back() noexcept
{ return *(end() - 1); }
const_reference
back() const noexcept
{ return *(end() - 1); }
_Tp*
data() noexcept
{ return _M_data_ptr(this->_M_impl._M_start); }
const _Tp*
data() const noexcept
{ return _M_data_ptr(this->_M_impl._M_start); }
void
push_back(const value_type& __x)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
__x);
++this->_M_impl._M_finish;
}
else
_M_emplace_back_aux(__x);
}
void
push_back(value_type&& __x)
{ emplace_back(std::move(__x)); }
template<typename... _Args>
void
emplace_back(_Args&&... __args);
void
pop_back() noexcept
{
--this->_M_impl._M_finish;
_Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
}
template<typename... _Args>
iterator
emplace(const_iterator __position, _Args&&... __args);
iterator
insert(const_iterator __position, const value_type& __x);
iterator
insert(const_iterator __position, value_type&& __x)
;
iterator
insert(const_iterator __position, initializer_list<value_type> __l)
;
iterator
insert(const_iterator __position, size_type __n, const value_type& __x)
;
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
iterator
insert(const_iterator __position, _InputIterator __first,
_InputIterator __last)
;
iterator
erase(const_iterator __position)
;
iterator
erase(const_iterator __first, const_iterator __last)
;
void
swap(vector& __x)
noexcept(_Alloc_traits::_S_nothrow_swap())
{
this->_M_impl._M_swap_data(__x._M_impl);
_Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
__x._M_get_Tp_allocator());
}
void
clear() noexcept
{ _M_erase_at_end(this->_M_impl._M_start); }
protected:
template<typename _ForwardIterator>
pointer
_M_allocate_and_copy(size_type __n,
_ForwardIterator __first, _ForwardIterator __last)
{
pointer __result = this->_M_allocate(__n);
try
{
std::__uninitialized_copy_a(__first, __last, __result,
_M_get_Tp_allocator());
return __result;
}
catch(...)
{
_M_deallocate(__result, __n);
throw;
}
}
template<typename _Integer>
void
_M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
{
this->_M_impl._M_start = _M_allocate(static_cast<size_type>(__n));
this->_M_impl._M_end_of_storage =
this->_M_impl._M_start + static_cast<size_type>(__n);
_M_fill_initialize(static_cast<size_type>(__n), __value);
}
template<typename _InputIterator>
void
_M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
{
typedef typename std::iterator_traits<_InputIterator>::
iterator_category _IterCategory;
_M_range_initialize(__first, __last, _IterCategory());
}
template<typename _InputIterator>
void
_M_range_initialize(_InputIterator __first,
_InputIterator __last, std::input_iterator_tag)
{
for (; __first != __last; ++__first)
emplace_back(*__first);
}
template<typename _ForwardIterator>
void
_M_range_initialize(_ForwardIterator __first,
_ForwardIterator __last, std::forward_iterator_tag)
{
const size_type __n = std::distance(__first, __last);
this->_M_impl._M_start = this->_M_allocate(__n);
this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
this->_M_impl._M_finish =
std::__uninitialized_copy_a(__first, __last,
this->_M_impl._M_start,
_M_get_Tp_allocator());
}
void
_M_fill_initialize(size_type __n, const value_type& __value)
{
this->_M_impl._M_finish =
std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
_M_get_Tp_allocator());
}
void
_M_default_initialize(size_type __n)
{
this->_M_impl._M_finish =
std::__uninitialized_default_n_a(this->_M_impl._M_start, __n,
_M_get_Tp_allocator());
}
template<typename _Integer>
void
_M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
{ _M_fill_assign(__n, __val); }
template<typename _InputIterator>
void
_M_assign_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
{
typedef typename std::iterator_traits<_InputIterator>::
iterator_category _IterCategory;
_M_assign_aux(__first, __last, _IterCategory());
}
template<typename _InputIterator>
void
_M_assign_aux(_InputIterator __first, _InputIterator __last,
std::input_iterator_tag);
template<typename _ForwardIterator>
void
_M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
std::forward_iterator_tag);
void
_M_fill_assign(size_type __n, const value_type& __val);
template<typename _Integer>
void
_M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
__true_type)
;
template<typename _InputIterator>
void
_M_insert_dispatch(iterator __pos, _InputIterator __first,
_InputIterator __last, __false_type)
;
template<typename _InputIterator>
void
_M_range_insert(iterator __pos, _InputIterator __first,
_InputIterator __last, std::input_iterator_tag);
template<typename _ForwardIterator>
void
_M_range_insert(iterator __pos, _ForwardIterator __first,
_ForwardIterator __last, std::forward_iterator_tag);
void
_M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
void
_M_default_append(size_type __n);
bool
_M_shrink_to_fit();
template<typename... _Args>
void
_M_insert_aux(iterator __position, _Args&&... __args);
template<typename... _Args>
void
_M_emplace_back_aux(_Args&&... __args);
size_type
_M_check_len(size_type __n, const char* __s) const
;
void
_M_erase_at_end(pointer __pos) noexcept
{
std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator());
this->_M_impl._M_finish = __pos;
}
iterator
_M_erase(iterator __position);
iterator
_M_erase(iterator __first, iterator __last);
private:
void
_M_move_assign(vector&& __x, std::true_type) noexcept
{
vector __tmp(get_allocator());
this->_M_impl._M_swap_data(__tmp._M_impl);
this->_M_impl._M_swap_data(__x._M_impl);
std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
}
void
_M_move_assign(vector&& __x, std::false_type)
{
if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
_M_move_assign(std::move(__x), std::true_type());
else
{
this->assign(std::__make_move_if_noexcept_iterator(__x.begin()),
std::__make_move_if_noexcept_iterator(__x.end()));
__x.clear();
}
}
template<typename _Up>
_Up*
_M_data_ptr(_Up* __ptr) const
{ return __ptr; }
template<typename _Ptr>
typename std::pointer_traits<_Ptr>::element_type*
_M_data_ptr(_Ptr __ptr) const
{ return empty() ? nullptr : std::__addressof(*__ptr); }
};
template<typename _Tp, typename _Alloc>
bool
operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
;
template<typename _Tp, typename _Alloc>
bool
operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
;
template<typename _Tp, typename _Alloc>
bool
operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
;
template<typename _Tp, typename _Alloc>
bool
operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
;
template<typename _Tp, typename _Alloc>
bool
operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
;
template<typename _Tp, typename _Alloc>
bool
operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
;
template<typename _Tp, typename _Alloc>
inline void
swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
{ __x.swap(__y); }
}
#define _STL_BVECTOR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
typedef unsigned long _Bit_type;
enum { _S_word_bit = int(8 * sizeof(_Bit_type)) };
struct _Bit_reference
{
_Bit_type * _M_p;
_Bit_type _M_mask;
_Bit_reference(_Bit_type * __x, _Bit_type __y)
: _M_p(__x), _M_mask(__y) { }
_Bit_reference() noexcept : _M_p(0), _M_mask(0) { }
operator bool() const noexcept
{ return !!(*_M_p & _M_mask); }
_Bit_reference&
operator=(bool __x) noexcept
{
if (__x)
*_M_p |= _M_mask;
else
*_M_p &= ~_M_mask;
return *this;
}
_Bit_reference&
operator=(const _Bit_reference& __x) noexcept
{ return *this = bool(__x); }
bool
operator==(const _Bit_reference& __x) const
{ return bool(*this) == bool(__x); }
bool
operator<(const _Bit_reference& __x) const
{ return !bool(*this) && bool(__x); }
void
flip() noexcept
{ *_M_p ^= _M_mask; }
};
inline void
swap(_Bit_reference __x, _Bit_reference __y) noexcept
{
bool __tmp = __x;
__x = __y;
__y = __tmp;
}
inline void
swap(_Bit_reference __x, bool& __y) noexcept
{
bool __tmp = __x;
__x = __y;
__y = __tmp;
}
inline void
swap(bool& __x, _Bit_reference __y) noexcept
{
bool __tmp = __x;
__x = __y;
__y = __tmp;
}
struct _Bit_iterator_base
: public std::iterator<std::random_access_iterator_tag, bool>
{
_Bit_type * _M_p;
unsigned int _M_offset;
_Bit_iterator_base(_Bit_type * __x, unsigned int __y)
: _M_p(__x), _M_offset(__y) { }
void
_M_bump_up()
{
if (_M_offset++ == int(_S_word_bit) - 1)
{
_M_offset = 0;
++_M_p;
}
}
void
_M_bump_down()
{
if (_M_offset-- == 0)
{
_M_offset = int(_S_word_bit) - 1;
--_M_p;
}
}
void
_M_incr(ptrdiff_t __i)
{
difference_type __n = __i + _M_offset;
_M_p += __n / int(_S_word_bit);
__n = __n % int(_S_word_bit);
if (__n < 0)
{
__n += int(_S_word_bit);
--_M_p;
}
_M_offset = static_cast<unsigned int>(__n);
}
bool
operator==(const _Bit_iterator_base& __i) const
{ return _M_p == __i._M_p && _M_offset == __i._M_offset; }
bool
operator<(const _Bit_iterator_base& __i) const
{
return _M_p < __i._M_p
|| (_M_p == __i._M_p && _M_offset < __i._M_offset);
}
bool
operator!=(const _Bit_iterator_base& __i) const
{ return !(*this == __i); }
bool
operator>(const _Bit_iterator_base& __i) const
{ return __i < *this; }
bool
operator<=(const _Bit_iterator_base& __i) const
{ return !(__i < *this); }
bool
operator>=(const _Bit_iterator_base& __i) const
{ return !(*this < __i); }
};
inline ptrdiff_t
operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
{
return (int(_S_word_bit) * (__x._M_p - __y._M_p)
+ __x._M_offset - __y._M_offset);
}
struct _Bit_iterator : public _Bit_iterator_base
{
typedef _Bit_reference reference;
typedef _Bit_reference* pointer;
typedef _Bit_iterator iterator;
_Bit_iterator() : _Bit_iterator_base(0, 0) { }
_Bit_iterator(_Bit_type * __x, unsigned int __y)
: _Bit_iterator_base(__x, __y) { }
iterator
_M_const_cast() const
{ return *this; }
reference
operator*() const
{ return reference(_M_p, 1UL << _M_offset); }
iterator&
operator++()
{
_M_bump_up();
return *this;
}
iterator
operator++(int)
{
iterator __tmp = *this;
_M_bump_up();
return __tmp;
}
iterator&
operator--()
{
_M_bump_down();
return *this;
}
iterator
operator--(int)
{
iterator __tmp = *this;
_M_bump_down();
return __tmp;
}
iterator&
operator+=(difference_type __i)
{
_M_incr(__i);
return *this;
}
iterator&
operator-=(difference_type __i)
{
*this += -__i;
return *this;
}
iterator
operator+(difference_type __i) const
{
iterator __tmp = *this;
return __tmp += __i;
}
iterator
operator-(difference_type __i) const
{
iterator __tmp = *this;
return __tmp -= __i;
}
reference
operator[](difference_type __i) const
{ return *(*this + __i); }
};
inline _Bit_iterator
operator+(ptrdiff_t __n, const _Bit_iterator& __x)
{ return __x + __n; }
struct _Bit_const_iterator : public _Bit_iterator_base
{
typedef bool reference;
typedef bool const_reference;
typedef const bool* pointer;
typedef _Bit_const_iterator const_iterator;
_Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
_Bit_const_iterator(_Bit_type * __x, unsigned int __y)
: _Bit_iterator_base(__x, __y) { }
_Bit_const_iterator(const _Bit_iterator& __x)
: _Bit_iterator_base(__x._M_p, __x._M_offset) { }
_Bit_iterator
_M_const_cast() const
{ return _Bit_iterator(_M_p, _M_offset); }
const_reference
operator*() const
;
const_iterator&
operator++()
;
const_iterator
operator++(int)
;
const_iterator&
operator--()
;
const_iterator
operator--(int)
;
const_iterator&
operator+=(difference_type __i)
;
const_iterator&
operator-=(difference_type __i)
;
const_iterator
operator+(difference_type __i) const
;
const_iterator
operator-(difference_type __i) const
;
const_reference
operator[](difference_type __i) const
;
};
_Bit_const_iterator
operator+(ptrdiff_t __n, const _Bit_const_iterator& __x)
;
void
__fill_bvector(_Bit_iterator __first, _Bit_iterator __last, bool __x)
;
void
fill(_Bit_iterator __first, _Bit_iterator __last, const bool& __x)
;
template<typename _Alloc>
struct _Bvector_base
{
typedef typename _Alloc::template rebind<_Bit_type>::other
_Bit_alloc_type;
struct _Bvector_impl
: public _Bit_alloc_type
{
_Bit_iterator _M_start;
_Bit_iterator _M_finish;
_Bit_type* _M_end_of_storage;
_Bvector_impl()
;
_Bvector_impl(const _Bit_alloc_type& __a)
;
_Bvector_impl(_Bit_alloc_type&& __a)
;
};
public:
typedef _Alloc allocator_type;
_Bit_alloc_type&
_M_get_Bit_allocator() noexcept
{ return *static_cast<_Bit_alloc_type*>(&this->_M_impl); }
const _Bit_alloc_type&
_M_get_Bit_allocator() const noexcept
{ return *static_cast<const _Bit_alloc_type*>(&this->_M_impl); }
allocator_type
get_allocator() const noexcept
{ return allocator_type(_M_get_Bit_allocator()); }
_Bvector_base()
: _M_impl() { }
_Bvector_base(const allocator_type& __a)
: _M_impl(__a) { }
_Bvector_base(_Bvector_base&& __x) noexcept
: _M_impl(std::move(__x._M_get_Bit_allocator()))
{
this->_M_impl._M_start = __x._M_impl._M_start;
this->_M_impl._M_finish = __x._M_impl._M_finish;
this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage;
__x._M_impl._M_start = _Bit_iterator();
__x._M_impl._M_finish = _Bit_iterator();
__x._M_impl._M_end_of_storage = 0;
}
~_Bvector_base()
{ this->_M_deallocate(); }
protected:
_Bvector_impl _M_impl;
_Bit_type*
_M_allocate(size_t __n)
;
void
_M_deallocate()
;
static size_t
_S_nword(size_t __n)
;
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc>
class vector<bool, _Alloc> : protected _Bvector_base<_Alloc>
{
typedef _Bvector_base<_Alloc> _Base;
template<typename> friend struct hash;
public:
typedef bool value_type;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef _Bit_reference reference;
typedef bool const_reference;
typedef _Bit_reference* pointer;
typedef const bool* const_pointer;
typedef _Bit_iterator iterator;
typedef _Bit_const_iterator const_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef _Alloc allocator_type;
allocator_type get_allocator() const
;
protected:
using _Base::_M_allocate;
using _Base::_M_deallocate;
using _Base::_S_nword;
using _Base::_M_get_Bit_allocator;
public:
vector() ;
explicit
vector(const allocator_type& __a) ;
explicit
vector(size_type __n, const allocator_type& __a = allocator_type())
;
vector(size_type __n, const bool& __value,
const allocator_type& __a = allocator_type())
;
vector(const vector& __x)
;
vector(vector&& __x) noexcept
: _Base(std::move(__x)) { }
vector(initializer_list<bool> __l,
const allocator_type& __a = allocator_type())
: _Base(__a)
{
_M_initialize_range(__l.begin(), __l.end(),
random_access_iterator_tag());
}
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
vector(_InputIterator __first, _InputIterator __last,
const allocator_type& __a = allocator_type())
: _Base(__a)
{ _M_initialize_dispatch(__first, __last, __false_type()); }
~vector() noexcept { }
vector&
operator=(const vector& __x)
{
if (&__x == this)
return *this;
if (__x.size() > capacity())
{
this->_M_deallocate();
_M_initialize(__x.size());
}
this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
begin());
return *this;
}
vector&
operator=(vector&& __x)
{
this->clear();
this->swap(__x);
return *this;
}
vector&
operator=(initializer_list<bool> __l)
{
this->assign (__l.begin(), __l.end());
return *this;
}
void
assign(size_type __n, const bool& __x)
{ _M_fill_assign(__n, __x); }
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
void
assign(_InputIterator __first, _InputIterator __last)
{ _M_assign_dispatch(__first, __last, __false_type()); }
void
assign(initializer_list<bool> __l)
{ this->assign(__l.begin(), __l.end()); }
iterator
begin() noexcept
{ return this->_M_impl._M_start; }
const_iterator
begin() const noexcept
{ return this->_M_impl._M_start; }
iterator
end() noexcept
{ return this->_M_impl._M_finish; }
const_iterator
end() const noexcept
{ return this->_M_impl._M_finish; }
reverse_iterator
rbegin() noexcept
{ return reverse_iterator(end()); }
const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(end()); }
reverse_iterator
rend() noexcept
{ return reverse_iterator(begin()); }
const_reverse_iterator
rend() const noexcept
{ return const_reverse_iterator(begin()); }
const_iterator
cbegin() const noexcept
{ return this->_M_impl._M_start; }
const_iterator
cend() const noexcept
{ return this->_M_impl._M_finish; }
const_reverse_iterator
crbegin() const noexcept
{ return const_reverse_iterator(end()); }
const_reverse_iterator
crend() const noexcept
{ return const_reverse_iterator(begin()); }
size_type
size() const noexcept
{ return size_type(end() - begin()); }
size_type
max_size() const noexcept
{
const size_type __isize =
__gnu_cxx::__numeric_traits<difference_type>::__max
- int(_S_word_bit) + 1;
const size_type __asize = _M_get_Bit_allocator().max_size();
return (__asize <= __isize / int(_S_word_bit)
? __asize * int(_S_word_bit) : __isize);
}
size_type
capacity() const noexcept
{ return size_type(const_iterator(this->_M_impl._M_end_of_storage, 0)
- begin()); }
bool
empty() const noexcept
{ return begin() == end(); }
reference
operator[](size_type __n)
{
return *iterator(this->_M_impl._M_start._M_p
+ __n / int(_S_word_bit), __n % int(_S_word_bit));
}
const_reference
operator[](size_type __n) const
{
return *const_iterator(this->_M_impl._M_start._M_p
+ __n / int(_S_word_bit), __n % int(_S_word_bit));
}
protected:
void
_M_range_check(size_type __n) const
{
if (__n >= this->size())
__throw_out_of_range_fmt(("vector<bool>::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"),
__n, this->size());
}
public:
reference
at(size_type __n)
{ _M_range_check(__n); return (*this)[__n]; }
const_reference
at(size_type __n) const
{ _M_range_check(__n); return (*this)[__n]; }
void
reserve(size_type __n)
{
if (__n > max_size())
__throw_length_error(("vector::reserve"));
if (capacity() < __n)
_M_reallocate(__n);
}
reference
front()
{ return *begin(); }
const_reference
front() const
{ return *begin(); }
reference
back()
{ return *(end() - 1); }
const_reference
back() const
{ return *(end() - 1); }
void
data() noexcept { }
void
push_back(bool __x)
{
if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
*this->_M_impl._M_finish++ = __x;
else
_M_insert_aux(end(), __x);
}
void
swap(vector& __x)
{
std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
std::swap(this->_M_impl._M_end_of_storage,
__x._M_impl._M_end_of_storage);
std::__alloc_swap<typename _Base::_Bit_alloc_type>::
_S_do_it(_M_get_Bit_allocator(), __x._M_get_Bit_allocator());
}
static void
swap(reference __x, reference __y) noexcept
{
bool __tmp = __x;
__x = __y;
__y = __tmp;
}
iterator
insert(const_iterator __position, const bool& __x = bool())
{
const difference_type __n = __position - begin();
if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage
&& __position == end())
*this->_M_impl._M_finish++ = __x;
else
_M_insert_aux(__position._M_const_cast(), __x);
return begin() + __n;
}
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
iterator
insert(const_iterator __position,
_InputIterator __first, _InputIterator __last)
{
difference_type __offset = __position - cbegin();
_M_insert_dispatch(__position._M_const_cast(),
__first, __last, __false_type());
return begin() + __offset;
}
iterator
insert(const_iterator __position, size_type __n, const bool& __x)
{
difference_type __offset = __position - cbegin();
_M_fill_insert(__position._M_const_cast(), __n, __x);
return begin() + __offset;
}
iterator
insert(const_iterator __p, initializer_list<bool> __l)
{ return this->insert(__p, __l.begin(), __l.end()); }
void
pop_back()
{ --this->_M_impl._M_finish; }
iterator
erase(const_iterator __position)
{ return _M_erase(__position._M_const_cast()); }
iterator
erase(const_iterator __first, const_iterator __last)
{ return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
void
resize(size_type __new_size, bool __x = bool())
{
if (__new_size < size())
_M_erase_at_end(begin() + difference_type(__new_size));
else
insert(end(), __new_size - size(), __x);
}
void
shrink_to_fit()
{ _M_shrink_to_fit(); }
void
flip() noexcept
{
for (_Bit_type * __p = this->_M_impl._M_start._M_p;
__p != this->_M_impl._M_end_of_storage; ++__p)
*__p = ~*__p;
}
void
clear() noexcept
{ _M_erase_at_end(begin()); }
template<typename... _Args>
void
emplace_back(_Args&&... __args)
{ push_back(bool(__args...)); }
template<typename... _Args>
iterator
emplace(const_iterator __pos, _Args&&... __args)
{ return insert(__pos, bool(__args...)); }
protected:
iterator
_M_copy_aligned(const_iterator __first, const_iterator __last,
iterator __result)
{
_Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
return std::copy(const_iterator(__last._M_p, 0), __last,
iterator(__q, 0));
}
void
_M_initialize(size_type __n)
{
_Bit_type* __q = this->_M_allocate(__n);
this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
this->_M_impl._M_start = iterator(__q, 0);
this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
}
void
_M_reallocate(size_type __n);
bool
_M_shrink_to_fit();
template<typename _Integer>
void
_M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
;
template<typename _InputIterator>
void
_M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
;
template<typename _InputIterator>
void
_M_initialize_range(_InputIterator __first, _InputIterator __last,
std::input_iterator_tag)
;
template<typename _ForwardIterator>
void
_M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
std::forward_iterator_tag)
;
template<typename _Integer>
void
_M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
;
template<class _InputIterator>
void
_M_assign_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
;
void
_M_fill_assign(size_t __n, bool __x)
;
template<typename _InputIterator>
void
_M_assign_aux(_InputIterator __first, _InputIterator __last,
std::input_iterator_tag)
;
template<typename _ForwardIterator>
void
_M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
std::forward_iterator_tag)
;
template<typename _Integer>
void
_M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
__true_type)
;
template<typename _InputIterator>
void
_M_insert_dispatch(iterator __pos,
_InputIterator __first, _InputIterator __last,
__false_type)
;
void
_M_fill_insert(iterator __position, size_type __n, bool __x);
template<typename _InputIterator>
void
_M_insert_range(iterator __pos, _InputIterator __first,
_InputIterator __last, std::input_iterator_tag)
;
template<typename _ForwardIterator>
void
_M_insert_range(iterator __position, _ForwardIterator __first,
_ForwardIterator __last, std::forward_iterator_tag);
void
_M_insert_aux(iterator __position, bool __x);
size_type
_M_check_len(size_type __n, const char* __s) const
;
void
_M_erase_at_end(iterator __pos)
;
iterator
_M_erase(iterator __pos);
iterator
_M_erase(iterator __first, iterator __last);
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc>
struct hash<std::vector<bool, _Alloc>>
: public __hash_base<size_t, std::vector<bool, _Alloc>>
{
size_t
operator()(const std::vector<bool, _Alloc>&) const noexcept;
};
}
#define _VECTOR_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc>
size_t
hash<std::vector<bool, _Alloc>>::
operator()(const std::vector<bool, _Alloc>& __b) const noexcept
{
size_t __hash = 0;
using std::_S_word_bit;
using std::_Bit_type;
const size_t __words = __b.size() / _S_word_bit;
if (__words)
{
const size_t __clength = __words * sizeof(_Bit_type);
__hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength);
}
const size_t __extrabits = __b.size() % _S_word_bit;
if (__extrabits)
{
_Bit_type __hiword = *__b._M_impl._M_finish._M_p;
__hiword &= ~((~static_cast<_Bit_type>(0)) << __extrabits);
const size_t __clength
= (__extrabits + 8 - 1) / 8;
if (__words)
__hash = std::_Hash_impl::hash(&__hiword, __clength, __hash);
else
__hash = std::_Hash_impl::hash(&__hiword, __clength);
}
return __hash;
}
}
namespace boost {
namespace asio {
namespace detail {
}
}
}
namespace boost {
namespace asio {
template <typename Service>
Service& use_service(io_service& ios)
;
template <> detail::io_service_impl& use_service<detail::io_service_impl>(
io_service& ios)
;
template <typename Service>
void add_service(io_service& ios, Service* svc)
;
template <typename Service>
bool has_service(io_service& ios)
;
}
}
#define BOOST_ASIO_DETAIL_TASK_IO_SERVICE_HPP
#define BOOST_ASIO_DETAIL_ATOMIC_COUNT_HPP
#define _GLIBCXX_ATOMIC 1
#define _GLIBCXX_ATOMIC_BASE_H 1
#define _STDBOOL_H
#define _Bool bool
#define bool bool
#define false false
#define true true
#define __bool_true_false_are_defined 1
#define _GLIBCXX_ALWAYS_INLINE inline __attribute__((always_inline))
namespace std __attribute__ ((__visibility__ ("default")))
{
typedef enum memory_order
{
memory_order_relaxed,
memory_order_consume,
memory_order_acquire,
memory_order_release,
memory_order_acq_rel,
memory_order_seq_cst
} memory_order;
enum __memory_order_modifier
{
__memory_order_mask = 0x0ffff,
__memory_order_modifier_mask = 0xffff0000,
__memory_order_hle_acquire = 0x10000,
__memory_order_hle_release = 0x20000
};
constexpr memory_order
operator|(memory_order __m, __memory_order_modifier __mod)
{
return memory_order(__m | int(__mod));
}
constexpr memory_order
operator&(memory_order __m, __memory_order_modifier __mod)
{
return memory_order(__m & int(__mod));
}
constexpr memory_order
__cmpexch_failure_order2(memory_order __m) noexcept
{
return __m == memory_order_acq_rel ? memory_order_acquire
: __m == memory_order_release ? memory_order_relaxed : __m;
}
constexpr memory_order
__cmpexch_failure_order(memory_order __m) noexcept
{
return memory_order(__cmpexch_failure_order2(__m & __memory_order_mask)
| (__m & __memory_order_modifier_mask));
}
inline __attribute__((always_inline)) void
atomic_thread_fence(memory_order __m) noexcept
{ __atomic_thread_fence(__m); }
inline __attribute__((always_inline)) void
atomic_signal_fence(memory_order __m) noexcept
{ __atomic_signal_fence(__m); }
template<typename _Tp>
inline _Tp
kill_dependency(_Tp __y) noexcept
{
_Tp __ret(__y);
return __ret;
}
template<typename _IntTp>
struct __atomic_base;
typedef __atomic_base<char> atomic_char;
typedef __atomic_base<signed char> atomic_schar;
typedef __atomic_base<unsigned char> atomic_uchar;
typedef __atomic_base<short> atomic_short;
typedef __atomic_base<unsigned short> atomic_ushort;
typedef __atomic_base<int> atomic_int;
typedef __atomic_base<unsigned int> atomic_uint;
typedef __atomic_base<long> atomic_long;
typedef __atomic_base<unsigned long> atomic_ulong;
typedef __atomic_base<long long> atomic_llong;
typedef __atomic_base<unsigned long long> atomic_ullong;
typedef __atomic_base<wchar_t> atomic_wchar_t;
typedef __atomic_base<char16_t> atomic_char16_t;
typedef __atomic_base<char32_t> atomic_char32_t;
typedef __atomic_base<char32_t> atomic_char32_t;
typedef __atomic_base<int_least8_t> atomic_int_least8_t;
typedef __atomic_base<uint_least8_t> atomic_uint_least8_t;
typedef __atomic_base<int_least16_t> atomic_int_least16_t;
typedef __atomic_base<uint_least16_t> atomic_uint_least16_t;
typedef __atomic_base<int_least32_t> atomic_int_least32_t;
typedef __atomic_base<uint_least32_t> atomic_uint_least32_t;
typedef __atomic_base<int_least64_t> atomic_int_least64_t;
typedef __atomic_base<uint_least64_t> atomic_uint_least64_t;
typedef __atomic_base<int_fast8_t> atomic_int_fast8_t;
typedef __atomic_base<uint_fast8_t> atomic_uint_fast8_t;
typedef __atomic_base<int_fast16_t> atomic_int_fast16_t;
typedef __atomic_base<uint_fast16_t> atomic_uint_fast16_t;
typedef __atomic_base<int_fast32_t> atomic_int_fast32_t;
typedef __atomic_base<uint_fast32_t> atomic_uint_fast32_t;
typedef __atomic_base<int_fast64_t> atomic_int_fast64_t;
typedef __atomic_base<uint_fast64_t> atomic_uint_fast64_t;
typedef __atomic_base<intptr_t> atomic_intptr_t;
typedef __atomic_base<uintptr_t> atomic_uintptr_t;
typedef __atomic_base<size_t> atomic_size_t;
typedef __atomic_base<intmax_t> atomic_intmax_t;
typedef __atomic_base<uintmax_t> atomic_uintmax_t;
typedef __atomic_base<ptrdiff_t> atomic_ptrdiff_t;
#define ATOMIC_VAR_INIT(_VI) { _VI }
template<typename _Tp>
struct atomic;
template<typename _Tp>
struct atomic<_Tp*>;
typedef bool __atomic_flag_data_type;
extern "C" {
struct __atomic_flag_base
{
__atomic_flag_data_type _M_i;
};
}
#define ATOMIC_FLAG_INIT { 0 }
struct atomic_flag : public __atomic_flag_base
{
atomic_flag() noexcept = default;
~atomic_flag() noexcept = default;
atomic_flag(const atomic_flag&) = delete;
atomic_flag& operator=(const atomic_flag&) = delete;
atomic_flag& operator=(const atomic_flag&) volatile = delete;
constexpr atomic_flag(bool __i) noexcept
: __atomic_flag_base{ _S_init(__i) }
{ }
inline __attribute__((always_inline)) bool
test_and_set(memory_order __m = memory_order_seq_cst) noexcept
{
return __atomic_test_and_set (&_M_i, __m);
}
inline __attribute__((always_inline)) bool
test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept
{
return __atomic_test_and_set (&_M_i, __m);
}
inline __attribute__((always_inline)) void
clear(memory_order __m = memory_order_seq_cst) noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
;
__atomic_clear (&_M_i, __m);
}
inline __attribute__((always_inline)) void
clear(memory_order __m = memory_order_seq_cst) volatile noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
;
__atomic_clear (&_M_i, __m);
}
private:
static constexpr __atomic_flag_data_type
_S_init(bool __i)
{ return __i ? 1 : 0; }
};
template<typename _ITp>
struct __atomic_base
{
private:
typedef _ITp __int_type;
__int_type _M_i;
public:
__atomic_base() noexcept = default;
~__atomic_base() noexcept = default;
__atomic_base(const __atomic_base&) = delete;
__atomic_base& operator=(const __atomic_base&) = delete;
__atomic_base& operator=(const __atomic_base&) volatile = delete;
constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { }
operator __int_type() const noexcept
{ return load(); }
operator __int_type() const volatile noexcept
{ return load(); }
__int_type
operator=(__int_type __i) noexcept
{
store(__i);
return __i;
}
__int_type
operator=(__int_type __i) volatile noexcept
{
store(__i);
return __i;
}
__int_type
operator++(int) noexcept
{ return fetch_add(1); }
__int_type
operator++(int) volatile noexcept
{ return fetch_add(1); }
__int_type
operator--(int) noexcept
{ return fetch_sub(1); }
__int_type
operator--(int) volatile noexcept
{ return fetch_sub(1); }
__int_type
operator++() noexcept
{ return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }
__int_type
operator++() volatile noexcept
{ return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }
__int_type
operator--() noexcept
{ return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }
__int_type
operator--() volatile noexcept
{ return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }
__int_type
operator+=(__int_type __i) noexcept
{ return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator+=(__int_type __i) volatile noexcept
{ return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator-=(__int_type __i) noexcept
{ return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator-=(__int_type __i) volatile noexcept
{ return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator&=(__int_type __i) noexcept
{ return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator&=(__int_type __i) volatile noexcept
{ return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator|=(__int_type __i) noexcept
{ return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator|=(__int_type __i) volatile noexcept
{ return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator^=(__int_type __i) noexcept
{ return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator^=(__int_type __i) volatile noexcept
{ return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }
bool
is_lock_free() const noexcept
{ return __atomic_is_lock_free(sizeof(_M_i), nullptr); }
bool
is_lock_free() const volatile noexcept
{ return __atomic_is_lock_free(sizeof(_M_i), nullptr); }
inline __attribute__((always_inline)) void
store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
;
__atomic_store_n(&_M_i, __i, __m);
}
inline __attribute__((always_inline)) void
store(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
;
__atomic_store_n(&_M_i, __i, __m);
}
inline __attribute__((always_inline)) __int_type
load(memory_order __m = memory_order_seq_cst) const noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
return __atomic_load_n(&_M_i, __m);
}
inline __attribute__((always_inline)) __int_type
load(memory_order __m = memory_order_seq_cst) const volatile noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
return __atomic_load_n(&_M_i, __m);
}
inline __attribute__((always_inline)) __int_type
exchange(__int_type __i,
memory_order __m = memory_order_seq_cst) noexcept
{
return __atomic_exchange_n(&_M_i, __i, __m);
}
inline __attribute__((always_inline)) __int_type
exchange(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
return __atomic_exchange_n(&_M_i, __i, __m);
}
inline __attribute__((always_inline)) bool
compare_exchange_weak(__int_type& __i1, __int_type __i2,
memory_order __m1, memory_order __m2) noexcept
{
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;
;
;
;
return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
}
inline __attribute__((always_inline)) bool
compare_exchange_weak(__int_type& __i1, __int_type __i2,
memory_order __m1,
memory_order __m2) volatile noexcept
{
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;
;
;
;
return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
}
inline __attribute__((always_inline)) bool
compare_exchange_weak(__int_type& __i1, __int_type __i2,
memory_order __m = memory_order_seq_cst) noexcept
{
return compare_exchange_weak(__i1, __i2, __m,
__cmpexch_failure_order(__m));
}
inline __attribute__((always_inline)) bool
compare_exchange_weak(__int_type& __i1, __int_type __i2,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
return compare_exchange_weak(__i1, __i2, __m,
__cmpexch_failure_order(__m));
}
inline __attribute__((always_inline)) bool
compare_exchange_strong(__int_type& __i1, __int_type __i2,
memory_order __m1, memory_order __m2) noexcept
{
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;
;
;
;
return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
}
inline __attribute__((always_inline)) bool
compare_exchange_strong(__int_type& __i1, __int_type __i2,
memory_order __m1,
memory_order __m2) volatile noexcept
{
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;
;
;
;
return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
}
inline __attribute__((always_inline)) bool
compare_exchange_strong(__int_type& __i1, __int_type __i2,
memory_order __m = memory_order_seq_cst) noexcept
{
return compare_exchange_strong(__i1, __i2, __m,
__cmpexch_failure_order(__m));
}
inline __attribute__((always_inline)) bool
compare_exchange_strong(__int_type& __i1, __int_type __i2,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
return compare_exchange_strong(__i1, __i2, __m,
__cmpexch_failure_order(__m));
}
inline __attribute__((always_inline)) __int_type
fetch_add(__int_type __i,
memory_order __m = memory_order_seq_cst) noexcept
{ return __atomic_fetch_add(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_add(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return __atomic_fetch_add(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_sub(__int_type __i,
memory_order __m = memory_order_seq_cst) noexcept
{ return __atomic_fetch_sub(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_sub(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return __atomic_fetch_sub(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_and(__int_type __i,
memory_order __m = memory_order_seq_cst) noexcept
{ return __atomic_fetch_and(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_and(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return __atomic_fetch_and(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_or(__int_type __i,
memory_order __m = memory_order_seq_cst) noexcept
{ return __atomic_fetch_or(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_or(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return __atomic_fetch_or(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_xor(__int_type __i,
memory_order __m = memory_order_seq_cst) noexcept
{ return __atomic_fetch_xor(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_xor(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return __atomic_fetch_xor(&_M_i, __i, __m); }
};
template<typename _PTp>
struct __atomic_base<_PTp*>
{
private:
typedef _PTp* __pointer_type;
__pointer_type _M_p;
constexpr ptrdiff_t
_M_type_size(ptrdiff_t __d) const { return __d * sizeof(_PTp); }
constexpr ptrdiff_t
_M_type_size(ptrdiff_t __d) const volatile { return __d * sizeof(_PTp); }
public:
__atomic_base() noexcept = default;
~__atomic_base() noexcept = default;
__atomic_base(const __atomic_base&) = delete;
__atomic_base& operator=(const __atomic_base&) = delete;
__atomic_base& operator=(const __atomic_base&) volatile = delete;
constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { }
operator __pointer_type() const noexcept
{ return load(); }
operator __pointer_type() const volatile noexcept
{ return load(); }
__pointer_type
operator=(__pointer_type __p) noexcept
{
store(__p);
return __p;
}
__pointer_type
operator=(__pointer_type __p) volatile noexcept
{
store(__p);
return __p;
}
__pointer_type
operator++(int) noexcept
{ return fetch_add(1); }
__pointer_type
operator++(int) volatile noexcept
{ return fetch_add(1); }
__pointer_type
operator--(int) noexcept
{ return fetch_sub(1); }
__pointer_type
operator--(int) volatile noexcept
{ return fetch_sub(1); }
__pointer_type
operator++() noexcept
{ return __atomic_add_fetch(&_M_p, _M_type_size(1),
memory_order_seq_cst); }
__pointer_type
operator++() volatile noexcept
{ return __atomic_add_fetch(&_M_p, _M_type_size(1),
memory_order_seq_cst); }
__pointer_type
operator--() noexcept
{ return __atomic_sub_fetch(&_M_p, _M_type_size(1),
memory_order_seq_cst); }
__pointer_type
operator--() volatile noexcept
{ return __atomic_sub_fetch(&_M_p, _M_type_size(1),
memory_order_seq_cst); }
__pointer_type
operator+=(ptrdiff_t __d) noexcept
{ return __atomic_add_fetch(&_M_p, _M_type_size(__d),
memory_order_seq_cst); }
__pointer_type
operator+=(ptrdiff_t __d) volatile noexcept
{ return __atomic_add_fetch(&_M_p, _M_type_size(__d),
memory_order_seq_cst); }
__pointer_type
operator-=(ptrdiff_t __d) noexcept
{ return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
memory_order_seq_cst); }
__pointer_type
operator-=(ptrdiff_t __d) volatile noexcept
{ return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
memory_order_seq_cst); }
bool
is_lock_free() const noexcept
{ return __atomic_is_lock_free(sizeof(__pointer_type), nullptr); }
bool
is_lock_free() const volatile noexcept
{ return __atomic_is_lock_free(sizeof(__pointer_type), nullptr); }
inline __attribute__((always_inline)) void
store(__pointer_type __p,
memory_order __m = memory_order_seq_cst) noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
;
__atomic_store_n(&_M_p, __p, __m);
}
inline __attribute__((always_inline)) void
store(__pointer_type __p,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
;
__atomic_store_n(&_M_p, __p, __m);
}
inline __attribute__((always_inline)) __pointer_type
load(memory_order __m = memory_order_seq_cst) const noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
return __atomic_load_n(&_M_p, __m);
}
inline __attribute__((always_inline)) __pointer_type
load(memory_order __m = memory_order_seq_cst) const volatile noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
return __atomic_load_n(&_M_p, __m);
}
inline __attribute__((always_inline)) __pointer_type
exchange(__pointer_type __p,
memory_order __m = memory_order_seq_cst) noexcept
{
return __atomic_exchange_n(&_M_p, __p, __m);
}
inline __attribute__((always_inline)) __pointer_type
exchange(__pointer_type __p,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
return __atomic_exchange_n(&_M_p, __p, __m);
}
inline __attribute__((always_inline)) bool
compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
memory_order __m1,
memory_order __m2) noexcept
{
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;
;
;
;
return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
}
inline __attribute__((always_inline)) bool
compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
memory_order __m1,
memory_order __m2) volatile noexcept
{
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;
;
;
;
return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
}
inline __attribute__((always_inline)) __pointer_type
fetch_add(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) noexcept
{ return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); }
inline __attribute__((always_inline)) __pointer_type
fetch_add(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); }
inline __attribute__((always_inline)) __pointer_type
fetch_sub(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) noexcept
{ return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); }
inline __attribute__((always_inline)) __pointer_type
fetch_sub(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); }
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
struct atomic_bool
{
private:
__atomic_base<bool> _M_base;
public:
atomic_bool() noexcept = default;
~atomic_bool() noexcept = default;
atomic_bool(const atomic_bool&) = delete;
atomic_bool& operator=(const atomic_bool&) = delete;
atomic_bool& operator=(const atomic_bool&) volatile = delete;
constexpr atomic_bool(bool __i) noexcept : _M_base(__i) { }
bool
operator=(bool __i) noexcept
{ return _M_base.operator=(__i); }
bool
operator=(bool __i) volatile noexcept
{ return _M_base.operator=(__i); }
operator bool() const noexcept
{ return _M_base.load(); }
operator bool() const volatile noexcept
{ return _M_base.load(); }
bool
is_lock_free() const noexcept { return _M_base.is_lock_free(); }
bool
is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); }
void
store(bool __i, memory_order __m = memory_order_seq_cst) noexcept
{ _M_base.store(__i, __m); }
void
store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept
{ _M_base.store(__i, __m); }
bool
load(memory_order __m = memory_order_seq_cst) const noexcept
{ return _M_base.load(__m); }
bool
load(memory_order __m = memory_order_seq_cst) const volatile noexcept
{ return _M_base.load(__m); }
bool
exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept
{ return _M_base.exchange(__i, __m); }
bool
exchange(bool __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return _M_base.exchange(__i, __m); }
bool
compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
memory_order __m2) noexcept
{ return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
bool
compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
memory_order __m2) volatile noexcept
{ return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
bool
compare_exchange_weak(bool& __i1, bool __i2,
memory_order __m = memory_order_seq_cst) noexcept
{ return _M_base.compare_exchange_weak(__i1, __i2, __m); }
bool
compare_exchange_weak(bool& __i1, bool __i2,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return _M_base.compare_exchange_weak(__i1, __i2, __m); }
bool
compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
memory_order __m2) noexcept
{ return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
bool
compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
memory_order __m2) volatile noexcept
{ return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
bool
compare_exchange_strong(bool& __i1, bool __i2,
memory_order __m = memory_order_seq_cst) noexcept
{ return _M_base.compare_exchange_strong(__i1, __i2, __m); }
bool
compare_exchange_strong(bool& __i1, bool __i2,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return _M_base.compare_exchange_strong(__i1, __i2, __m); }
};
template<typename _Tp>
struct atomic
{
private:
_Tp _M_i;
static_assert(sizeof(_Tp) > 0,
"Incomplete or zero-sized types are not supported");
public:
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(_Tp __i) noexcept : _M_i(__i) { }
operator _Tp() const noexcept
{ return load(); }
operator _Tp() const volatile noexcept
{ return load(); }
_Tp
operator=(_Tp __i) noexcept
{ store(__i); return __i; }
_Tp
operator=(_Tp __i) volatile noexcept
{ store(__i); return __i; }
bool
is_lock_free() const noexcept
{ return __atomic_is_lock_free(sizeof(_M_i), nullptr); }
bool
is_lock_free() const volatile noexcept
{ return __atomic_is_lock_free(sizeof(_M_i), nullptr); }
void
store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
{ __atomic_store(&_M_i, &__i, __m); }
void
store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept
{ __atomic_store(&_M_i, &__i, __m); }
_Tp
load(memory_order __m = memory_order_seq_cst) const noexcept
{
_Tp tmp;
__atomic_load(&_M_i, &tmp, __m);
return tmp;
}
_Tp
load(memory_order __m = memory_order_seq_cst) const volatile noexcept
{
_Tp tmp;
__atomic_load(&_M_i, &tmp, __m);
return tmp;
}
_Tp
exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
{
_Tp tmp;
__atomic_exchange(&_M_i, &__i, &tmp, __m);
return tmp;
}
_Tp
exchange(_Tp __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
_Tp tmp;
__atomic_exchange(&_M_i, &__i, &tmp, __m);
return tmp;
}
bool
compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
memory_order __f) noexcept
{
return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f);
}
bool
compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
memory_order __f) volatile noexcept
{
return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f);
}
bool
compare_exchange_weak(_Tp& __e, _Tp __i,
memory_order __m = memory_order_seq_cst) noexcept
{ return compare_exchange_weak(__e, __i, __m,
__cmpexch_failure_order(__m)); }
bool
compare_exchange_weak(_Tp& __e, _Tp __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return compare_exchange_weak(__e, __i, __m,
__cmpexch_failure_order(__m)); }
bool
compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
memory_order __f) noexcept
{
return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f);
}
bool
compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
memory_order __f) volatile noexcept
{
return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f);
}
bool
compare_exchange_strong(_Tp& __e, _Tp __i,
memory_order __m = memory_order_seq_cst) noexcept
{ return compare_exchange_strong(__e, __i, __m,
__cmpexch_failure_order(__m)); }
bool
compare_exchange_strong(_Tp& __e, _Tp __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return compare_exchange_strong(__e, __i, __m,
__cmpexch_failure_order(__m)); }
};
template<typename _Tp>
struct atomic<_Tp*>
{
typedef _Tp* __pointer_type;
typedef __atomic_base<_Tp*> __base_type;
__base_type _M_b;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }
operator __pointer_type() const noexcept
{ return __pointer_type(_M_b); }
operator __pointer_type() const volatile noexcept
{ return __pointer_type(_M_b); }
__pointer_type
operator=(__pointer_type __p) noexcept
{ return _M_b.operator=(__p); }
__pointer_type
operator=(__pointer_type __p) volatile noexcept
{ return _M_b.operator=(__p); }
__pointer_type
operator++(int) noexcept
{ return _M_b++; }
__pointer_type
operator++(int) volatile noexcept
{ return _M_b++; }
__pointer_type
operator--(int) noexcept
{ return _M_b--; }
__pointer_type
operator--(int) volatile noexcept
{ return _M_b--; }
__pointer_type
operator++() noexcept
{ return ++_M_b; }
__pointer_type
operator++() volatile noexcept
{ return ++_M_b; }
__pointer_type
operator--() noexcept
{ return --_M_b; }
__pointer_type
operator--() volatile noexcept
{ return --_M_b; }
__pointer_type
operator+=(ptrdiff_t __d) noexcept
{ return _M_b.operator+=(__d); }
__pointer_type
operator+=(ptrdiff_t __d) volatile noexcept
{ return _M_b.operator+=(__d); }
__pointer_type
operator-=(ptrdiff_t __d) noexcept
{ return _M_b.operator-=(__d); }
__pointer_type
operator-=(ptrdiff_t __d) volatile noexcept
{ return _M_b.operator-=(__d); }
bool
is_lock_free() const noexcept
{ return _M_b.is_lock_free(); }
bool
is_lock_free() const volatile noexcept
{ return _M_b.is_lock_free(); }
void
store(__pointer_type __p,
memory_order __m = memory_order_seq_cst) noexcept
{ return _M_b.store(__p, __m); }
void
store(__pointer_type __p,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return _M_b.store(__p, __m); }
__pointer_type
load(memory_order __m = memory_order_seq_cst) const noexcept
{ return _M_b.load(__m); }
__pointer_type
load(memory_order __m = memory_order_seq_cst) const volatile noexcept
{ return _M_b.load(__m); }
__pointer_type
exchange(__pointer_type __p,
memory_order __m = memory_order_seq_cst) noexcept
{ return _M_b.exchange(__p, __m); }
__pointer_type
exchange(__pointer_type __p,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return _M_b.exchange(__p, __m); }
bool
compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
memory_order __m1, memory_order __m2) noexcept
{ return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
bool
compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
memory_order __m1,
memory_order __m2) volatile noexcept
{ return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
bool
compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
memory_order __m = memory_order_seq_cst) noexcept
{
return compare_exchange_weak(__p1, __p2, __m,
__cmpexch_failure_order(__m));
}
bool
compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
return compare_exchange_weak(__p1, __p2, __m,
__cmpexch_failure_order(__m));
}
bool
compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
memory_order __m1, memory_order __m2) noexcept
{ return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
bool
compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
memory_order __m1,
memory_order __m2) volatile noexcept
{ return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
bool
compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
memory_order __m = memory_order_seq_cst) noexcept
{
return _M_b.compare_exchange_strong(__p1, __p2, __m,
__cmpexch_failure_order(__m));
}
bool
compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
return _M_b.compare_exchange_strong(__p1, __p2, __m,
__cmpexch_failure_order(__m));
}
__pointer_type
fetch_add(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) noexcept
{ return _M_b.fetch_add(__d, __m); }
__pointer_type
fetch_add(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return _M_b.fetch_add(__d, __m); }
__pointer_type
fetch_sub(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) noexcept
{ return _M_b.fetch_sub(__d, __m); }
__pointer_type
fetch_sub(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return _M_b.fetch_sub(__d, __m); }
};
template<>
struct atomic<bool> : public atomic_bool
{
typedef bool __integral_type;
typedef atomic_bool __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<char> : public atomic_char
{
typedef char __integral_type;
typedef atomic_char __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<signed char> : public atomic_schar
{
typedef signed char __integral_type;
typedef atomic_schar __base_type;
atomic() noexcept= default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<unsigned char> : public atomic_uchar
{
typedef unsigned char __integral_type;
typedef atomic_uchar __base_type;
atomic() noexcept= default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<short> : public atomic_short
{
typedef short __integral_type;
typedef atomic_short __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<unsigned short> : public atomic_ushort
{
typedef unsigned short __integral_type;
typedef atomic_ushort __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<int> : atomic_int
{
typedef int __integral_type;
typedef atomic_int __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<unsigned int> : public atomic_uint
{
typedef unsigned int __integral_type;
typedef atomic_uint __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<long> : public atomic_long
{
typedef long __integral_type;
typedef atomic_long __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<unsigned long> : public atomic_ulong
{
typedef unsigned long __integral_type;
typedef atomic_ulong __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<long long> : public atomic_llong
{
typedef long long __integral_type;
typedef atomic_llong __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<unsigned long long> : public atomic_ullong
{
typedef unsigned long long __integral_type;
typedef atomic_ullong __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<wchar_t> : public atomic_wchar_t
{
typedef wchar_t __integral_type;
typedef atomic_wchar_t __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<char16_t> : public atomic_char16_t
{
typedef char16_t __integral_type;
typedef atomic_char16_t __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<char32_t> : public atomic_char32_t
{
typedef char32_t __integral_type;
typedef atomic_char32_t __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
inline bool
atomic_flag_test_and_set_explicit(atomic_flag* __a,
memory_order __m) noexcept
{ return __a->test_and_set(__m); }
inline bool
atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
memory_order __m) noexcept
{ return __a->test_and_set(__m); }
inline void
atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept
{ __a->clear(__m); }
inline void
atomic_flag_clear_explicit(volatile atomic_flag* __a,
memory_order __m) noexcept
{ __a->clear(__m); }
inline bool
atomic_flag_test_and_set(atomic_flag* __a) noexcept
{ return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
inline bool
atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept
{ return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
inline void
atomic_flag_clear(atomic_flag* __a) noexcept
{ atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
inline void
atomic_flag_clear(volatile atomic_flag* __a) noexcept
{ atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
template<typename _ITp>
inline bool
atomic_is_lock_free(const atomic<_ITp>* __a) noexcept
{ return __a->is_lock_free(); }
template<typename _ITp>
inline bool
atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept
{ return __a->is_lock_free(); }
template<typename _ITp>
inline void
atomic_init(atomic<_ITp>* __a, _ITp __i) noexcept;
template<typename _ITp>
inline void
atomic_init(volatile atomic<_ITp>* __a, _ITp __i) noexcept;
template<typename _ITp>
inline void
atomic_store_explicit(atomic<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ __a->store(__i, __m); }
template<typename _ITp>
inline void
atomic_store_explicit(volatile atomic<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ __a->store(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept
{ return __a->load(__m); }
template<typename _ITp>
inline _ITp
atomic_load_explicit(const volatile atomic<_ITp>* __a,
memory_order __m) noexcept
{ return __a->load(__m); }
template<typename _ITp>
inline _ITp
atomic_exchange_explicit(atomic<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->exchange(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_exchange_explicit(volatile atomic<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->exchange(__i, __m); }
template<typename _ITp>
inline bool
atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2,
memory_order __m1,
memory_order __m2) noexcept
{ return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
template<typename _ITp>
inline bool
atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2,
memory_order __m1,
memory_order __m2) noexcept
{ return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
template<typename _ITp>
inline bool
atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2,
memory_order __m1,
memory_order __m2) noexcept
{ return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
template<typename _ITp>
inline bool
atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2,
memory_order __m1,
memory_order __m2) noexcept
{ return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
template<typename _ITp>
inline void
atomic_store(atomic<_ITp>* __a, _ITp __i) noexcept
{ atomic_store_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline void
atomic_store(volatile atomic<_ITp>* __a, _ITp __i) noexcept
{ atomic_store_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_load(const atomic<_ITp>* __a) noexcept
{ return atomic_load_explicit(__a, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_load(const volatile atomic<_ITp>* __a) noexcept
{ return atomic_load_explicit(__a, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_exchange(atomic<_ITp>* __a, _ITp __i) noexcept
{ return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_exchange(volatile atomic<_ITp>* __a, _ITp __i) noexcept
{ return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline bool
atomic_compare_exchange_weak(atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2) noexcept
{
return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
memory_order_seq_cst,
memory_order_seq_cst);
}
template<typename _ITp>
inline bool
atomic_compare_exchange_weak(volatile atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2) noexcept
{
return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
memory_order_seq_cst,
memory_order_seq_cst);
}
template<typename _ITp>
inline bool
atomic_compare_exchange_strong(atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2) noexcept
{
return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
memory_order_seq_cst,
memory_order_seq_cst);
}
template<typename _ITp>
inline bool
atomic_compare_exchange_strong(volatile atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2) noexcept
{
return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
memory_order_seq_cst,
memory_order_seq_cst);
}
template<typename _ITp>
inline _ITp
atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_add(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_add(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_sub(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_sub(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_and(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_and(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_or(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_or(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_xor(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_xor(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp*
atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
memory_order __m) noexcept
{ return __a->fetch_add(__d, __m); }
template<typename _ITp>
inline _ITp*
atomic_fetch_add_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d,
memory_order __m) noexcept
{ return __a->fetch_add(__d, __m); }
template<typename _ITp>
inline _ITp*
atomic_fetch_add(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
{ return __a->fetch_add(__d); }
template<typename _ITp>
inline _ITp*
atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
{ return __a->fetch_add(__d); }
template<typename _ITp>
inline _ITp*
atomic_fetch_sub_explicit(volatile atomic<_ITp*>* __a,
ptrdiff_t __d, memory_order __m) noexcept
{ return __a->fetch_sub(__d, __m); }
template<typename _ITp>
inline _ITp*
atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
memory_order __m) noexcept
{ return __a->fetch_sub(__d, __m); }
template<typename _ITp>
inline _ITp*
atomic_fetch_sub(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
{ return __a->fetch_sub(__d); }
template<typename _ITp>
inline _ITp*
atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
{ return __a->fetch_sub(__d); }
}
namespace boost {
namespace asio {
namespace detail {
typedef std::atomic<long> atomic_count;
void increment(atomic_count& a, long b) ;
}
}
}
#define BOOST_ASIO_DETAIL_REACTOR_FWD_HPP
namespace boost {
namespace asio {
namespace detail {
typedef class epoll_reactor reactor;
}
}
}
#define BOOST_ASIO_DETAIL_TASK_IO_SERVICE_OPERATION_HPP
#define BOOST_ASIO_DETAIL_HANDLER_TRACKING_HPP
namespace boost {
namespace asio {
namespace detail {
#define BOOST_ASIO_INHERIT_TRACKED_HANDLER
#define BOOST_ASIO_ALSO_INHERIT_TRACKED_HANDLER
#define BOOST_ASIO_HANDLER_TRACKING_INIT (void)0
#define BOOST_ASIO_HANDLER_CREATION(args) (void)0
#define BOOST_ASIO_HANDLER_COMPLETION(args) (void)0
#define BOOST_ASIO_HANDLER_INVOCATION_BEGIN(args) (void)0
#define BOOST_ASIO_HANDLER_INVOCATION_END (void)0
#define BOOST_ASIO_HANDLER_OPERATION(args) (void)0
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_HANDLER_TRACKING_IPP
namespace boost {
namespace asio {
namespace detail {
class task_io_service;
class task_io_service_operation
{
public:
void complete(task_io_service& owner,
const boost::system::error_code& ec, std::size_t bytes_transferred)
;
void destroy()
;
protected:
typedef void (*func_type)(task_io_service*,
task_io_service_operation*,
const boost::system::error_code&, std::size_t);
task_io_service_operation(func_type func)
;
~task_io_service_operation()
;
private:
friend class op_queue_access;
task_io_service_operation* next_;
func_type func_;
protected:
friend class task_io_service;
unsigned int task_result_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
struct task_io_service_thread_info;
class task_io_service
: public boost::asio::detail::service_base<task_io_service>
{
public:
typedef task_io_service_operation operation;
inline task_io_service(boost::asio::io_service& io_service,
std::size_t concurrency_hint = 0);
inline void shutdown_service();
inline void init_task();
inline std::size_t run(boost::system::error_code& ec);
inline std::size_t run_one(boost::system::error_code& ec);
inline std::size_t poll(boost::system::error_code& ec);
inline std::size_t poll_one(boost::system::error_code& ec);
inline void stop();
inline bool stopped() const;
inline void reset();
void work_started()
;
void work_finished()
;
bool can_dispatch()
;
template <typename Handler>
void dispatch(Handler& handler);
template <typename Handler>
void post(Handler& handler);
inline void post_immediate_completion(
operation* op, bool is_continuation);
inline void post_deferred_completion(operation* op);
inline void post_deferred_completions(op_queue<operation>& ops);
inline void abandon_operations(op_queue<operation>& ops);
private:
typedef task_io_service_thread_info thread_info;
inline void do_dispatch(operation* op);
inline std::size_t do_run_one(mutex::scoped_lock& lock,
thread_info& this_thread, const boost::system::error_code& ec);
inline std::size_t do_poll_one(mutex::scoped_lock& lock,
thread_info& this_thread, const boost::system::error_code& ec);
inline void stop_all_threads(mutex::scoped_lock& lock);
inline bool wake_one_idle_thread_and_unlock(
mutex::scoped_lock& lock);
inline void wake_one_thread_and_unlock(
mutex::scoped_lock& lock);
struct task_cleanup;
friend struct task_cleanup;
struct work_cleanup;
friend struct work_cleanup;
const bool one_thread_;
mutable mutex mutex_;
reactor* task_;
struct task_operation : operation
{
task_operation() ;
} task_operation_;
bool task_interrupted_;
atomic_count outstanding_work_;
op_queue<operation> op_queue_;
bool stopped_;
bool shutdown_;
typedef call_stack<task_io_service, thread_info> thread_call_stack;
thread_info* first_idle_thread_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_TASK_IO_SERVICE_HPP
#define BOOST_ASIO_DETAIL_COMPLETION_HANDLER_HPP
#define BOOST_ASIO_DETAIL_FENCED_BLOCK_HPP
#define BOOST_ASIO_DETAIL_GCC_X86_FENCED_BLOCK_HPP
namespace boost {
namespace asio {
namespace detail {
class gcc_x86_fenced_block
: private noncopyable
{
public:
enum half_t { half };
enum full_t { full };
explicit gcc_x86_fenced_block(half_t)
;
explicit gcc_x86_fenced_block(full_t)
;
~gcc_x86_fenced_block()
;
private:
static int barrier()
;
static void lbarrier()
;
static void sbarrier()
;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
typedef gcc_x86_fenced_block fenced_block;
}
}
}
#define BOOST_ASIO_DETAIL_OPERATION_HPP
namespace boost {
namespace asio {
namespace detail {
typedef task_io_service_operation operation;
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Handler>
class completion_handler : public operation
{
public:
struct ptr { Handler* h; void* v; completion_handler* p; ~ptr() ; void reset() ; };
completion_handler(Handler& h)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_TASK_IO_SERVICE_IPP
#define BOOST_ASIO_DETAIL_LIMITS_HPP
#define BOOST_LIMITS
#define _GLIBCXX_NUMERIC_LIMITS 1
#define __glibcxx_integral_traps true
#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(T) ((T)(-1) < 0)
#define __glibcxx_min(T) (__glibcxx_signed (T) ? -__glibcxx_max (T) - 1 : (T)0)
#define __glibcxx_max(T) (__glibcxx_signed (T) ? (((((T)1 << (__glibcxx_digits (T) - 1)) - 1) << 1) + 1) : ~(T)0)
#define __glibcxx_digits(T) (sizeof(T) * __CHAR_BIT__ - __glibcxx_signed (T))
#define __glibcxx_digits10(T) (__glibcxx_digits (T) * 643L / 2136)
#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
};
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;
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;
};
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> { };
template<>
struct numeric_limits<bool>
{
static constexpr bool is_specialized = true;
static constexpr bool
min() noexcept { return false; }
static constexpr bool
max() noexcept { return true; }
static constexpr bool
lowest() noexcept { return min(); }
static constexpr int digits = 1;
static constexpr int digits10 = 0;
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr bool
epsilon() noexcept { return false; }
static constexpr bool
round_error() noexcept { return false; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr bool
infinity() noexcept { return false; }
static constexpr bool
quiet_NaN() noexcept { return false; }
static constexpr bool
signaling_NaN() noexcept { return false; }
static constexpr bool
denorm_min() noexcept { return false; }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<char>
{
static constexpr bool is_specialized = true;
static constexpr char
min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); }
static constexpr char
max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); }
static constexpr char
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = ((char)(-1) < 0);
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr char
epsilon() noexcept { return 0; }
static constexpr char
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr
char infinity() noexcept { return char(); }
static constexpr char
quiet_NaN() noexcept { return char(); }
static constexpr char
signaling_NaN() noexcept { return char(); }
static constexpr char
denorm_min() noexcept { return static_cast<char>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<signed char>
{
static constexpr bool is_specialized = true;
static constexpr signed char
min() noexcept { return -0x7f - 1; }
static constexpr signed char
max() noexcept { return 0x7f; }
static constexpr signed char
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
static constexpr int digits10
= ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr signed char
epsilon() noexcept { return 0; }
static constexpr signed char
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr signed char
infinity() noexcept { return static_cast<signed char>(0); }
static constexpr signed char
quiet_NaN() noexcept { return static_cast<signed char>(0); }
static constexpr signed char
signaling_NaN() noexcept
{ return static_cast<signed char>(0); }
static constexpr signed char
denorm_min() noexcept
{ return static_cast<signed char>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned char>
{
static constexpr bool is_specialized = true;
static constexpr unsigned char
min() noexcept { return 0; }
static constexpr unsigned char
max() noexcept { return 0x7f * 2U + 1; }
static constexpr unsigned char
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
static constexpr int digits10
= ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned char
epsilon() noexcept { return 0; }
static constexpr unsigned char
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned char
infinity() noexcept
{ return static_cast<unsigned char>(0); }
static constexpr unsigned char
quiet_NaN() noexcept
{ return static_cast<unsigned char>(0); }
static constexpr unsigned char
signaling_NaN() noexcept
{ return static_cast<unsigned char>(0); }
static constexpr unsigned char
denorm_min() noexcept
{ return static_cast<unsigned char>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<wchar_t>
{
static constexpr bool is_specialized = true;
static constexpr wchar_t
min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); }
static constexpr wchar_t
max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); }
static constexpr wchar_t
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
static constexpr int digits10
= ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = ((wchar_t)(-1) < 0);
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr wchar_t
epsilon() noexcept { return 0; }
static constexpr wchar_t
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr wchar_t
infinity() noexcept { return wchar_t(); }
static constexpr wchar_t
quiet_NaN() noexcept { return wchar_t(); }
static constexpr wchar_t
signaling_NaN() noexcept { return wchar_t(); }
static constexpr wchar_t
denorm_min() noexcept { return wchar_t(); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<char16_t>
{
static constexpr bool is_specialized = true;
static constexpr char16_t
min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); }
static constexpr char16_t
max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); }
static constexpr char16_t
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0));
static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = ((char16_t)(-1) < 0);
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr char16_t
epsilon() noexcept { return 0; }
static constexpr char16_t
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr char16_t
infinity() noexcept { return char16_t(); }
static constexpr char16_t
quiet_NaN() noexcept { return char16_t(); }
static constexpr char16_t
signaling_NaN() noexcept { return char16_t(); }
static constexpr char16_t
denorm_min() noexcept { return char16_t(); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
template<>
struct numeric_limits<char32_t>
{
static constexpr bool is_specialized = true;
static constexpr char32_t
min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); }
static constexpr char32_t
max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); }
static constexpr char32_t
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0));
static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = ((char32_t)(-1) < 0);
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr char32_t
epsilon() noexcept { return 0; }
static constexpr char32_t
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr char32_t
infinity() noexcept { return char32_t(); }
static constexpr char32_t
quiet_NaN() noexcept { return char32_t(); }
static constexpr char32_t
signaling_NaN() noexcept { return char32_t(); }
static constexpr char32_t
denorm_min() noexcept { return char32_t(); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
template<>
struct numeric_limits<short>
{
static constexpr bool is_specialized = true;
static constexpr short
min() noexcept { return -0x7fff - 1; }
static constexpr short
max() noexcept { return 0x7fff; }
static constexpr short
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr short
epsilon() noexcept { return 0; }
static constexpr short
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr short
infinity() noexcept { return short(); }
static constexpr short
quiet_NaN() noexcept { return short(); }
static constexpr short
signaling_NaN() noexcept { return short(); }
static constexpr short
denorm_min() noexcept { return short(); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned short>
{
static constexpr bool is_specialized = true;
static constexpr unsigned short
min() noexcept { return 0; }
static constexpr unsigned short
max() noexcept { return 0x7fff * 2U + 1; }
static constexpr unsigned short
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
static constexpr int digits10
= ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned short
epsilon() noexcept { return 0; }
static constexpr unsigned short
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned short
infinity() noexcept
{ return static_cast<unsigned short>(0); }
static constexpr unsigned short
quiet_NaN() noexcept
{ return static_cast<unsigned short>(0); }
static constexpr unsigned short
signaling_NaN() noexcept
{ return static_cast<unsigned short>(0); }
static constexpr unsigned short
denorm_min() noexcept
{ return static_cast<unsigned short>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<int>
{
static constexpr bool is_specialized = true;
static constexpr int
min() noexcept { return -0x7fffffff - 1; }
static constexpr int
max() noexcept { return 0x7fffffff; }
static constexpr int
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr int
epsilon() noexcept { return 0; }
static constexpr int
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr int
infinity() noexcept { return static_cast<int>(0); }
static constexpr int
quiet_NaN() noexcept { return static_cast<int>(0); }
static constexpr int
signaling_NaN() noexcept { return static_cast<int>(0); }
static constexpr int
denorm_min() noexcept { return static_cast<int>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned int>
{
static constexpr bool is_specialized = true;
static constexpr unsigned int
min() noexcept { return 0; }
static constexpr unsigned int
max() noexcept { return 0x7fffffff * 2U + 1; }
static constexpr unsigned int
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
static constexpr int digits10
= ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned int
epsilon() noexcept { return 0; }
static constexpr unsigned int
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned int
infinity() noexcept { return static_cast<unsigned int>(0); }
static constexpr unsigned int
quiet_NaN() noexcept
{ return static_cast<unsigned int>(0); }
static constexpr unsigned int
signaling_NaN() noexcept
{ return static_cast<unsigned int>(0); }
static constexpr unsigned int
denorm_min() noexcept
{ return static_cast<unsigned int>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<long>
{
static constexpr bool is_specialized = true;
static constexpr long
min() noexcept { return -0x7fffffffffffffffL - 1; }
static constexpr long
max() noexcept { return 0x7fffffffffffffffL; }
static constexpr long
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr long
epsilon() noexcept { return 0; }
static constexpr long
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr long
infinity() noexcept { return static_cast<long>(0); }
static constexpr long
quiet_NaN() noexcept { return static_cast<long>(0); }
static constexpr long
signaling_NaN() noexcept { return static_cast<long>(0); }
static constexpr long
denorm_min() noexcept { return static_cast<long>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned long>
{
static constexpr bool is_specialized = true;
static constexpr unsigned long
min() noexcept { return 0; }
static constexpr unsigned long
max() noexcept { return 0x7fffffffffffffffL * 2UL + 1; }
static constexpr unsigned long
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
static constexpr int digits10
= ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned long
epsilon() noexcept { return 0; }
static constexpr unsigned long
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned long
infinity() noexcept
{ return static_cast<unsigned long>(0); }
static constexpr unsigned long
quiet_NaN() noexcept
{ return static_cast<unsigned long>(0); }
static constexpr unsigned long
signaling_NaN() noexcept
{ return static_cast<unsigned long>(0); }
static constexpr unsigned long
denorm_min() noexcept
{ return static_cast<unsigned long>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<long long>
{
static constexpr bool is_specialized = true;
static constexpr long long
min() noexcept { return -0x7fffffffffffffffLL - 1; }
static constexpr long long
max() noexcept { return 0x7fffffffffffffffLL; }
static constexpr long long
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(long long) * 8 - ((long long)(-1) < 0));
static constexpr int digits10
= ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr long long
epsilon() noexcept { return 0; }
static constexpr long long
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr long long
infinity() noexcept { return static_cast<long long>(0); }
static constexpr long long
quiet_NaN() noexcept { return static_cast<long long>(0); }
static constexpr long long
signaling_NaN() noexcept
{ return static_cast<long long>(0); }
static constexpr long long
denorm_min() noexcept { return static_cast<long long>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned long long>
{
static constexpr bool is_specialized = true;
static constexpr unsigned long long
min() noexcept { return 0; }
static constexpr unsigned long long
max() noexcept { return 0x7fffffffffffffffLL * 2ULL + 1; }
static constexpr unsigned long long
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
static constexpr int digits10
= ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned long long
epsilon() noexcept { return 0; }
static constexpr unsigned long long
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned long long
infinity() noexcept
{ return static_cast<unsigned long long>(0); }
static constexpr unsigned long long
quiet_NaN() noexcept
{ return static_cast<unsigned long long>(0); }
static constexpr unsigned long long
signaling_NaN() noexcept
{ return static_cast<unsigned long long>(0); }
static constexpr unsigned long long
denorm_min() noexcept
{ return static_cast<unsigned long long>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<float>
{
static constexpr bool is_specialized = true;
static constexpr float
min() noexcept { return 1.17549435082228750797e-38F; }
static constexpr float
max() noexcept { return 3.40282346638528859812e+38F; }
static constexpr float
lowest() noexcept { return -3.40282346638528859812e+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.19209289550781250000e-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.40129846432481707092e-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 double(2.22507385850720138309e-308L); }
static constexpr double
max() noexcept { return double(1.79769313486231570815e+308L); }
static constexpr double
lowest() noexcept { return -double(1.79769313486231570815e+308L); }
static constexpr int digits = 53;
static constexpr int digits10 = 15;
static constexpr int max_digits10
= (2 + (53) * 643L / 2136);
static constexpr bool is_signed = true;
static constexpr bool is_integer = false;
static constexpr bool is_exact = false;
static constexpr int radix = 2;
static constexpr double
epsilon() noexcept { return double(2.22044604925031308085e-16L); }
static constexpr double
round_error() noexcept { return 0.5; }
static constexpr int min_exponent = (-1021);
static constexpr int min_exponent10 = (-307);
static constexpr int max_exponent = 1024;
static constexpr int max_exponent10 = 308;
static constexpr bool has_infinity = 1;
static constexpr bool has_quiet_NaN = 1;
static constexpr bool has_signaling_NaN = has_quiet_NaN;
static constexpr float_denorm_style has_denorm
= bool(1) ? denorm_present : denorm_absent;
static constexpr bool has_denorm_loss
= false;
static constexpr double
infinity() noexcept { return __builtin_huge_val(); }
static constexpr double
quiet_NaN() noexcept { return __builtin_nan(""); }
static constexpr double
signaling_NaN() noexcept { return __builtin_nans(""); }
static constexpr double
denorm_min() noexcept { return double(4.94065645841246544177e-324L); }
static constexpr bool is_iec559
= has_infinity && has_quiet_NaN && has_denorm == denorm_present;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = false;
static constexpr bool tinyness_before
= false;
static constexpr float_round_style round_style
= round_to_nearest;
};
#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.36210314311209350626e-4932L; }
static constexpr long double
max() noexcept { return 1.18973149535723176502e+4932L; }
static constexpr long double
lowest() noexcept { return -1.18973149535723176502e+4932L; }
static constexpr int digits = 64;
static constexpr int digits10 = 18;
static constexpr int max_digits10
= (2 + (64) * 643L / 2136);
static constexpr bool is_signed = true;
static constexpr bool is_integer = false;
static constexpr bool is_exact = false;
static constexpr int radix = 2;
static constexpr long double
epsilon() noexcept { return 1.08420217248550443401e-19L; }
static constexpr long double
round_error() noexcept { return 0.5L; }
static constexpr int min_exponent = (-16381);
static constexpr int min_exponent10 = (-4931);
static constexpr int max_exponent = 16384;
static constexpr int max_exponent10 = 4932;
static constexpr bool has_infinity = 1;
static constexpr bool has_quiet_NaN = 1;
static constexpr bool has_signaling_NaN = has_quiet_NaN;
static constexpr float_denorm_style has_denorm
= bool(1) ? denorm_present : denorm_absent;
static constexpr bool has_denorm_loss
= false;
static constexpr long double
infinity() noexcept { return __builtin_huge_vall(); }
static constexpr long double
quiet_NaN() noexcept { return __builtin_nanl(""); }
static constexpr long double
signaling_NaN() noexcept { return __builtin_nansl(""); }
static constexpr long double
denorm_min() noexcept { return 3.64519953188247460253e-4951L; }
static constexpr bool is_iec559
= has_infinity && has_quiet_NaN && has_denorm == denorm_present;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = false;
static constexpr bool tinyness_before =
false;
static constexpr float_round_style round_style =
round_to_nearest;
};
#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
#define BOOST_ASIO_DETAIL_REACTOR_HPP
#define BOOST_ASIO_DETAIL_EPOLL_REACTOR_HPP
#define BOOST_ASIO_DETAIL_OBJECT_POOL_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Object>
class object_pool;
class object_pool_access
{
public:
template <typename Object>
static Object* create()
;
template <typename Object>
static void destroy(Object* o)
;
template <typename Object>
static Object*& next(Object* o)
;
template <typename Object>
static Object*& prev(Object* o)
;
};
template <typename Object>
class object_pool
: private noncopyable
{
public:
object_pool()
;
~object_pool()
;
Object* first()
;
Object* alloc()
;
void free(Object* o)
;
private:
void destroy_list(Object* list)
;
Object* live_list_;
Object* free_list_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTOR_OP_HPP
namespace boost {
namespace asio {
namespace detail {
class reactor_op
: public operation
{
public:
boost::system::error_code ec_;
std::size_t bytes_transferred_;
bool perform()
;
protected:
typedef bool (*perform_func_type)(reactor_op*);
reactor_op(perform_func_type perform_func, func_type complete_func)
;
private:
perform_func_type perform_func_;
};
}
}
}
#define BOOST_ASIO_DETAIL_SELECT_INTERRUPTER_HPP
#define BOOST_ASIO_DETAIL_EVENTFD_SELECT_INTERRUPTER_HPP
namespace boost {
namespace asio {
namespace detail {
class eventfd_select_interrupter
{
public:
inline eventfd_select_interrupter();
inline ~eventfd_select_interrupter();
inline void recreate();
inline void interrupt();
inline bool reset();
int read_descriptor() const
;
private:
inline void open_descriptors();
inline void close_descriptors();
int read_descriptor_;
int write_descriptor_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_EVENTFD_SELECT_INTERRUPTER_IPP
#define _SYS_STAT_H 1
#define __need_time_t
#define __need_timespec
extern "C" {
#define _BITS_STAT_H 1
#define _STAT_VER_KERNEL 0
#define _STAT_VER_LINUX 1
#define _MKNOD_VER_LINUX 0
#define _STAT_VER _STAT_VER_LINUX
struct stat
{
__dev_t st_dev;
__ino_t st_ino;
__nlink_t st_nlink;
__mode_t st_mode;
__uid_t st_uid;
__gid_t st_gid;
int __pad0;
__dev_t st_rdev;
__off_t st_size;
__blksize_t st_blksize;
__blkcnt_t st_blocks;
struct timespec st_atim;
struct timespec st_mtim;
struct timespec st_ctim;
#define st_atime st_atim.tv_sec
#define st_mtime st_mtim.tv_sec
#define st_ctime st_ctim.tv_sec
__syscall_slong_t __glibc_reserved[3];
};
struct stat64
{
__dev_t st_dev;
__ino64_t st_ino;
__nlink_t st_nlink;
__mode_t st_mode;
__uid_t st_uid;
__gid_t st_gid;
int __pad0;
__dev_t st_rdev;
__off_t st_size;
__blksize_t st_blksize;
__blkcnt64_t st_blocks;
struct timespec st_atim;
struct timespec st_mtim;
struct timespec st_ctim;
__syscall_slong_t __glibc_reserved[3];
};
#define _STATBUF_ST_BLKSIZE
#define _STATBUF_ST_RDEV
#define _STATBUF_ST_NSEC
#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) ((buf)->st_mode - (buf)->st_mode)
#define __S_TYPEISSEM(buf) ((buf)->st_mode - (buf)->st_mode)
#define __S_TYPEISSHM(buf) ((buf)->st_mode - (buf)->st_mode)
#define __S_ISUID 04000
#define __S_ISGID 02000
#define __S_ISVTX 01000
#define __S_IREAD 0400
#define __S_IWRITE 0200
#define __S_IEXEC 0100
#define UTIME_NOW ((1l << 30) - 1l)
#define UTIME_OMIT ((1l << 30) - 2l)
#define S_IFMT __S_IFMT
#define S_IFDIR __S_IFDIR
#define S_IFCHR __S_IFCHR
#define S_IFBLK __S_IFBLK
#define S_IFREG __S_IFREG
#define S_IFIFO __S_IFIFO
#define S_IFLNK __S_IFLNK
#define S_IFSOCK __S_IFSOCK
#define __S_ISTYPE(mode,mask) (((mode) & __S_IFMT) == (mask))
#define S_ISDIR(mode) __S_ISTYPE((mode), __S_IFDIR)
#define S_ISCHR(mode) __S_ISTYPE((mode), __S_IFCHR)
#define S_ISBLK(mode) __S_ISTYPE((mode), __S_IFBLK)
#define S_ISREG(mode) __S_ISTYPE((mode), __S_IFREG)
#define S_ISFIFO(mode) __S_ISTYPE((mode), __S_IFIFO)
#define S_ISLNK(mode) __S_ISTYPE((mode), __S_IFLNK)
#define S_ISSOCK(mode) __S_ISTYPE((mode), __S_IFSOCK)
#define S_TYPEISMQ(buf) __S_TYPEISMQ(buf)
#define S_TYPEISSEM(buf) __S_TYPEISSEM(buf)
#define S_TYPEISSHM(buf) __S_TYPEISSHM(buf)
#define S_ISUID __S_ISUID
#define S_ISGID __S_ISGID
#define S_ISVTX __S_ISVTX
#define S_IRUSR __S_IREAD
#define S_IWUSR __S_IWRITE
#define S_IXUSR __S_IEXEC
#define S_IRWXU (__S_IREAD|__S_IWRITE|__S_IEXEC)
#define S_IREAD S_IRUSR
#define S_IWRITE S_IWUSR
#define S_IEXEC S_IXUSR
#define S_IRGRP (S_IRUSR >> 3)
#define S_IWGRP (S_IWUSR >> 3)
#define S_IXGRP (S_IXUSR >> 3)
#define S_IRWXG (S_IRWXU >> 3)
#define S_IROTH (S_IRGRP >> 3)
#define S_IWOTH (S_IWGRP >> 3)
#define S_IXOTH (S_IXGRP >> 3)
#define S_IRWXO (S_IRWXG >> 3)
#define ACCESSPERMS (S_IRWXU|S_IRWXG|S_IRWXO)
#define ALLPERMS (S_ISUID|S_ISGID|S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO)
#define DEFFILEMODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)
#define S_BLKSIZE 512
extern int stat (const char *__restrict __file,
struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int fstat (int __fd, struct stat *__buf) throw () __attribute__ ((__nonnull__ (2)));
extern int stat64 (const char *__restrict __file,
struct stat64 *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int fstat64 (int __fd, struct stat64 *__buf) throw () __attribute__ ((__nonnull__ (2)));
extern int fstatat (int __fd, const char *__restrict __file,
struct stat *__restrict __buf, int __flag)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern int fstatat64 (int __fd, const char *__restrict __file,
struct stat64 *__restrict __buf, int __flag)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern int lstat (const char *__restrict __file,
struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int lstat64 (const char *__restrict __file,
struct stat64 *__restrict __buf)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int chmod (const char *__file, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (1)));
extern int lchmod (const char *__file, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (1)));
extern int fchmod (int __fd, __mode_t __mode) throw ();
extern int fchmodat (int __fd, const char *__file, __mode_t __mode,
int __flag)
throw () __attribute__ ((__nonnull__ (2))) ;
extern __mode_t umask (__mode_t __mask) throw ();
extern __mode_t getumask (void) throw ();
extern int mkdir (const char *__path, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (1)));
extern int mkdirat (int __fd, const char *__path, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (2)));
extern int mknod (const char *__path, __mode_t __mode, __dev_t __dev)
throw () __attribute__ ((__nonnull__ (1)));
extern int mknodat (int __fd, const char *__path, __mode_t __mode,
__dev_t __dev) throw () __attribute__ ((__nonnull__ (2)));
extern int mkfifo (const char *__path, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (1)));
extern int mkfifoat (int __fd, const char *__path, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (2)));
extern int utimensat (int __fd, const char *__path,
const struct timespec __times[2],
int __flags)
throw () __attribute__ ((__nonnull__ (2)));
extern int futimens (int __fd, const struct timespec __times[2]) throw ();
#define _MKNOD_VER 0
extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf)
throw () __attribute__ ((__nonnull__ (3)));
extern int __xstat (int __ver, const char *__filename,
struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __lxstat (int __ver, const char *__filename,
struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __fxstatat (int __ver, int __fildes, const char *__filename,
struct stat *__stat_buf, int __flag)
throw () __attribute__ ((__nonnull__ (3, 4)));
extern int __fxstat64 (int __ver, int __fildes, struct stat64 *__stat_buf)
throw () __attribute__ ((__nonnull__ (3)));
extern int __xstat64 (int __ver, const char *__filename,
struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __lxstat64 (int __ver, const char *__filename,
struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __fxstatat64 (int __ver, int __fildes, const char *__filename,
struct stat64 *__stat_buf, int __flag)
throw () __attribute__ ((__nonnull__ (3, 4)));
extern int __xmknod (int __ver, const char *__path, __mode_t __mode,
__dev_t *__dev) throw () __attribute__ ((__nonnull__ (2, 4)));
extern int __xmknodat (int __ver, int __fd, const char *__path,
__mode_t __mode, __dev_t *__dev)
throw () __attribute__ ((__nonnull__ (3, 5)));
}
#define _FCNTL_H 1
extern "C" {
#define __O_LARGEFILE 0
#define F_GETLK64 5
#define F_SETLK64 6
#define F_SETLKW64 7
struct flock
{
short int l_type;
short int l_whence;
__off_t l_start;
__off_t l_len;
__pid_t l_pid;
};
struct flock64
{
short int l_type;
short int l_whence;
__off64_t l_start;
__off64_t l_len;
__pid_t l_pid;
};
#define O_ACCMODE 0003
#define O_RDONLY 00
#define O_WRONLY 01
#define O_RDWR 02
#define O_CREAT 0100
#define O_EXCL 0200
#define O_NOCTTY 0400
#define O_TRUNC 01000
#define O_APPEND 02000
#define O_NONBLOCK 04000
#define O_NDELAY O_NONBLOCK
#define O_SYNC 04010000
#define O_FSYNC O_SYNC
#define O_ASYNC 020000
#define __O_DIRECTORY 0200000
#define __O_NOFOLLOW 0400000
#define __O_CLOEXEC 02000000
#define __O_DIRECT 040000
#define __O_NOATIME 01000000
#define __O_PATH 010000000
#define __O_DSYNC 010000
#define __O_TMPFILE 020200000
#define F_GETLK 5
#define F_SETLK 6
#define F_SETLKW 7
#define O_LARGEFILE __O_LARGEFILE
#define O_DIRECTORY __O_DIRECTORY
#define O_NOFOLLOW __O_NOFOLLOW
#define O_CLOEXEC __O_CLOEXEC
#define O_DIRECT __O_DIRECT
#define O_NOATIME __O_NOATIME
#define O_PATH __O_PATH
#define O_TMPFILE __O_TMPFILE
#define O_DSYNC __O_DSYNC
#define O_RSYNC O_SYNC
#define F_DUPFD 0
#define F_GETFD 1
#define F_SETFD 2
#define F_GETFL 3
#define F_SETFL 4
#define __F_SETOWN 8
#define __F_GETOWN 9
#define F_SETOWN __F_SETOWN
#define F_GETOWN __F_GETOWN
#define __F_SETSIG 10
#define __F_GETSIG 11
#define __F_SETOWN_EX 15
#define __F_GETOWN_EX 16
#define F_SETSIG __F_SETSIG
#define F_GETSIG __F_GETSIG
#define F_SETOWN_EX __F_SETOWN_EX
#define F_GETOWN_EX __F_GETOWN_EX
#define F_SETLEASE 1024
#define F_GETLEASE 1025
#define F_NOTIFY 1026
#define F_SETPIPE_SZ 1031
#define F_GETPIPE_SZ 1032
#define F_DUPFD_CLOEXEC 1030
#define FD_CLOEXEC 1
#define F_RDLCK 0
#define F_WRLCK 1
#define F_UNLCK 2
#define F_EXLCK 4
#define F_SHLCK 8
#define LOCK_SH 1
#define LOCK_EX 2
#define LOCK_NB 4
#define LOCK_UN 8
#define LOCK_MAND 32
#define LOCK_READ 64
#define LOCK_WRITE 128
#define LOCK_RW 192
#define DN_ACCESS 0x00000001
#define DN_MODIFY 0x00000002
#define DN_CREATE 0x00000004
#define DN_DELETE 0x00000008
#define DN_RENAME 0x00000010
#define DN_ATTRIB 0x00000020
#define DN_MULTISHOT 0x80000000
enum __pid_type
{
F_OWNER_TID = 0,
F_OWNER_PID,
F_OWNER_PGRP,
F_OWNER_GID = F_OWNER_PGRP
};
struct f_owner_ex
{
enum __pid_type type;
__pid_t pid;
};
#define FAPPEND O_APPEND
#define FFSYNC O_FSYNC
#define FASYNC O_ASYNC
#define FNONBLOCK O_NONBLOCK
#define FNDELAY O_NDELAY
#define __POSIX_FADV_DONTNEED 4
#define __POSIX_FADV_NOREUSE 5
#define POSIX_FADV_NORMAL 0
#define POSIX_FADV_RANDOM 1
#define POSIX_FADV_SEQUENTIAL 2
#define POSIX_FADV_WILLNEED 3
#define POSIX_FADV_DONTNEED __POSIX_FADV_DONTNEED
#define POSIX_FADV_NOREUSE __POSIX_FADV_NOREUSE
#define SYNC_FILE_RANGE_WAIT_BEFORE 1
#define SYNC_FILE_RANGE_WRITE 2
#define SYNC_FILE_RANGE_WAIT_AFTER 4
#define SPLICE_F_MOVE 1
#define SPLICE_F_NONBLOCK 2
#define SPLICE_F_MORE 4
#define SPLICE_F_GIFT 8
#define FALLOC_FL_KEEP_SIZE 1
#define FALLOC_FL_PUNCH_HOLE 2
struct file_handle
{
unsigned int handle_bytes;
int handle_type;
unsigned char f_handle[0];
};
#define MAX_HANDLE_SZ 128
#define AT_FDCWD -100
#define AT_SYMLINK_NOFOLLOW 0x100
#define AT_REMOVEDIR 0x200
#define AT_SYMLINK_FOLLOW 0x400
#define AT_NO_AUTOMOUNT 0x800
#define AT_EMPTY_PATH 0x1000
#define AT_EACCESS 0x200
extern "C" {
extern ssize_t readahead (int __fd, __off64_t __offset, size_t __count)
throw ();
extern int sync_file_range (int __fd, __off64_t __offset, __off64_t __count,
unsigned int __flags);
extern ssize_t vmsplice (int __fdout, const struct iovec *__iov,
size_t __count, unsigned int __flags);
extern ssize_t splice (int __fdin, __off64_t *__offin, int __fdout,
__off64_t *__offout, size_t __len,
unsigned int __flags);
extern ssize_t tee (int __fdin, int __fdout, size_t __len,
unsigned int __flags);
extern int fallocate (int __fd, int __mode, __off_t __offset, __off_t __len);
extern int fallocate64 (int __fd, int __mode, __off64_t __offset,
__off64_t __len);
extern int name_to_handle_at (int __dfd, const char *__name,
struct file_handle *__handle, int *__mnt_id,
int __flags) throw ();
extern int open_by_handle_at (int __mountdirfd, struct file_handle *__handle,
int __flags);
}
#define __need_timespec
#define S_IFMT __S_IFMT
#define S_IFDIR __S_IFDIR
#define S_IFCHR __S_IFCHR
#define S_IFBLK __S_IFBLK
#define S_IFREG __S_IFREG
#define S_IFIFO __S_IFIFO
#define S_IFLNK __S_IFLNK
#define S_IFSOCK __S_IFSOCK
#define S_ISUID __S_ISUID
#define S_ISGID __S_ISGID
#define S_ISVTX __S_ISVTX
#define S_IRUSR __S_IREAD
#define S_IWUSR __S_IWRITE
#define S_IXUSR __S_IEXEC
#define S_IRWXU (__S_IREAD|__S_IWRITE|__S_IEXEC)
#define S_IRGRP (S_IRUSR >> 3)
#define S_IWGRP (S_IWUSR >> 3)
#define S_IXGRP (S_IXUSR >> 3)
#define S_IRWXG (S_IRWXU >> 3)
#define S_IROTH (S_IRGRP >> 3)
#define S_IWOTH (S_IWGRP >> 3)
#define S_IXOTH (S_IXGRP >> 3)
#define S_IRWXO (S_IRWXG >> 3)
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2
extern int fcntl (int __fd, int __cmd, ...);
extern int open (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
extern int open64 (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
extern int openat (int __fd, const char *__file, int __oflag, ...)
__attribute__ ((__nonnull__ (2)));
extern int openat64 (int __fd, const char *__file, int __oflag, ...)
__attribute__ ((__nonnull__ (2)));
extern int creat (const char *__file, mode_t __mode) __attribute__ ((__nonnull__ (1)));
extern int creat64 (const char *__file, mode_t __mode) __attribute__ ((__nonnull__ (1)));
extern int posix_fadvise (int __fd, off_t __offset, off_t __len,
int __advise) throw ();
extern int posix_fadvise64 (int __fd, off64_t __offset, off64_t __len,
int __advise) throw ();
extern int posix_fallocate (int __fd, off_t __offset, off_t __len);
extern int posix_fallocate64 (int __fd, off64_t __offset, off64_t __len);
}
#define _SYS_EVENTFD_H 1
enum
{
EFD_SEMAPHORE = 00000001,
#define EFD_SEMAPHORE EFD_SEMAPHORE
EFD_CLOEXEC = 02000000,
#define EFD_CLOEXEC EFD_CLOEXEC
EFD_NONBLOCK = 00004000
#define EFD_NONBLOCK EFD_NONBLOCK
};
typedef uint64_t eventfd_t;
extern "C" {
extern int eventfd (int __count, int __flags) throw ();
extern int eventfd_read (int __fd, eventfd_t *__value);
extern int eventfd_write (int __fd, eventfd_t __value);
}
#define BOOST_ASIO_DETAIL_CSTDINT_HPP
namespace boost {
namespace asio {
using std::int16_t;
using std::uint16_t;
using std::int32_t;
using std::uint32_t;
using std::int64_t;
using std::uint64_t;
}
}
namespace boost {
namespace asio {
namespace detail {
bool eventfd_select_interrupter::reset()
{
if (write_descriptor_ == read_descriptor_)
{
for (;;)
{
uint64_t counter(0);
(*__errno_location ()) = 0;
int bytes_read = ::read(read_descriptor_, &counter, sizeof(uint64_t));
if (bytes_read < 0 && (*__errno_location ()) == 4)
continue;
bool was_interrupted = (bytes_read > 0);
return was_interrupted;
}
}
else
{
for (;;)
{
char data[1024];
int bytes_read = ::read(read_descriptor_, data, sizeof(data));
if (bytes_read < 0 && (*__errno_location ()) == 4)
continue;
bool was_interrupted = (bytes_read > 0);
while (bytes_read == sizeof(data))
bytes_read = ::read(read_descriptor_, data, sizeof(data));
return was_interrupted;
}
}
}
}
}
}
namespace boost {
namespace asio {
namespace detail {
typedef eventfd_select_interrupter select_interrupter;
}
}
}
#define BOOST_ASIO_DETAIL_SOCKET_TYPES_HPP
#define _SYS_IOCTL_H 1
extern "C" {
#define __ASM_GENERIC_IOCTLS_H
#define _LINUX_IOCTL_H
#define _ASM_GENERIC_IOCTL_H
#define _IOC_NRBITS 8
#define _IOC_TYPEBITS 8
#define _IOC_SIZEBITS 14
#define _IOC_DIRBITS 2
#define _IOC_NRMASK ((1 << _IOC_NRBITS)-1)
#define _IOC_TYPEMASK ((1 << _IOC_TYPEBITS)-1)
#define _IOC_SIZEMASK ((1 << _IOC_SIZEBITS)-1)
#define _IOC_DIRMASK ((1 << _IOC_DIRBITS)-1)
#define _IOC_NRSHIFT 0
#define _IOC_TYPESHIFT (_IOC_NRSHIFT+_IOC_NRBITS)
#define _IOC_SIZESHIFT (_IOC_TYPESHIFT+_IOC_TYPEBITS)
#define _IOC_DIRSHIFT (_IOC_SIZESHIFT+_IOC_SIZEBITS)
#define _IOC_NONE 0U
#define _IOC_WRITE 1U
#define _IOC_READ 2U
#define _IOC(dir,type,nr,size) (((dir) << _IOC_DIRSHIFT) | ((type) << _IOC_TYPESHIFT) | ((nr) << _IOC_NRSHIFT) | ((size) << _IOC_SIZESHIFT))
#define _IOC_TYPECHECK(t) (sizeof(t))
#define _IO(type,nr) _IOC(_IOC_NONE,(type),(nr),0)
#define _IOR(type,nr,size) _IOC(_IOC_READ,(type),(nr),(_IOC_TYPECHECK(size)))
#define _IOW(type,nr,size) _IOC(_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(size)))
#define _IOWR(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(size)))
#define _IOR_BAD(type,nr,size) _IOC(_IOC_READ,(type),(nr),sizeof(size))
#define _IOW_BAD(type,nr,size) _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
#define _IOWR_BAD(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))
#define _IOC_DIR(nr) (((nr) >> _IOC_DIRSHIFT) & _IOC_DIRMASK)
#define _IOC_TYPE(nr) (((nr) >> _IOC_TYPESHIFT) & _IOC_TYPEMASK)
#define _IOC_NR(nr) (((nr) >> _IOC_NRSHIFT) & _IOC_NRMASK)
#define _IOC_SIZE(nr) (((nr) >> _IOC_SIZESHIFT) & _IOC_SIZEMASK)
#define IOC_IN (_IOC_WRITE << _IOC_DIRSHIFT)
#define IOC_OUT (_IOC_READ << _IOC_DIRSHIFT)
#define IOC_INOUT ((_IOC_WRITE|_IOC_READ) << _IOC_DIRSHIFT)
#define IOCSIZE_MASK (_IOC_SIZEMASK << _IOC_SIZESHIFT)
#define IOCSIZE_SHIFT (_IOC_SIZESHIFT)
#define TCGETS 0x5401
#define TCSETS 0x5402
#define TCSETSW 0x5403
#define TCSETSF 0x5404
#define TCGETA 0x5405
#define TCSETA 0x5406
#define TCSETAW 0x5407
#define TCSETAF 0x5408
#define TCSBRK 0x5409
#define TCXONC 0x540A
#define TCFLSH 0x540B
#define TIOCEXCL 0x540C
#define TIOCNXCL 0x540D
#define TIOCSCTTY 0x540E
#define TIOCGPGRP 0x540F
#define TIOCSPGRP 0x5410
#define TIOCOUTQ 0x5411
#define TIOCSTI 0x5412
#define TIOCGWINSZ 0x5413
#define TIOCSWINSZ 0x5414
#define TIOCMGET 0x5415
#define TIOCMBIS 0x5416
#define TIOCMBIC 0x5417
#define TIOCMSET 0x5418
#define TIOCGSOFTCAR 0x5419
#define TIOCSSOFTCAR 0x541A
#define FIONREAD 0x541B
#define TIOCINQ FIONREAD
#define TIOCLINUX 0x541C
#define TIOCCONS 0x541D
#define TIOCGSERIAL 0x541E
#define TIOCSSERIAL 0x541F
#define TIOCPKT 0x5420
#define FIONBIO 0x5421
#define TIOCNOTTY 0x5422
#define TIOCSETD 0x5423
#define TIOCGETD 0x5424
#define TCSBRKP 0x5425
#define TIOCSBRK 0x5427
#define TIOCCBRK 0x5428
#define TIOCGSID 0x5429
#define TCGETS2 _IOR('T', 0x2A, struct termios2)
#define TCSETS2 _IOW('T', 0x2B, struct termios2)
#define TCSETSW2 _IOW('T', 0x2C, struct termios2)
#define TCSETSF2 _IOW('T', 0x2D, struct termios2)
#define TIOCGRS485 0x542E
#define TIOCSRS485 0x542F
#define TIOCGPTN _IOR('T', 0x30, unsigned int)
#define TIOCSPTLCK _IOW('T', 0x31, int)
#define TIOCGDEV _IOR('T', 0x32, unsigned int)
#define TCGETX 0x5432
#define TCSETX 0x5433
#define TCSETXF 0x5434
#define TCSETXW 0x5435
#define TIOCSIG _IOW('T', 0x36, int)
#define TIOCVHANGUP 0x5437
#define TIOCGPKT _IOR('T', 0x38, int)
#define TIOCGPTLCK _IOR('T', 0x39, int)
#define TIOCGEXCL _IOR('T', 0x40, int)
#define FIONCLEX 0x5450
#define FIOCLEX 0x5451
#define FIOASYNC 0x5452
#define TIOCSERCONFIG 0x5453
#define TIOCSERGWILD 0x5454
#define TIOCSERSWILD 0x5455
#define TIOCGLCKTRMIOS 0x5456
#define TIOCSLCKTRMIOS 0x5457
#define TIOCSERGSTRUCT 0x5458
#define TIOCSERGETLSR 0x5459
#define TIOCSERGETMULTI 0x545A
#define TIOCSERSETMULTI 0x545B
#define TIOCMIWAIT 0x545C
#define TIOCGICOUNT 0x545D
#define FIOQSIZE 0x5460
#define TIOCPKT_DATA 0
#define TIOCPKT_FLUSHREAD 1
#define TIOCPKT_FLUSHWRITE 2
#define TIOCPKT_STOP 4
#define TIOCPKT_START 8
#define TIOCPKT_NOSTOP 16
#define TIOCPKT_DOSTOP 32
#define TIOCPKT_IOCTL 64
#define TIOCSER_TEMT 0x01
#define SIOCADDRT 0x890B
#define SIOCDELRT 0x890C
#define SIOCRTMSG 0x890D
#define SIOCGIFNAME 0x8910
#define SIOCSIFLINK 0x8911
#define SIOCGIFCONF 0x8912
#define SIOCGIFFLAGS 0x8913
#define SIOCSIFFLAGS 0x8914
#define SIOCGIFADDR 0x8915
#define SIOCSIFADDR 0x8916
#define SIOCGIFDSTADDR 0x8917
#define SIOCSIFDSTADDR 0x8918
#define SIOCGIFBRDADDR 0x8919
#define SIOCSIFBRDADDR 0x891a
#define SIOCGIFNETMASK 0x891b
#define SIOCSIFNETMASK 0x891c
#define SIOCGIFMETRIC 0x891d
#define SIOCSIFMETRIC 0x891e
#define SIOCGIFMEM 0x891f
#define SIOCSIFMEM 0x8920
#define SIOCGIFMTU 0x8921
#define SIOCSIFMTU 0x8922
#define SIOCSIFNAME 0x8923
#define SIOCSIFHWADDR 0x8924
#define SIOCGIFENCAP 0x8925
#define SIOCSIFENCAP 0x8926
#define SIOCGIFHWADDR 0x8927
#define SIOCGIFSLAVE 0x8929
#define SIOCSIFSLAVE 0x8930
#define SIOCADDMULTI 0x8931
#define SIOCDELMULTI 0x8932
#define SIOCGIFINDEX 0x8933
#define SIOGIFINDEX SIOCGIFINDEX
#define SIOCSIFPFLAGS 0x8934
#define SIOCGIFPFLAGS 0x8935
#define SIOCDIFADDR 0x8936
#define SIOCSIFHWBROADCAST 0x8937
#define SIOCGIFCOUNT 0x8938
#define SIOCGIFBR 0x8940
#define SIOCSIFBR 0x8941
#define SIOCGIFTXQLEN 0x8942
#define SIOCSIFTXQLEN 0x8943
#define SIOCDARP 0x8953
#define SIOCGARP 0x8954
#define SIOCSARP 0x8955
#define SIOCDRARP 0x8960
#define SIOCGRARP 0x8961
#define SIOCSRARP 0x8962
#define SIOCGIFMAP 0x8970
#define SIOCSIFMAP 0x8971
#define SIOCADDDLCI 0x8980
#define SIOCDELDLCI 0x8981
#define SIOCDEVPRIVATE 0x89F0
#define SIOCPROTOPRIVATE 0x89E0
struct winsize
{
unsigned short int ws_row;
unsigned short int ws_col;
unsigned short int ws_xpixel;
unsigned short int ws_ypixel;
};
#define NCC 8
struct termio
{
unsigned short int c_iflag;
unsigned short int c_oflag;
unsigned short int c_cflag;
unsigned short int c_lflag;
unsigned char c_line;
unsigned char c_cc[8];
};
#define TIOCM_LE 0x001
#define TIOCM_DTR 0x002
#define TIOCM_RTS 0x004
#define TIOCM_ST 0x008
#define TIOCM_SR 0x010
#define TIOCM_CTS 0x020
#define TIOCM_CAR 0x040
#define TIOCM_RNG 0x080
#define TIOCM_DSR 0x100
#define TIOCM_CD TIOCM_CAR
#define TIOCM_RI TIOCM_RNG
#define N_TTY 0
#define N_SLIP 1
#define N_MOUSE 2
#define N_PPP 3
#define N_STRIP 4
#define N_AX25 5
#define N_X25 6
#define N_6PACK 7
#define N_MASC 8
#define N_R3964 9
#define N_PROFIBUS_FDL 10
#define N_IRDA 11
#define N_SMSBLOCK 12
#define N_HDLC 13
#define N_SYNC_PPP 14
#define N_HCI 15
#define _SYS_TTYDEFAULTS_H_
#define TTYDEF_IFLAG (BRKINT | ISTRIP | ICRNL | IMAXBEL | IXON | IXANY)
#define TTYDEF_OFLAG (OPOST | ONLCR | XTABS)
#define TTYDEF_LFLAG (ECHO | ICANON | ISIG | IEXTEN | ECHOE|ECHOKE|ECHOCTL)
#define TTYDEF_CFLAG (CREAD | CS7 | PARENB | HUPCL)
#define TTYDEF_SPEED (B9600)
#define CTRL(x) (x&037)
#define CEOF CTRL('d')
#define CEOL _POSIX_VDISABLE
#define CERASE 0177
#define CINTR CTRL('c')
#define CSTATUS _POSIX_VDISABLE
#define CKILL CTRL('u')
#define CMIN 1
#define CQUIT 034
#define CSUSP CTRL('z')
#define CTIME 0
#define CDSUSP CTRL('y')
#define CSTART CTRL('q')
#define CSTOP CTRL('s')
#define CLNEXT CTRL('v')
#define CDISCARD CTRL('o')
#define CWERASE CTRL('w')
#define CREPRINT CTRL('r')
#define CEOT CEOF
#define CBRK CEOL
#define CRPRNT CREPRINT
#define CFLUSH CDISCARD
extern int ioctl (int __fd, unsigned long int __request, ...) throw ();
}
#define _SYS_POLL_H 1
#define POLLIN 0x001
#define POLLPRI 0x002
#define POLLOUT 0x004
#define POLLRDNORM 0x040
#define POLLRDBAND 0x080
#define POLLWRNORM 0x100
#define POLLWRBAND 0x200
#define POLLMSG 0x400
#define POLLREMOVE 0x1000
#define POLLRDHUP 0x2000
#define POLLERR 0x008
#define POLLHUP 0x010
#define POLLNVAL 0x020
#define __need_timespec
typedef unsigned long int nfds_t;
struct pollfd
{
int fd;
short int events;
short int revents;
};
extern "C" {
extern int poll (struct pollfd *__fds, nfds_t __nfds, int __timeout);
extern int ppoll (struct pollfd *__fds, nfds_t __nfds,
const struct timespec *__timeout,
const __sigset_t *__ss);
}
#define _SYS_UN_H 1
extern "C" {
struct sockaddr_un
{
sa_family_t sun_family;
char sun_path[108];
};
#define _STRING_H 1
extern "C" {
#define __need_size_t
#define __need_NULL
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define __CORRECT_ISO_CPP_STRING_H_PROTO
extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *memmove (void *__dest, const void *__src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
int __c, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern int memcmp (const void *__s1, const void *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++"
{
extern void *memchr (void *__s, int __c, size_t __n)
throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const void *memchr (const void *__s, int __c, size_t __n)
throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
}
extern "C++" void *rawmemchr (void *__s, int __c)
throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const void *rawmemchr (const void *__s, int __c)
throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" void *memrchr (void *__s, int __c, size_t __n)
throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const void *memrchr (const void *__s, int __c, size_t __n)
throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strncpy (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strcat (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strncat (char *__restrict __dest, const char *__restrict __src,
size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int strcmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strncmp (const char *__s1, const char *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strcoll (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern size_t strxfrm (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (2)));
extern int strcoll_l (const char *__s1, const char *__s2, __locale_t __l)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
__locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));
extern char *strdup (const char *__s)
throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
extern char *strndup (const char *__string, size_t __n)
throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
#define strdupa(s) (__extension__ ({ const char *__old = (s); size_t __len = strlen (__old) + 1; char *__new = (char *) __builtin_alloca (__len); (char *) memcpy (__new, __old, __len); }))
#define strndupa(s,n) (__extension__ ({ const char *__old = (s); size_t __len = strnlen (__old, (n)); char *__new = (char *) __builtin_alloca (__len + 1); __new[__len] = '\0'; (char *) memcpy (__new, __old, __len); }))
extern "C++"
{
extern char *strchr (char *__s, int __c)
throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *strchr (const char *__s, int __c)
throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
}
extern "C++"
{
extern char *strrchr (char *__s, int __c)
throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *strrchr (const char *__s, int __c)
throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
}
extern "C++" char *strchrnul (char *__s, int __c)
throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const char *strchrnul (const char *__s, int __c)
throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern size_t strcspn (const char *__s, const char *__reject)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern size_t strspn (const char *__s, const char *__accept)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++"
{
extern char *strpbrk (char *__s, const char *__accept)
throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern const char *strpbrk (const char *__s, const char *__accept)
throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
}
extern "C++"
{
extern char *strstr (char *__haystack, const char *__needle)
throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern const char *strstr (const char *__haystack, const char *__needle)
throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
}
extern char *strtok (char *__restrict __s, const char *__restrict __delim)
throw () __attribute__ ((__nonnull__ (2)));
extern char *__strtok_r (char *__restrict __s,
const char *__restrict __delim,
char **__restrict __save_ptr)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
char **__restrict __save_ptr)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern "C++" char *strcasestr (char *__haystack, const char *__needle)
throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++" const char *strcasestr (const char *__haystack,
const char *__needle)
throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern void *memmem (const void *__haystack, size_t __haystacklen,
const void *__needle, size_t __needlelen)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));
extern void *__mempcpy (void *__restrict __dest,
const void *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *mempcpy (void *__restrict __dest,
const void *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern size_t strlen (const char *__s)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern size_t strnlen (const char *__string, size_t __maxlen)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern char *strerror (int __errnum) throw ();
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2))) ;
extern char *strerror_l (int __errnum, __locale_t __l) throw ();
extern void __bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern void bcopy (const void *__src, void *__dest, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern int bcmp (const void *__s1, const void *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++"
{
extern char *index (char *__s, int __c)
throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *index (const char *__s, int __c)
throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
}
extern "C++"
{
extern char *rindex (char *__s, int __c)
throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *rindex (const char *__s, int __c)
throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
}
extern int ffs (int __i) throw () __attribute__ ((__const__));
extern int ffsl (long int __l) throw () __attribute__ ((__const__));
__extension__ extern int ffsll (long long int __ll)
throw () __attribute__ ((__const__));
extern int strcasecmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strcasecmp_l (const char *__s1, const char *__s2,
__locale_t __loc)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
extern int strncasecmp_l (const char *__s1, const char *__s2,
size_t __n, __locale_t __loc)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
extern char *strsep (char **__restrict __stringp,
const char *__restrict __delim)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strsignal (int __sig) throw ();
extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *__stpncpy (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpncpy (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int strverscmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));
extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern "C++" char *basename (char *__filename)
throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
extern "C++" const char *basename (const char *__filename)
throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
}
#define SUN_LEN(ptr) ((size_t) (((struct sockaddr_un *) 0)->sun_path) + strlen ((ptr)->sun_path))
}
#define _NETINET_TCP_H 1
#define TCP_NODELAY 1
#define TCP_MAXSEG 2
#define TCP_CORK 3
#define TCP_KEEPIDLE 4
#define TCP_KEEPINTVL 5
#define TCP_KEEPCNT 6
#define TCP_SYNCNT 7
#define TCP_LINGER2 8
#define TCP_DEFER_ACCEPT 9
#define TCP_WINDOW_CLAMP 10
#define TCP_INFO 11
#define TCP_QUICKACK 12
#define TCP_CONGESTION 13
#define TCP_MD5SIG 14
#define TCP_COOKIE_TRANSACTIONS 15
#define TCP_THIN_LINEAR_TIMEOUTS 16
#define TCP_THIN_DUPACK 17
#define TCP_USER_TIMEOUT 18
#define TCP_REPAIR 19
#define TCP_REPAIR_QUEUE 20
#define TCP_QUEUE_SEQ 21
#define TCP_REPAIR_OPTIONS 22
#define TCP_FASTOPEN 23
#define TCP_TIMESTAMP 24
typedef u_int32_t tcp_seq;
struct tcphdr
{
__extension__ union
{
struct
{
u_int16_t th_sport;
u_int16_t th_dport;
tcp_seq th_seq;
tcp_seq th_ack;
u_int8_t th_x2:4;
u_int8_t th_off:4;
u_int8_t th_flags;
#define TH_FIN 0x01
#define TH_SYN 0x02
#define TH_RST 0x04
#define TH_PUSH 0x08
#define TH_ACK 0x10
#define TH_URG 0x20
u_int16_t th_win;
u_int16_t th_sum;
u_int16_t th_urp;
};
struct
{
u_int16_t source;
u_int16_t dest;
u_int32_t seq;
u_int32_t ack_seq;
u_int16_t res1:4;
u_int16_t doff:4;
u_int16_t fin:1;
u_int16_t syn:1;
u_int16_t rst:1;
u_int16_t psh:1;
u_int16_t ack:1;
u_int16_t urg:1;
u_int16_t res2:2;
u_int16_t window;
u_int16_t check;
u_int16_t urg_ptr;
};
};
};
enum
{
TCP_ESTABLISHED = 1,
TCP_SYN_SENT,
TCP_SYN_RECV,
TCP_FIN_WAIT1,
TCP_FIN_WAIT2,
TCP_TIME_WAIT,
TCP_CLOSE,
TCP_CLOSE_WAIT,
TCP_LAST_ACK,
TCP_LISTEN,
TCP_CLOSING
};
#define TCPOPT_EOL 0
#define TCPOPT_NOP 1
#define TCPOPT_MAXSEG 2
#define TCPOLEN_MAXSEG 4
#define TCPOPT_WINDOW 3
#define TCPOLEN_WINDOW 3
#define TCPOPT_SACK_PERMITTED 4
#define TCPOLEN_SACK_PERMITTED 2
#define TCPOPT_SACK 5
#define TCPOPT_TIMESTAMP 8
#define TCPOLEN_TIMESTAMP 10
#define TCPOLEN_TSTAMP_APPA (TCPOLEN_TIMESTAMP+2)
#define TCPOPT_TSTAMP_HDR (TCPOPT_NOP<<24|TCPOPT_NOP<<16|TCPOPT_TIMESTAMP<<8|TCPOLEN_TIMESTAMP)
#define TCP_MSS 512
#define TCP_MAXWIN 65535
#define TCP_MAX_WINSHIFT 14
#define SOL_TCP 6
#define TCPI_OPT_TIMESTAMPS 1
#define TCPI_OPT_SACK 2
#define TCPI_OPT_WSCALE 4
#define TCPI_OPT_ECN 8
#define TCPI_OPT_ECN_SEEN 16
#define TCPI_OPT_SYN_DATA 32
enum tcp_ca_state
{
TCP_CA_Open = 0,
TCP_CA_Disorder = 1,
TCP_CA_CWR = 2,
TCP_CA_Recovery = 3,
TCP_CA_Loss = 4
};
struct tcp_info
{
u_int8_t tcpi_state;
u_int8_t tcpi_ca_state;
u_int8_t tcpi_retransmits;
u_int8_t tcpi_probes;
u_int8_t tcpi_backoff;
u_int8_t tcpi_options;
u_int8_t tcpi_snd_wscale : 4, tcpi_rcv_wscale : 4;
u_int32_t tcpi_rto;
u_int32_t tcpi_ato;
u_int32_t tcpi_snd_mss;
u_int32_t tcpi_rcv_mss;
u_int32_t tcpi_unacked;
u_int32_t tcpi_sacked;
u_int32_t tcpi_lost;
u_int32_t tcpi_retrans;
u_int32_t tcpi_fackets;
u_int32_t tcpi_last_data_sent;
u_int32_t tcpi_last_ack_sent;
u_int32_t tcpi_last_data_recv;
u_int32_t tcpi_last_ack_recv;
u_int32_t tcpi_pmtu;
u_int32_t tcpi_rcv_ssthresh;
u_int32_t tcpi_rtt;
u_int32_t tcpi_rttvar;
u_int32_t tcpi_snd_ssthresh;
u_int32_t tcpi_snd_cwnd;
u_int32_t tcpi_advmss;
u_int32_t tcpi_reordering;
u_int32_t tcpi_rcv_rtt;
u_int32_t tcpi_rcv_space;
u_int32_t tcpi_total_retrans;
};
#define TCP_MD5SIG_MAXKEYLEN 80
struct tcp_md5sig
{
struct sockaddr_storage tcpm_addr;
u_int16_t __tcpm_pad1;
u_int16_t tcpm_keylen;
u_int32_t __tcpm_pad2;
u_int8_t tcpm_key[80];
};
struct tcp_repair_opt
{
u_int32_t opt_code;
u_int32_t opt_val;
};
enum
{
TCP_NO_QUEUE,
TCP_RECV_QUEUE,
TCP_SEND_QUEUE,
TCP_QUEUES_NR,
};
#define TCP_COOKIE_MIN 8
#define TCP_COOKIE_MAX 16
#define TCP_COOKIE_PAIR_SIZE (2*TCP_COOKIE_MAX)
#define TCP_COOKIE_IN_ALWAYS (1 << 0)
#define TCP_COOKIE_OUT_NEVER (1 << 1)
#define TCP_S_DATA_IN (1 << 2)
#define TCP_S_DATA_OUT (1 << 3)
#define TCP_MSS_DEFAULT 536U
#define TCP_MSS_DESIRED 1220U
struct tcp_cookie_transactions
{
u_int16_t tcpct_flags;
u_int8_t __tcpct_pad1;
u_int8_t tcpct_cookie_desired;
u_int16_t tcpct_s_data_desired;
u_int16_t tcpct_used;
u_int8_t tcpct_value[536U];
};
#define _ARPA_INET_H 1
extern "C" {
extern in_addr_t inet_addr (const char *__cp) throw ();
extern in_addr_t inet_lnaof (struct in_addr __in) throw ();
extern struct in_addr inet_makeaddr (in_addr_t __net, in_addr_t __host)
throw ();
extern in_addr_t inet_netof (struct in_addr __in) throw ();
extern in_addr_t inet_network (const char *__cp) throw ();
extern char *inet_ntoa (struct in_addr __in) throw ();
extern int inet_pton (int __af, const char *__restrict __cp,
void *__restrict __buf) throw ();
extern const char *inet_ntop (int __af, const void *__restrict __cp,
char *__restrict __buf, socklen_t __len)
throw ();
extern int inet_aton (const char *__cp, struct in_addr *__inp) throw ();
extern char *inet_neta (in_addr_t __net, char *__buf, size_t __len) throw ();
extern char *inet_net_ntop (int __af, const void *__cp, int __bits,
char *__buf, size_t __len) throw ();
extern int inet_net_pton (int __af, const char *__cp,
void *__buf, size_t __len) throw ();
extern unsigned int inet_nsap_addr (const char *__cp,
unsigned char *__buf, int __len) throw ();
extern char *inet_nsap_ntoa (int __len, const unsigned char *__cp,
char *__buf) throw ();
}
#define _NET_IF_H 1
#define IF_NAMESIZE 16
struct if_nameindex
{
unsigned int if_index;
char *if_name;
};
enum
{
IFF_UP = 0x1,
#define IFF_UP IFF_UP
IFF_BROADCAST = 0x2,
#define IFF_BROADCAST IFF_BROADCAST
IFF_DEBUG = 0x4,
#define IFF_DEBUG IFF_DEBUG
IFF_LOOPBACK = 0x8,
#define IFF_LOOPBACK IFF_LOOPBACK
IFF_POINTOPOINT = 0x10,
#define IFF_POINTOPOINT IFF_POINTOPOINT
IFF_NOTRAILERS = 0x20,
#define IFF_NOTRAILERS IFF_NOTRAILERS
IFF_RUNNING = 0x40,
#define IFF_RUNNING IFF_RUNNING
IFF_NOARP = 0x80,
#define IFF_NOARP IFF_NOARP
IFF_PROMISC = 0x100,
#define IFF_PROMISC IFF_PROMISC
IFF_ALLMULTI = 0x200,
#define IFF_ALLMULTI IFF_ALLMULTI
IFF_MASTER = 0x400,
#define IFF_MASTER IFF_MASTER
IFF_SLAVE = 0x800,
#define IFF_SLAVE IFF_SLAVE
IFF_MULTICAST = 0x1000,
#define IFF_MULTICAST IFF_MULTICAST
IFF_PORTSEL = 0x2000,
#define IFF_PORTSEL IFF_PORTSEL
IFF_AUTOMEDIA = 0x4000,
#define IFF_AUTOMEDIA IFF_AUTOMEDIA
IFF_DYNAMIC = 0x8000
#define IFF_DYNAMIC IFF_DYNAMIC
};
struct ifaddr
{
struct sockaddr ifa_addr;
union
{
struct sockaddr ifu_broadaddr;
struct sockaddr ifu_dstaddr;
} ifa_ifu;
struct iface *ifa_ifp;
struct ifaddr *ifa_next;
};
#define ifa_broadaddr ifa_ifu.ifu_broadaddr
#define ifa_dstaddr ifa_ifu.ifu_dstaddr
struct ifmap
{
unsigned long int mem_start;
unsigned long int mem_end;
unsigned short int base_addr;
unsigned char irq;
unsigned char dma;
unsigned char port;
};
struct ifreq
{
#define IFHWADDRLEN 6
#define IFNAMSIZ IF_NAMESIZE
union
{
char ifrn_name[16];
} ifr_ifrn;
union
{
struct sockaddr ifru_addr;
struct sockaddr ifru_dstaddr;
struct sockaddr ifru_broadaddr;
struct sockaddr ifru_netmask;
struct sockaddr ifru_hwaddr;
short int ifru_flags;
int ifru_ivalue;
int ifru_mtu;
struct ifmap ifru_map;
char ifru_slave[16];
char ifru_newname[16];
__caddr_t ifru_data;
} ifr_ifru;
};
#define ifr_name ifr_ifrn.ifrn_name
#define ifr_hwaddr ifr_ifru.ifru_hwaddr
#define ifr_addr ifr_ifru.ifru_addr
#define ifr_dstaddr ifr_ifru.ifru_dstaddr
#define ifr_broadaddr ifr_ifru.ifru_broadaddr
#define ifr_netmask ifr_ifru.ifru_netmask
#define ifr_flags ifr_ifru.ifru_flags
#define ifr_metric ifr_ifru.ifru_ivalue
#define ifr_mtu ifr_ifru.ifru_mtu
#define ifr_map ifr_ifru.ifru_map
#define ifr_slave ifr_ifru.ifru_slave
#define ifr_data ifr_ifru.ifru_data
#define ifr_ifindex ifr_ifru.ifru_ivalue
#define ifr_bandwidth ifr_ifru.ifru_ivalue
#define ifr_qlen ifr_ifru.ifru_ivalue
#define ifr_newname ifr_ifru.ifru_newname
#define _IOT_ifreq _IOT(_IOTS(char),IFNAMSIZ,_IOTS(char),16,0,0)
#define _IOT_ifreq_short _IOT(_IOTS(char),IFNAMSIZ,_IOTS(short),1,0,0)
#define _IOT_ifreq_int _IOT(_IOTS(char),IFNAMSIZ,_IOTS(int),1,0,0)
struct ifconf
{
int ifc_len;
union
{
__caddr_t ifcu_buf;
struct ifreq *ifcu_req;
} ifc_ifcu;
};
#define ifc_buf ifc_ifcu.ifcu_buf
#define ifc_req ifc_ifcu.ifcu_req
#define _IOT_ifconf _IOT(_IOTS(struct ifconf),1,0,0,0,0)
extern "C" {
extern unsigned int if_nametoindex (const char *__ifname) throw ();
extern char *if_indextoname (unsigned int __ifindex, char *__ifname) throw ();
extern struct if_nameindex *if_nameindex (void) throw ();
extern void if_freenameindex (struct if_nameindex *__ptr) throw ();
}
namespace boost {
namespace asio {
namespace detail {
typedef int socket_type;
const int invalid_socket = -1;
const int socket_error_retval = -1;
const int max_addr_v4_str_len = 16;
const int max_addr_v6_str_len = 46 + 1 + 16;
typedef sockaddr socket_addr_type;
typedef in_addr in4_addr_type;
typedef ip_mreq in4_mreq_type;
typedef sockaddr_in sockaddr_in4_type;
typedef in6_addr in6_addr_type;
typedef ipv6_mreq in6_mreq_type;
typedef sockaddr_in6 sockaddr_in6_type;
typedef sockaddr_storage sockaddr_storage_type;
typedef sockaddr_un sockaddr_un_type;
typedef addrinfo addrinfo_type;
typedef ::linger linger_type;
typedef int ioctl_arg_type;
typedef uint32_t u_long_type;
typedef uint16_t u_short_type;
typedef ssize_t signed_size_type;
#define BOOST_ASIO_OS_DEF(c) BOOST_ASIO_OS_DEF_ ##c
#define BOOST_ASIO_OS_DEF_AF_UNSPEC AF_UNSPEC
#define BOOST_ASIO_OS_DEF_AF_INET AF_INET
#define BOOST_ASIO_OS_DEF_AF_INET6 AF_INET6
#define BOOST_ASIO_OS_DEF_SOCK_STREAM SOCK_STREAM
#define BOOST_ASIO_OS_DEF_SOCK_DGRAM SOCK_DGRAM
#define BOOST_ASIO_OS_DEF_SOCK_RAW SOCK_RAW
#define BOOST_ASIO_OS_DEF_SOCK_SEQPACKET SOCK_SEQPACKET
#define BOOST_ASIO_OS_DEF_IPPROTO_IP IPPROTO_IP
#define BOOST_ASIO_OS_DEF_IPPROTO_IPV6 IPPROTO_IPV6
#define BOOST_ASIO_OS_DEF_IPPROTO_TCP IPPROTO_TCP
#define BOOST_ASIO_OS_DEF_IPPROTO_UDP IPPROTO_UDP
#define BOOST_ASIO_OS_DEF_IPPROTO_ICMP IPPROTO_ICMP
#define BOOST_ASIO_OS_DEF_IPPROTO_ICMPV6 IPPROTO_ICMPV6
#define BOOST_ASIO_OS_DEF_FIONBIO FIONBIO
#define BOOST_ASIO_OS_DEF_FIONREAD FIONREAD
#define BOOST_ASIO_OS_DEF_INADDR_ANY INADDR_ANY
#define BOOST_ASIO_OS_DEF_MSG_OOB MSG_OOB
#define BOOST_ASIO_OS_DEF_MSG_PEEK MSG_PEEK
#define BOOST_ASIO_OS_DEF_MSG_DONTROUTE MSG_DONTROUTE
#define BOOST_ASIO_OS_DEF_MSG_EOR MSG_EOR
#define BOOST_ASIO_OS_DEF_SHUT_RD SHUT_RD
#define BOOST_ASIO_OS_DEF_SHUT_WR SHUT_WR
#define BOOST_ASIO_OS_DEF_SHUT_RDWR SHUT_RDWR
#define BOOST_ASIO_OS_DEF_SOMAXCONN SOMAXCONN
#define BOOST_ASIO_OS_DEF_SOL_SOCKET SOL_SOCKET
#define BOOST_ASIO_OS_DEF_SO_BROADCAST SO_BROADCAST
#define BOOST_ASIO_OS_DEF_SO_DEBUG SO_DEBUG
#define BOOST_ASIO_OS_DEF_SO_DONTROUTE SO_DONTROUTE
#define BOOST_ASIO_OS_DEF_SO_KEEPALIVE SO_KEEPALIVE
#define BOOST_ASIO_OS_DEF_SO_LINGER SO_LINGER
#define BOOST_ASIO_OS_DEF_SO_SNDBUF SO_SNDBUF
#define BOOST_ASIO_OS_DEF_SO_RCVBUF SO_RCVBUF
#define BOOST_ASIO_OS_DEF_SO_SNDLOWAT SO_SNDLOWAT
#define BOOST_ASIO_OS_DEF_SO_RCVLOWAT SO_RCVLOWAT
#define BOOST_ASIO_OS_DEF_SO_REUSEADDR SO_REUSEADDR
#define BOOST_ASIO_OS_DEF_TCP_NODELAY TCP_NODELAY
#define BOOST_ASIO_OS_DEF_IP_MULTICAST_IF IP_MULTICAST_IF
#define BOOST_ASIO_OS_DEF_IP_MULTICAST_TTL IP_MULTICAST_TTL
#define BOOST_ASIO_OS_DEF_IP_MULTICAST_LOOP IP_MULTICAST_LOOP
#define BOOST_ASIO_OS_DEF_IP_ADD_MEMBERSHIP IP_ADD_MEMBERSHIP
#define BOOST_ASIO_OS_DEF_IP_DROP_MEMBERSHIP IP_DROP_MEMBERSHIP
#define BOOST_ASIO_OS_DEF_IP_TTL IP_TTL
#define BOOST_ASIO_OS_DEF_IPV6_UNICAST_HOPS IPV6_UNICAST_HOPS
#define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_IF IPV6_MULTICAST_IF
#define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_HOPS IPV6_MULTICAST_HOPS
#define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_LOOP IPV6_MULTICAST_LOOP
#define BOOST_ASIO_OS_DEF_IPV6_JOIN_GROUP IPV6_JOIN_GROUP
#define BOOST_ASIO_OS_DEF_IPV6_LEAVE_GROUP IPV6_LEAVE_GROUP
#define BOOST_ASIO_OS_DEF_AI_CANONNAME AI_CANONNAME
#define BOOST_ASIO_OS_DEF_AI_PASSIVE AI_PASSIVE
#define BOOST_ASIO_OS_DEF_AI_NUMERICHOST AI_NUMERICHOST
#define BOOST_ASIO_OS_DEF_AI_NUMERICSERV AI_NUMERICSERV
#define BOOST_ASIO_OS_DEF_AI_V4MAPPED AI_V4MAPPED
#define BOOST_ASIO_OS_DEF_AI_ALL AI_ALL
#define BOOST_ASIO_OS_DEF_AI_ADDRCONFIG AI_ADDRCONFIG
const int max_iov_len = 1024;
const int custom_socket_option_level = 0xA5100000;
const int enable_connection_aborted_option = 1;
const int always_fail_option = 2;
}
}
}
#define BOOST_ASIO_DETAIL_TIMER_QUEUE_BASE_HPP
namespace boost {
namespace asio {
namespace detail {
class timer_queue_base
: private noncopyable
{
public:
timer_queue_base() ;
virtual ~timer_queue_base() ;
virtual bool empty() const = 0;
virtual long wait_duration_msec(long max_duration) const = 0;
virtual long wait_duration_usec(long max_duration) const = 0;
virtual void get_ready_timers(op_queue<operation>& ops) = 0;
virtual void get_all_timers(op_queue<operation>& ops) = 0;
private:
friend class timer_queue_set;
timer_queue_base* next_;
};
template <typename Time_Traits>
class timer_queue;
}
}
}
#define BOOST_ASIO_DETAIL_TIMER_QUEUE_SET_HPP
namespace boost {
namespace asio {
namespace detail {
class timer_queue_set
{
public:
inline timer_queue_set();
inline void insert(timer_queue_base* q);
inline void erase(timer_queue_base* q);
inline bool all_empty() const;
inline long wait_duration_msec(long max_duration) const;
inline long wait_duration_usec(long max_duration) const;
inline void get_ready_timers(op_queue<operation>& ops);
inline void get_all_timers(op_queue<operation>& ops);
private:
timer_queue_base* first_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_TIMER_QUEUE_SET_IPP
namespace boost {
namespace asio {
namespace detail {
bool timer_queue_set::all_empty() const
{
for (timer_queue_base* p = first_; p; p = p->next_)
if (!p->empty())
return false;
return true;
}
}
}
}
#define BOOST_ASIO_DETAIL_WAIT_OP_HPP
namespace boost {
namespace asio {
namespace detail {
class wait_op
: public operation
{
public:
boost::system::error_code ec_;
protected:
wait_op(func_type func)
;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
class epoll_reactor
: public boost::asio::detail::service_base<epoll_reactor>
{
public:
enum op_types { read_op = 0, write_op = 1,
connect_op = 1, except_op = 2, max_ops = 3 };
class descriptor_state : operation
{
friend class epoll_reactor;
friend class object_pool_access;
descriptor_state* next_;
descriptor_state* prev_;
mutex mutex_;
epoll_reactor* reactor_;
int descriptor_;
uint32_t registered_events_;
op_queue<reactor_op> op_queue_[max_ops];
bool shutdown_;
inline descriptor_state();
void set_ready_events(uint32_t events) ;
inline operation* perform_io(uint32_t events);
inline static void do_complete(
io_service_impl* owner, operation* base,
const boost::system::error_code& ec, std::size_t bytes_transferred);
};
typedef descriptor_state* per_descriptor_data;
inline epoll_reactor(boost::asio::io_service& io_service);
inline ~epoll_reactor();
inline void shutdown_service();
inline void fork_service(
boost::asio::io_service::fork_event fork_ev);
inline void init_task();
inline int register_descriptor(socket_type descriptor,
per_descriptor_data& descriptor_data);
inline int register_internal_descriptor(
int op_type, socket_type descriptor,
per_descriptor_data& descriptor_data, reactor_op* op);
inline void move_descriptor(socket_type descriptor,
per_descriptor_data& target_descriptor_data,
per_descriptor_data& source_descriptor_data);
void post_immediate_completion(reactor_op* op, bool is_continuation)
;
inline void start_op(int op_type, socket_type descriptor,
per_descriptor_data& descriptor_data, reactor_op* op,
bool is_continuation, bool allow_speculative);
inline void cancel_ops(socket_type descriptor,
per_descriptor_data& descriptor_data);
inline void deregister_descriptor(socket_type descriptor,
per_descriptor_data& descriptor_data, bool closing);
inline void deregister_internal_descriptor(
socket_type descriptor, per_descriptor_data& descriptor_data);
template <typename Time_Traits>
void add_timer_queue(timer_queue<Time_Traits>& timer_queue);
template <typename Time_Traits>
void remove_timer_queue(timer_queue<Time_Traits>& timer_queue);
template <typename Time_Traits>
void schedule_timer(timer_queue<Time_Traits>& queue,
const typename Time_Traits::time_type& time,
typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op);
template <typename Time_Traits>
std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
typename timer_queue<Time_Traits>::per_timer_data& timer,
std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
inline void run(bool block, op_queue<operation>& ops);
inline void interrupt();
private:
enum { epoll_size = 20000 };
inline static int do_epoll_create();
inline static int do_timerfd_create();
inline descriptor_state* allocate_descriptor_state();
inline void free_descriptor_state(descriptor_state* s);
inline void do_add_timer_queue(timer_queue_base& queue);
inline void do_remove_timer_queue(timer_queue_base& queue);
inline void update_timeout();
inline int get_timeout();
inline int get_timeout(itimerspec& ts);
io_service_impl& io_service_;
mutex mutex_;
select_interrupter interrupter_;
int epoll_fd_;
int timer_fd_;
timer_queue_set timer_queues_;
bool shutdown_;
mutex registered_descriptors_mutex_;
object_pool<descriptor_state> registered_descriptors_;
struct perform_io_cleanup_on_block_exit;
friend struct perform_io_cleanup_on_block_exit;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_EPOLL_REACTOR_HPP
namespace boost {
namespace asio {
namespace detail {
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_EPOLL_REACTOR_IPP
#define _SYS_EPOLL_H 1
enum
{
EPOLL_CLOEXEC = 02000000
#define EPOLL_CLOEXEC EPOLL_CLOEXEC
};
#define __EPOLL_PACKED __attribute__ ((__packed__))
enum EPOLL_EVENTS
{
EPOLLIN = 0x001,
#define EPOLLIN EPOLLIN
EPOLLPRI = 0x002,
#define EPOLLPRI EPOLLPRI
EPOLLOUT = 0x004,
#define EPOLLOUT EPOLLOUT
EPOLLRDNORM = 0x040,
#define EPOLLRDNORM EPOLLRDNORM
EPOLLRDBAND = 0x080,
#define EPOLLRDBAND EPOLLRDBAND
EPOLLWRNORM = 0x100,
#define EPOLLWRNORM EPOLLWRNORM
EPOLLWRBAND = 0x200,
#define EPOLLWRBAND EPOLLWRBAND
EPOLLMSG = 0x400,
#define EPOLLMSG EPOLLMSG
EPOLLERR = 0x008,
#define EPOLLERR EPOLLERR
EPOLLHUP = 0x010,
#define EPOLLHUP EPOLLHUP
EPOLLRDHUP = 0x2000,
#define EPOLLRDHUP EPOLLRDHUP
EPOLLWAKEUP = 1u << 29,
#define EPOLLWAKEUP EPOLLWAKEUP
EPOLLONESHOT = 1u << 30,
#define EPOLLONESHOT EPOLLONESHOT
EPOLLET = 1u << 31
#define EPOLLET EPOLLET
};
#define EPOLL_CTL_ADD 1
#define EPOLL_CTL_DEL 2
#define EPOLL_CTL_MOD 3
typedef union epoll_data
{
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
struct epoll_event
{
uint32_t events;
epoll_data_t data;
} __attribute__ ((__packed__));
extern "C" {
extern int epoll_create (int __size) throw ();
extern int epoll_create1 (int __flags) throw ();
extern int epoll_ctl (int __epfd, int __op, int __fd,
struct epoll_event *__event) throw ();
extern int epoll_wait (int __epfd, struct epoll_event *__events,
int __maxevents, int __timeout);
extern int epoll_pwait (int __epfd, struct epoll_event *__events,
int __maxevents, int __timeout,
const __sigset_t *__ss);
}
#define _SYS_TIMERFD_H 1
enum
{
TFD_CLOEXEC = 02000000,
#define TFD_CLOEXEC TFD_CLOEXEC
TFD_NONBLOCK = 00004000
#define TFD_NONBLOCK TFD_NONBLOCK
};
enum
{
TFD_TIMER_ABSTIME = 1 << 0
#define TFD_TIMER_ABSTIME TFD_TIMER_ABSTIME
};
extern "C" {
extern int timerfd_create (clockid_t __clock_id, int __flags) throw ();
extern int timerfd_settime (int __ufd, int __flags,
const struct itimerspec *__utmr,
struct itimerspec *__otmr) throw ();
extern int timerfd_gettime (int __ufd, struct itimerspec *__otmr) throw ();
}
namespace boost {
namespace asio {
namespace detail {
struct epoll_reactor::perform_io_cleanup_on_block_exit
{
explicit perform_io_cleanup_on_block_exit(epoll_reactor* r)
;
~perform_io_cleanup_on_block_exit()
;
epoll_reactor* reactor_;
op_queue<operation> ops_;
operation* first_op_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
struct task_io_service::task_cleanup
{
~task_cleanup()
;
task_io_service* task_io_service_;
mutex::scoped_lock* lock_;
thread_info* this_thread_;
};
struct task_io_service::work_cleanup
{
~work_cleanup()
;
task_io_service* task_io_service_;
mutex::scoped_lock* lock_;
thread_info* this_thread_;
};
bool task_io_service::stopped() const
{
mutex::scoped_lock lock(mutex_);
return stopped_;
}
bool task_io_service::wake_one_idle_thread_and_unlock(
mutex::scoped_lock& lock)
{
if (first_idle_thread_)
{
thread_info* idle_thread = first_idle_thread_;
first_idle_thread_ = idle_thread->next;
idle_thread->next = 0;
idle_thread->wakeup_event->signal_and_unlock(lock);
return true;
}
return false;
}
}
}
}
namespace boost {
namespace asio {
}
}
#define BOOST_ASIO_IMPL_IO_SERVICE_IPP
#define BOOST_ASIO_DETAIL_SCOPED_PTR_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename T>
class scoped_ptr
{
public:
explicit scoped_ptr(T* p = 0)
;
~scoped_ptr()
;
T* get()
;
T* operator->()
;
T& operator*()
;
void reset(T* p = 0)
;
private:
scoped_ptr(const scoped_ptr&);
scoped_ptr& operator=(const scoped_ptr&);
T* p_;
};
}
}
}
namespace boost {
namespace asio {
bool io_service::stopped() const
{
return impl_.stopped();
}
}
}
namespace boost {
namespace asio {
namespace detail
{
template <typename IoObjectService>
class service_has_move
{
private:
typedef IoObjectService service_type;
typedef typename service_type::implementation_type implementation_type;
template <typename T, typename U>
static auto eval(T* t, U* u) -> decltype(t->move_construct(*u, *u), char());
static char (&eval(...))[2];
public:
static const bool value =
sizeof(service_has_move::eval(
static_cast<service_type*>(0),
static_cast<implementation_type*>(0))) == 1;
};
}
template <typename IoObjectService,
bool Movable = detail::service_has_move<IoObjectService>::value>
class basic_io_object
{
public:
typedef IoObjectService service_type;
typedef typename service_type::implementation_type implementation_type;
boost::asio::io_service& get_io_service()
;
protected:
explicit basic_io_object(boost::asio::io_service& io_service)
;
~basic_io_object()
;
service_type& get_service()
;
const service_type& get_service() const
;
service_type& service;
implementation_type& get_implementation()
;
const implementation_type& get_implementation() const
;
implementation_type implementation;
private:
basic_io_object(const basic_io_object&);
basic_io_object& operator=(const basic_io_object&);
};
template <typename IoObjectService>
class basic_io_object<IoObjectService, true>
{
public:
typedef IoObjectService service_type;
typedef typename service_type::implementation_type implementation_type;
boost::asio::io_service& get_io_service()
;
protected:
explicit basic_io_object(boost::asio::io_service& io_service)
;
basic_io_object(basic_io_object&& other)
;
~basic_io_object()
;
basic_io_object& operator=(basic_io_object&& other)
;
service_type& get_service()
;
const service_type& get_service() const
;
implementation_type& get_implementation()
;
const implementation_type& get_implementation() const
;
implementation_type implementation;
private:
basic_io_object(const basic_io_object&);
void operator=(const basic_io_object&);
IoObjectService* service_;
};
}
}
#define BOOST_ASIO_DETAIL_TYPE_TRAITS_HPP
namespace boost {
namespace asio {
using std::add_const;
using std::enable_if;
using std::is_const;
using std::is_convertible;
using std::is_function;
using std::is_same;
using std::remove_pointer;
using std::remove_reference;
}
}
#define BOOST_ASIO_SOCKET_BASE_HPP
#define BOOST_ASIO_DETAIL_IO_CONTROL_HPP
namespace boost {
namespace asio {
namespace detail {
namespace io_control {
class non_blocking_io
{
public:
non_blocking_io()
;
non_blocking_io(bool value)
;
int name() const
;
void set(bool value)
;
bool get() const
;
detail::ioctl_arg_type* data()
;
const detail::ioctl_arg_type* data() const
;
private:
detail::ioctl_arg_type value_;
};
class bytes_readable
{
public:
bytes_readable()
;
bytes_readable(std::size_t value)
;
int name() const
;
void set(std::size_t value)
;
std::size_t get() const
;
detail::ioctl_arg_type* data()
;
const detail::ioctl_arg_type* data() const
;
private:
detail::ioctl_arg_type value_;
};
}
}
}
}
#define BOOST_ASIO_DETAIL_SOCKET_OPTION_HPP
namespace boost {
namespace asio {
namespace detail {
namespace socket_option {
template <int Level, int Name>
class boolean
{
public:
boolean()
;
explicit boolean(bool v)
;
boolean& operator=(bool v)
;
bool value() const
;
operator bool() const
;
bool operator!() const
;
template <typename Protocol>
int level(const Protocol&) const
;
template <typename Protocol>
int name(const Protocol&) const
;
template <typename Protocol>
int* data(const Protocol&)
;
template <typename Protocol>
const int* data(const Protocol&) const
;
template <typename Protocol>
std::size_t size(const Protocol&) const
;
template <typename Protocol>
void resize(const Protocol&, std::size_t s)
;
private:
int value_;
};
template <int Level, int Name>
class integer
{
public:
integer()
;
explicit integer(int v)
;
integer& operator=(int v)
;
int value() const
;
template <typename Protocol>
int level(const Protocol&) const
;
template <typename Protocol>
int name(const Protocol&) const
;
template <typename Protocol>
int* data(const Protocol&)
;
template <typename Protocol>
const int* data(const Protocol&) const
;
template <typename Protocol>
std::size_t size(const Protocol&) const
;
template <typename Protocol>
void resize(const Protocol&, std::size_t s)
;
private:
int value_;
};
template <int Level, int Name>
class linger
{
public:
linger()
;
linger(bool e, int t)
;
void enabled(bool value)
;
bool enabled() const
;
void timeout (int value)
;
int timeout () const
;
template <typename Protocol>
int level(const Protocol&) const
;
template <typename Protocol>
int name(const Protocol&) const
;
template <typename Protocol>
detail::linger_type* data(const Protocol&)
;
template <typename Protocol>
const detail::linger_type* data(const Protocol&) const
;
template <typename Protocol>
std::size_t size(const Protocol&) const
;
template <typename Protocol>
void resize(const Protocol&, std::size_t s)
;
private:
detail::linger_type value_;
};
}
}
}
}
namespace boost {
namespace asio {
class socket_base
{
public:
enum shutdown_type
{
shutdown_receive = SHUT_RD,
shutdown_send = SHUT_WR,
shutdown_both = SHUT_RDWR
};
typedef int message_flags;
static const int message_peek = MSG_PEEK;
static const int message_out_of_band = MSG_OOB;
static const int message_do_not_route = MSG_DONTROUTE;
static const int message_end_of_record = MSG_EOR;
typedef boost::asio::detail::socket_option::boolean<
1, 6>
broadcast;
typedef boost::asio::detail::socket_option::boolean<
1, 1> debug;
typedef boost::asio::detail::socket_option::boolean<
1, 5>
do_not_route;
typedef boost::asio::detail::socket_option::boolean<
1, 9> keep_alive;
typedef boost::asio::detail::socket_option::integer<
1, 7>
send_buffer_size;
typedef boost::asio::detail::socket_option::integer<
1, 19>
send_low_watermark;
typedef boost::asio::detail::socket_option::integer<
1, 8>
receive_buffer_size;
typedef boost::asio::detail::socket_option::integer<
1, 18>
receive_low_watermark;
typedef boost::asio::detail::socket_option::boolean<
1, 2>
reuse_address;
typedef boost::asio::detail::socket_option::linger<
1, 13>
linger;
typedef boost::asio::detail::socket_option::boolean<
boost::asio::detail::custom_socket_option_level,
boost::asio::detail::enable_connection_aborted_option>
enable_connection_aborted;
typedef boost::asio::detail::io_control::non_blocking_io non_blocking_io;
typedef boost::asio::detail::io_control::bytes_readable bytes_readable;
static const int max_connections = 128;
protected:
~socket_base()
;
};
}
}
namespace boost {
namespace asio {
template <typename Protocol, typename SocketService>
class basic_socket
: public basic_io_object<SocketService>,
public socket_base
{
public:
typedef typename SocketService::native_handle_type native_type;
typedef typename SocketService::native_handle_type native_handle_type;
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
typedef basic_socket<Protocol, SocketService> lowest_layer_type;
explicit basic_socket(boost::asio::io_service& io_service)
;
basic_socket(boost::asio::io_service& io_service,
const protocol_type& protocol)
;
basic_socket(boost::asio::io_service& io_service,
const endpoint_type& endpoint)
;
basic_socket(boost::asio::io_service& io_service,
const protocol_type& protocol, const native_handle_type& native_socket)
;
basic_socket(basic_socket&& other)
;
basic_socket& operator=(basic_socket&& other)
;
template <typename Protocol1, typename SocketService1>
friend class basic_socket;
template <typename Protocol1, typename SocketService1>
basic_socket(basic_socket<Protocol1, SocketService1>&& other,
typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
;
template <typename Protocol1, typename SocketService1>
typename enable_if<is_convertible<Protocol1, Protocol>::value,
basic_socket>::type& operator=(
basic_socket<Protocol1, SocketService1>&& other)
;
lowest_layer_type& lowest_layer()
;
const lowest_layer_type& lowest_layer() const
;
void open(const protocol_type& protocol = protocol_type())
;
boost::system::error_code open(const protocol_type& protocol,
boost::system::error_code& ec)
;
void assign(const protocol_type& protocol,
const native_handle_type& native_socket)
;
boost::system::error_code assign(const protocol_type& protocol,
const native_handle_type& native_socket, boost::system::error_code& ec)
;
bool is_open() const
;
void close()
;
boost::system::error_code close(boost::system::error_code& ec)
;
native_type native()
;
native_handle_type native_handle()
;
void cancel()
;
boost::system::error_code cancel(boost::system::error_code& ec)
;
bool at_mark() const
;
bool at_mark(boost::system::error_code& ec) const
;
std::size_t available() const
;
std::size_t available(boost::system::error_code& ec) const
;
void bind(const endpoint_type& endpoint)
;
boost::system::error_code bind(const endpoint_type& endpoint,
boost::system::error_code& ec)
;
void connect(const endpoint_type& peer_endpoint)
;
boost::system::error_code connect(const endpoint_type& peer_endpoint,
boost::system::error_code& ec)
;
template <typename ConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ConnectHandler, void (boost::system::error_code)>::type>::type
async_connect(const endpoint_type& peer_endpoint,
ConnectHandler&& handler)
;
template <typename SettableSocketOption>
void set_option(const SettableSocketOption& option)
;
template <typename SettableSocketOption>
boost::system::error_code set_option(const SettableSocketOption& option,
boost::system::error_code& ec)
;
template <typename GettableSocketOption>
void get_option(GettableSocketOption& option) const
;
template <typename GettableSocketOption>
boost::system::error_code get_option(GettableSocketOption& option,
boost::system::error_code& ec) const
;
template <typename IoControlCommand>
void io_control(IoControlCommand& command)
;
template <typename IoControlCommand>
boost::system::error_code io_control(IoControlCommand& command,
boost::system::error_code& ec)
;
bool non_blocking() const
;
void non_blocking(bool mode)
;
boost::system::error_code non_blocking(
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking() const
;
void native_non_blocking(bool mode)
;
boost::system::error_code native_non_blocking(
bool mode, boost::system::error_code& ec)
;
endpoint_type local_endpoint() const
;
endpoint_type local_endpoint(boost::system::error_code& ec) const
;
endpoint_type remote_endpoint() const
;
endpoint_type remote_endpoint(boost::system::error_code& ec) const
;
void shutdown(shutdown_type what)
;
boost::system::error_code shutdown(shutdown_type what,
boost::system::error_code& ec)
;
protected:
~basic_socket()
;
};
}
}
#define BOOST_ASIO_DATAGRAM_SOCKET_SERVICE_HPP
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_HPP
#define BOOST_ASIO_BUFFER_HPP
#define _GLIBCXX_CSTRING 1
#undef memchr
#undef memcmp
#undef memcpy
#undef memmove
#undef memset
#undef strcat
#undef strchr
#undef strcmp
#undef strcoll
#undef strcpy
#undef strcspn
#undef strerror
#undef strlen
#undef strncat
#undef strncmp
#undef strncpy
#undef strpbrk
#undef strrchr
#undef strspn
#undef strstr
#undef strtok
#undef strxfrm
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::memchr;
using ::memcmp;
using ::memcpy;
using ::memmove;
using ::memset;
using ::strcat;
using ::strcmp;
using ::strcoll;
using ::strcpy;
using ::strcspn;
using ::strerror;
using ::strlen;
using ::strncat;
using ::strncmp;
using ::strncpy;
using ::strspn;
using ::strtok;
using ::strxfrm;
using ::strchr;
using ::strpbrk;
using ::strrchr;
using ::strstr;
}
#define BOOST_ASIO_DETAIL_ARRAY_FWD_HPP
namespace boost {
template<class T, std::size_t N>
class array;
}
namespace boost {
namespace asio {
class mutable_buffer;
class const_buffer;
namespace detail {
void* buffer_cast_helper(const mutable_buffer&);
const void* buffer_cast_helper(const const_buffer&);
std::size_t buffer_size_helper(const mutable_buffer&);
std::size_t buffer_size_helper(const const_buffer&);
}
class mutable_buffer
{
public:
mutable_buffer()
;
mutable_buffer(void* data, std::size_t size)
;
private:
friend void* boost::asio::detail::buffer_cast_helper(
const mutable_buffer& b);
friend std::size_t boost::asio::detail::buffer_size_helper(
const mutable_buffer& b);
void* data_;
std::size_t size_;
};
namespace detail {
void* buffer_cast_helper(const mutable_buffer& b)
;
std::size_t buffer_size_helper(const mutable_buffer& b)
;
}
class mutable_buffers_1
: public mutable_buffer
{
public:
typedef mutable_buffer value_type;
typedef const mutable_buffer* const_iterator;
mutable_buffers_1(void* data, std::size_t size)
;
explicit mutable_buffers_1(const mutable_buffer& b)
;
const_iterator begin() const
;
const_iterator end() const
;
};
class const_buffer
{
public:
const_buffer()
;
const_buffer(const void* data, std::size_t size)
;
const_buffer(const mutable_buffer& b)
;
private:
friend const void* boost::asio::detail::buffer_cast_helper(
const const_buffer& b);
friend std::size_t boost::asio::detail::buffer_size_helper(
const const_buffer& b);
const void* data_;
std::size_t size_;
};
namespace detail {
const void* buffer_cast_helper(const const_buffer& b)
;
std::size_t buffer_size_helper(const const_buffer& b)
;
}
class const_buffers_1
: public const_buffer
{
public:
typedef const_buffer value_type;
typedef const const_buffer* const_iterator;
const_buffers_1(const void* data, std::size_t size)
;
explicit const_buffers_1(const const_buffer& b)
;
const_iterator begin() const
;
const_iterator end() const
;
};
class null_buffers
{
public:
typedef mutable_buffer value_type;
typedef const mutable_buffer* const_iterator;
const_iterator begin() const
;
const_iterator end() const
;
private:
mutable_buffer buf_;
};
std::size_t buffer_size(const mutable_buffer& b)
;
std::size_t buffer_size(const mutable_buffers_1& b)
;
std::size_t buffer_size(const const_buffer& b)
;
std::size_t buffer_size(const const_buffers_1& b)
;
template <typename BufferSequence>
std::size_t buffer_size(const BufferSequence& b)
;
template <typename PointerToPodType>
PointerToPodType buffer_cast(const mutable_buffer& b)
;
template <typename PointerToPodType>
PointerToPodType buffer_cast(const const_buffer& b)
;
mutable_buffer operator+(const mutable_buffer& b, std::size_t start)
;
mutable_buffer operator+(std::size_t start, const mutable_buffer& b)
;
const_buffer operator+(const const_buffer& b, std::size_t start)
;
const_buffer operator+(std::size_t start, const const_buffer& b)
;
mutable_buffers_1 buffer(const mutable_buffer& b)
;
mutable_buffers_1 buffer(const mutable_buffer& b,
std::size_t max_size_in_bytes)
;
const_buffers_1 buffer(const const_buffer& b)
;
const_buffers_1 buffer(const const_buffer& b,
std::size_t max_size_in_bytes)
;
mutable_buffers_1 buffer(void* data, std::size_t size_in_bytes)
;
const_buffers_1 buffer(const void* data,
std::size_t size_in_bytes)
;
template <typename PodType, std::size_t N>
mutable_buffers_1 buffer(PodType (&data)[N])
;
template <typename PodType, std::size_t N>
mutable_buffers_1 buffer(PodType (&data)[N],
std::size_t max_size_in_bytes)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(const PodType (&data)[N])
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(const PodType (&data)[N],
std::size_t max_size_in_bytes)
;
template <typename PodType, std::size_t N>
mutable_buffers_1 buffer(boost::array<PodType, N>& data)
;
template <typename PodType, std::size_t N>
mutable_buffers_1 buffer(boost::array<PodType, N>& data,
std::size_t max_size_in_bytes)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(boost::array<const PodType, N>& data)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(boost::array<const PodType, N>& data,
std::size_t max_size_in_bytes)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(const boost::array<PodType, N>& data)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(const boost::array<PodType, N>& data,
std::size_t max_size_in_bytes)
;
template <typename PodType, std::size_t N>
mutable_buffers_1 buffer(std::array<PodType, N>& data)
;
template <typename PodType, std::size_t N>
mutable_buffers_1 buffer(std::array<PodType, N>& data,
std::size_t max_size_in_bytes)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(std::array<const PodType, N>& data)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(std::array<const PodType, N>& data,
std::size_t max_size_in_bytes)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(const std::array<PodType, N>& data)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(const std::array<PodType, N>& data,
std::size_t max_size_in_bytes)
;
template <typename PodType, typename Allocator>
mutable_buffers_1 buffer(std::vector<PodType, Allocator>& data)
;
template <typename PodType, typename Allocator>
mutable_buffers_1 buffer(std::vector<PodType, Allocator>& data,
std::size_t max_size_in_bytes)
;
template <typename PodType, typename Allocator>
const_buffers_1 buffer(
const std::vector<PodType, Allocator>& data)
;
template <typename PodType, typename Allocator>
const_buffers_1 buffer(
const std::vector<PodType, Allocator>& data, std::size_t max_size_in_bytes)
;
template <typename Elem, typename Traits, typename Allocator>
const_buffers_1 buffer(
const std::basic_string<Elem, Traits, Allocator>& data)
;
template <typename Elem, typename Traits, typename Allocator>
const_buffers_1 buffer(
const std::basic_string<Elem, Traits, Allocator>& data,
std::size_t max_size_in_bytes)
;
std::size_t buffer_copy(const mutable_buffer& target,
const const_buffer& source)
;
std::size_t buffer_copy(const mutable_buffer& target,
const const_buffers_1& source)
;
std::size_t buffer_copy(const mutable_buffer& target,
const mutable_buffer& source)
;
std::size_t buffer_copy(const mutable_buffer& target,
const mutable_buffers_1& source)
;
template <typename ConstBufferSequence>
std::size_t buffer_copy(const mutable_buffer& target,
const ConstBufferSequence& source)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const const_buffer& source)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const const_buffers_1& source)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const mutable_buffer& source)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const mutable_buffers_1& source)
;
template <typename ConstBufferSequence>
std::size_t buffer_copy(const mutable_buffers_1& target,
const ConstBufferSequence& source)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const const_buffer& source)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const const_buffers_1& source)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const mutable_buffer& source)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const mutable_buffers_1& source)
;
template <typename MutableBufferSequence, typename ConstBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const ConstBufferSequence& source)
;
std::size_t buffer_copy(const mutable_buffer& target,
const const_buffer& source, std::size_t max_bytes_to_copy)
;
std::size_t buffer_copy(const mutable_buffer& target,
const const_buffers_1& source, std::size_t max_bytes_to_copy)
;
std::size_t buffer_copy(const mutable_buffer& target,
const mutable_buffer& source, std::size_t max_bytes_to_copy)
;
std::size_t buffer_copy(const mutable_buffer& target,
const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
;
template <typename ConstBufferSequence>
std::size_t buffer_copy(const mutable_buffer& target,
const ConstBufferSequence& source, std::size_t max_bytes_to_copy)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const const_buffer& source, std::size_t max_bytes_to_copy)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const const_buffers_1& source, std::size_t max_bytes_to_copy)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const mutable_buffer& source, std::size_t max_bytes_to_copy)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
;
template <typename ConstBufferSequence>
std::size_t buffer_copy(const mutable_buffers_1& target,
const ConstBufferSequence& source, std::size_t max_bytes_to_copy)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const const_buffer& source, std::size_t max_bytes_to_copy)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const const_buffers_1& source, std::size_t max_bytes_to_copy)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const mutable_buffer& source, std::size_t max_bytes_to_copy)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
;
template <typename MutableBufferSequence, typename ConstBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const ConstBufferSequence& source, std::size_t max_bytes_to_copy)
;
}
}
#define BOOST_ASIO_DETAIL_BUFFER_SEQUENCE_ADAPTER_HPP
namespace boost {
namespace asio {
namespace detail {
class buffer_sequence_adapter_base
{
protected:
enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len };
typedef iovec native_buffer_type;
static void init_iov_base(void*& base, void* addr)
;
template <typename T>
static void init_iov_base(T& base, void* addr)
;
static void init_native_buffer(iovec& iov,
const boost::asio::mutable_buffer& buffer)
;
static void init_native_buffer(iovec& iov,
const boost::asio::const_buffer& buffer)
;
};
template <typename Buffer, typename Buffers>
class buffer_sequence_adapter
: buffer_sequence_adapter_base
{
public:
explicit buffer_sequence_adapter(const Buffers& buffer_sequence)
;
native_buffer_type* buffers()
;
std::size_t count() const
;
bool all_empty() const
;
static bool all_empty(const Buffers& buffer_sequence)
;
static void validate(const Buffers& buffer_sequence)
;
static Buffer first(const Buffers& buffer_sequence)
;
private:
native_buffer_type buffers_[max_buffers];
std::size_t count_;
std::size_t total_buffer_size_;
};
template <typename Buffer>
class buffer_sequence_adapter<Buffer, boost::asio::mutable_buffers_1>
: buffer_sequence_adapter_base
{
public:
explicit buffer_sequence_adapter(
const boost::asio::mutable_buffers_1& buffer_sequence)
;
native_buffer_type* buffers()
;
std::size_t count() const
;
bool all_empty() const
;
static bool all_empty(const boost::asio::mutable_buffers_1& buffer_sequence)
;
static void validate(const boost::asio::mutable_buffers_1& buffer_sequence)
;
static Buffer first(const boost::asio::mutable_buffers_1& buffer_sequence)
;
private:
native_buffer_type buffer_;
std::size_t total_buffer_size_;
};
template <typename Buffer>
class buffer_sequence_adapter<Buffer, boost::asio::const_buffers_1>
: buffer_sequence_adapter_base
{
public:
explicit buffer_sequence_adapter(
const boost::asio::const_buffers_1& buffer_sequence)
;
native_buffer_type* buffers()
;
std::size_t count() const
;
bool all_empty() const
;
static bool all_empty(const boost::asio::const_buffers_1& buffer_sequence)
;
static void validate(const boost::asio::const_buffers_1& buffer_sequence)
;
static Buffer first(const boost::asio::const_buffers_1& buffer_sequence)
;
private:
native_buffer_type buffer_;
std::size_t total_buffer_size_;
};
template <typename Buffer, typename Elem>
class buffer_sequence_adapter<Buffer, boost::array<Elem, 2> >
: buffer_sequence_adapter_base
{
public:
explicit buffer_sequence_adapter(
const boost::array<Elem, 2>& buffer_sequence)
;
native_buffer_type* buffers()
;
std::size_t count() const
;
bool all_empty() const
;
static bool all_empty(const boost::array<Elem, 2>& buffer_sequence)
;
static void validate(const boost::array<Elem, 2>& buffer_sequence)
;
static Buffer first(const boost::array<Elem, 2>& buffer_sequence)
;
private:
native_buffer_type buffers_[2];
std::size_t total_buffer_size_;
};
template <typename Buffer, typename Elem>
class buffer_sequence_adapter<Buffer, std::array<Elem, 2> >
: buffer_sequence_adapter_base
{
public:
explicit buffer_sequence_adapter(
const std::array<Elem, 2>& buffer_sequence)
;
native_buffer_type* buffers()
;
std::size_t count() const
;
bool all_empty() const
;
static bool all_empty(const std::array<Elem, 2>& buffer_sequence)
;
static void validate(const std::array<Elem, 2>& buffer_sequence)
;
static Buffer first(const std::array<Elem, 2>& buffer_sequence)
;
private:
native_buffer_type buffers_[2];
std::size_t total_buffer_size_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_BUFFER_SEQUENCE_ADAPTER_IPP
#define BOOST_ASIO_DETAIL_REACTIVE_NULL_BUFFERS_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Handler>
class reactive_null_buffers_op : public reactor_op
{
public:
struct ptr { Handler* h; void* v; reactive_null_buffers_op* p; ~ptr() ; void reset() ; };
reactive_null_buffers_op(Handler& handler)
;
static bool do_perform(reactor_op*)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_ACCEPT_OP_HPP
#define BOOST_ASIO_DETAIL_SOCKET_HOLDER_HPP
#define BOOST_ASIO_DETAIL_SOCKET_OPS_HPP
#define BOOST_ASIO_DETAIL_SHARED_PTR_HPP
namespace boost {
namespace asio {
namespace detail {
using std::shared_ptr;
}
}
}
#define BOOST_ASIO_DETAIL_WEAK_PTR_HPP
namespace boost {
namespace asio {
namespace detail {
using std::weak_ptr;
}
}
}
namespace boost {
namespace asio {
namespace detail {
namespace socket_ops {
enum
{
user_set_non_blocking = 1,
internal_non_blocking = 2,
non_blocking = user_set_non_blocking | internal_non_blocking,
enable_connection_aborted = 4,
user_set_linger = 8,
stream_oriented = 16,
datagram_oriented = 32,
possible_dup = 64
};
typedef unsigned char state_type;
struct noop_deleter { void operator()(void*) ; };
typedef shared_ptr<void> shared_cancel_token_type;
typedef weak_ptr<void> weak_cancel_token_type;
inline socket_type accept(socket_type s, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec);
inline socket_type sync_accept(socket_type s,
state_type state, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec);
inline bool non_blocking_accept(socket_type s,
state_type state, socket_addr_type* addr, std::size_t* addrlen,
boost::system::error_code& ec, socket_type& new_socket);
inline int bind(socket_type s, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec);
inline int close(socket_type s, state_type& state,
bool destruction, boost::system::error_code& ec);
inline bool set_user_non_blocking(socket_type s,
state_type& state, bool value, boost::system::error_code& ec);
inline bool set_internal_non_blocking(socket_type s,
state_type& state, bool value, boost::system::error_code& ec);
inline int shutdown(socket_type s,
int what, boost::system::error_code& ec);
inline int connect(socket_type s, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec);
inline void sync_connect(socket_type s, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec);
inline bool non_blocking_connect(socket_type s,
boost::system::error_code& ec);
inline int socketpair(int af, int type, int protocol,
socket_type sv[2], boost::system::error_code& ec);
inline bool sockatmark(socket_type s, boost::system::error_code& ec);
inline size_t available(socket_type s, boost::system::error_code& ec);
inline int listen(socket_type s,
int backlog, boost::system::error_code& ec);
typedef iovec buf;
inline void init_buf(buf& b, void* data, size_t size);
inline void init_buf(buf& b, const void* data, size_t size);
inline signed_size_type recv(socket_type s, buf* bufs,
size_t count, int flags, boost::system::error_code& ec);
inline size_t sync_recv(socket_type s, state_type state, buf* bufs,
size_t count, int flags, bool all_empty, boost::system::error_code& ec);
inline bool non_blocking_recv(socket_type s,
buf* bufs, size_t count, int flags, bool is_stream,
boost::system::error_code& ec, size_t& bytes_transferred);
inline signed_size_type recvfrom(socket_type s, buf* bufs,
size_t count, int flags, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec);
inline size_t sync_recvfrom(socket_type s, state_type state,
buf* bufs, size_t count, int flags, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec);
inline bool non_blocking_recvfrom(socket_type s,
buf* bufs, size_t count, int flags,
socket_addr_type* addr, std::size_t* addrlen,
boost::system::error_code& ec, size_t& bytes_transferred);
inline signed_size_type recvmsg(socket_type s, buf* bufs,
size_t count, int in_flags, int& out_flags,
boost::system::error_code& ec);
inline size_t sync_recvmsg(socket_type s, state_type state,
buf* bufs, size_t count, int in_flags, int& out_flags,
boost::system::error_code& ec);
inline bool non_blocking_recvmsg(socket_type s,
buf* bufs, size_t count, int in_flags, int& out_flags,
boost::system::error_code& ec, size_t& bytes_transferred);
inline signed_size_type send(socket_type s, const buf* bufs,
size_t count, int flags, boost::system::error_code& ec);
inline size_t sync_send(socket_type s, state_type state,
const buf* bufs, size_t count, int flags,
bool all_empty, boost::system::error_code& ec);
inline bool non_blocking_send(socket_type s,
const buf* bufs, size_t count, int flags,
boost::system::error_code& ec, size_t& bytes_transferred);
inline signed_size_type sendto(socket_type s, const buf* bufs,
size_t count, int flags, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec);
inline size_t sync_sendto(socket_type s, state_type state,
const buf* bufs, size_t count, int flags, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec);
inline bool non_blocking_sendto(socket_type s,
const buf* bufs, size_t count, int flags,
const socket_addr_type* addr, std::size_t addrlen,
boost::system::error_code& ec, size_t& bytes_transferred);
inline socket_type socket(int af, int type, int protocol,
boost::system::error_code& ec);
inline int setsockopt(socket_type s, state_type& state,
int level, int optname, const void* optval,
std::size_t optlen, boost::system::error_code& ec);
inline int getsockopt(socket_type s, state_type state,
int level, int optname, void* optval,
size_t* optlen, boost::system::error_code& ec);
inline int getpeername(socket_type s, socket_addr_type* addr,
std::size_t* addrlen, bool cached, boost::system::error_code& ec);
inline int getsockname(socket_type s, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec);
inline int ioctl(socket_type s, state_type& state,
int cmd, ioctl_arg_type* arg, boost::system::error_code& ec);
inline int select(int nfds, fd_set* readfds, fd_set* writefds,
fd_set* exceptfds, timeval* timeout, boost::system::error_code& ec);
inline int poll_read(socket_type s,
state_type state, boost::system::error_code& ec);
inline int poll_write(socket_type s,
state_type state, boost::system::error_code& ec);
inline int poll_connect(socket_type s, boost::system::error_code& ec);
inline const char* inet_ntop(int af, const void* src, char* dest,
size_t length, unsigned long scope_id, boost::system::error_code& ec);
inline int inet_pton(int af, const char* src, void* dest,
unsigned long* scope_id, boost::system::error_code& ec);
inline int gethostname(char* name,
int namelen, boost::system::error_code& ec);
inline boost::system::error_code getaddrinfo(const char* host,
const char* service, const addrinfo_type& hints,
addrinfo_type** result, boost::system::error_code& ec);
inline boost::system::error_code background_getaddrinfo(
const weak_cancel_token_type& cancel_token, const char* host,
const char* service, const addrinfo_type& hints,
addrinfo_type** result, boost::system::error_code& ec);
inline void freeaddrinfo(addrinfo_type* ai);
inline boost::system::error_code getnameinfo(
const socket_addr_type* addr, std::size_t addrlen,
char* host, std::size_t hostlen, char* serv,
std::size_t servlen, int flags, boost::system::error_code& ec);
inline boost::system::error_code sync_getnameinfo(
const socket_addr_type* addr, std::size_t addrlen,
char* host, std::size_t hostlen, char* serv,
std::size_t servlen, int sock_type, boost::system::error_code& ec);
inline boost::system::error_code background_getnameinfo(
const weak_cancel_token_type& cancel_token,
const socket_addr_type* addr, std::size_t addrlen,
char* host, std::size_t hostlen, char* serv,
std::size_t servlen, int sock_type, boost::system::error_code& ec);
inline u_long_type network_to_host_long(u_long_type value);
inline u_long_type host_to_network_long(u_long_type value);
inline u_short_type network_to_host_short(u_short_type value);
inline u_short_type host_to_network_short(u_short_type value);
}
}
}
}
#define BOOST_ASIO_DETAIL_SOCKET_OPS_IPP
#undef __need_error_t
namespace boost {
namespace asio {
namespace detail {
namespace socket_ops {
void clear_last_error()
;
template <typename ReturnType>
ReturnType error_wrapper(ReturnType return_value,
boost::system::error_code& ec)
;
template <typename SockLenType>
socket_type call_accept(SockLenType msghdr::*,
socket_type s, socket_addr_type* addr, std::size_t* addrlen)
;
socket_type accept(socket_type s, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec)
;
socket_type sync_accept(socket_type s, state_type state,
socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec)
;
bool non_blocking_accept(socket_type s,
state_type state, socket_addr_type* addr, std::size_t* addrlen,
boost::system::error_code& ec, socket_type& new_socket)
;
template <typename SockLenType>
int call_bind(SockLenType msghdr::*,
socket_type s, const socket_addr_type* addr, std::size_t addrlen)
;
int bind(socket_type s, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec)
;
int close(socket_type s, state_type& state,
bool destruction, boost::system::error_code& ec)
;
bool set_user_non_blocking(socket_type s,
state_type& state, bool value, boost::system::error_code& ec)
;
bool set_internal_non_blocking(socket_type s,
state_type& state, bool value, boost::system::error_code& ec)
;
int shutdown(socket_type s, int what, boost::system::error_code& ec)
;
template <typename SockLenType>
int call_connect(SockLenType msghdr::*,
socket_type s, const socket_addr_type* addr, std::size_t addrlen)
;
int connect(socket_type s, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec)
;
void sync_connect(socket_type s, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec)
;
bool non_blocking_connect(socket_type s, boost::system::error_code& ec)
;
int socketpair(int af, int type, int protocol,
socket_type sv[2], boost::system::error_code& ec)
;
bool sockatmark(socket_type s, boost::system::error_code& ec)
;
size_t available(socket_type s, boost::system::error_code& ec)
;
int listen(socket_type s, int backlog, boost::system::error_code& ec)
;
void init_buf_iov_base(void*& base, void* addr)
;
template <typename T>
void init_buf_iov_base(T& base, void* addr)
;
typedef iovec buf;
void init_buf(buf& b, void* data, size_t size)
;
void init_buf(buf& b, const void* data, size_t size)
;
void init_msghdr_msg_name(void*& name, socket_addr_type* addr)
;
void init_msghdr_msg_name(void*& name, const socket_addr_type* addr)
;
template <typename T>
void init_msghdr_msg_name(T& name, socket_addr_type* addr)
;
template <typename T>
void init_msghdr_msg_name(T& name, const socket_addr_type* addr)
;
signed_size_type recv(socket_type s, buf* bufs, size_t count,
int flags, boost::system::error_code& ec)
;
size_t sync_recv(socket_type s, state_type state, buf* bufs,
size_t count, int flags, bool all_empty, boost::system::error_code& ec)
;
bool non_blocking_recv(socket_type s,
buf* bufs, size_t count, int flags, bool is_stream,
boost::system::error_code& ec, size_t& bytes_transferred)
;
signed_size_type recvfrom(socket_type s, buf* bufs, size_t count,
int flags, socket_addr_type* addr, std::size_t* addrlen,
boost::system::error_code& ec)
;
size_t sync_recvfrom(socket_type s, state_type state, buf* bufs,
size_t count, int flags, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec)
;
bool non_blocking_recvfrom(socket_type s,
buf* bufs, size_t count, int flags,
socket_addr_type* addr, std::size_t* addrlen,
boost::system::error_code& ec, size_t& bytes_transferred)
;
signed_size_type recvmsg(socket_type s, buf* bufs, size_t count,
int in_flags, int& out_flags, boost::system::error_code& ec)
;
size_t sync_recvmsg(socket_type s, state_type state,
buf* bufs, size_t count, int in_flags, int& out_flags,
boost::system::error_code& ec)
;
bool non_blocking_recvmsg(socket_type s,
buf* bufs, size_t count, int in_flags, int& out_flags,
boost::system::error_code& ec, size_t& bytes_transferred)
;
signed_size_type send(socket_type s, const buf* bufs, size_t count,
int flags, boost::system::error_code& ec)
;
size_t sync_send(socket_type s, state_type state, const buf* bufs,
size_t count, int flags, bool all_empty, boost::system::error_code& ec)
;
bool non_blocking_send(socket_type s,
const buf* bufs, size_t count, int flags,
boost::system::error_code& ec, size_t& bytes_transferred)
;
signed_size_type sendto(socket_type s, const buf* bufs, size_t count,
int flags, const socket_addr_type* addr, std::size_t addrlen,
boost::system::error_code& ec)
;
size_t sync_sendto(socket_type s, state_type state, const buf* bufs,
size_t count, int flags, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec)
;
bool non_blocking_sendto(socket_type s,
const buf* bufs, size_t count, int flags,
const socket_addr_type* addr, std::size_t addrlen,
boost::system::error_code& ec, size_t& bytes_transferred)
;
socket_type socket(int af, int type, int protocol,
boost::system::error_code& ec)
;
template <typename SockLenType>
int call_setsockopt(SockLenType msghdr::*,
socket_type s, int level, int optname,
const void* optval, std::size_t optlen)
;
int setsockopt(socket_type s, state_type& state, int level, int optname,
const void* optval, std::size_t optlen, boost::system::error_code& ec)
;
template <typename SockLenType>
int call_getsockopt(SockLenType msghdr::*,
socket_type s, int level, int optname,
void* optval, std::size_t* optlen)
;
int getsockopt(socket_type s, state_type state, int level, int optname,
void* optval, size_t* optlen, boost::system::error_code& ec)
;
template <typename SockLenType>
int call_getpeername(SockLenType msghdr::*,
socket_type s, socket_addr_type* addr, std::size_t* addrlen)
;
int getpeername(socket_type s, socket_addr_type* addr,
std::size_t* addrlen, bool cached, boost::system::error_code& ec)
;
template <typename SockLenType>
int call_getsockname(SockLenType msghdr::*,
socket_type s, socket_addr_type* addr, std::size_t* addrlen)
;
int getsockname(socket_type s, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec)
;
int ioctl(socket_type s, state_type& state, int cmd,
ioctl_arg_type* arg, boost::system::error_code& ec)
;
int select(int nfds, fd_set* readfds, fd_set* writefds,
fd_set* exceptfds, timeval* timeout, boost::system::error_code& ec)
;
int poll_read(socket_type s, state_type state, boost::system::error_code& ec)
;
int poll_write(socket_type s, state_type state, boost::system::error_code& ec)
;
int poll_connect(socket_type s, boost::system::error_code& ec)
;
const char* inet_ntop(int af, const void* src, char* dest, size_t length,
unsigned long scope_id, boost::system::error_code& ec)
;
int inet_pton(int af, const char* src, void* dest,
unsigned long* scope_id, boost::system::error_code& ec)
;
int gethostname(char* name, int namelen, boost::system::error_code& ec)
;
boost::system::error_code translate_addrinfo_error(int error)
;
boost::system::error_code getaddrinfo(const char* host,
const char* service, const addrinfo_type& hints,
addrinfo_type** result, boost::system::error_code& ec)
;
boost::system::error_code background_getaddrinfo(
const weak_cancel_token_type& cancel_token, const char* host,
const char* service, const addrinfo_type& hints,
addrinfo_type** result, boost::system::error_code& ec)
;
void freeaddrinfo(addrinfo_type* ai)
;
boost::system::error_code getnameinfo(const socket_addr_type* addr,
std::size_t addrlen, char* host, std::size_t hostlen,
char* serv, std::size_t servlen, int flags, boost::system::error_code& ec)
;
boost::system::error_code sync_getnameinfo(
const socket_addr_type* addr, std::size_t addrlen,
char* host, std::size_t hostlen, char* serv,
std::size_t servlen, int sock_type, boost::system::error_code& ec)
;
boost::system::error_code background_getnameinfo(
const weak_cancel_token_type& cancel_token,
const socket_addr_type* addr, std::size_t addrlen,
char* host, std::size_t hostlen, char* serv,
std::size_t servlen, int sock_type, boost::system::error_code& ec)
;
u_long_type network_to_host_long(u_long_type value)
;
u_long_type host_to_network_long(u_long_type value)
;
u_short_type network_to_host_short(u_short_type value)
;
u_short_type host_to_network_short(u_short_type value)
;
}
}
}
}
namespace boost {
namespace asio {
namespace detail {
class socket_holder
: private noncopyable
{
public:
socket_holder()
;
explicit socket_holder(socket_type s)
;
~socket_holder()
;
socket_type get() const
;
void reset()
;
void reset(socket_type s)
;
socket_type release()
;
private:
socket_type socket_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Socket, typename Protocol>
class reactive_socket_accept_op_base : public reactor_op
{
public:
reactive_socket_accept_op_base(socket_type socket,
socket_ops::state_type state, Socket& peer, const Protocol& protocol,
typename Protocol::endpoint* peer_endpoint, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
socket_type socket_;
socket_ops::state_type state_;
Socket& peer_;
Protocol protocol_;
typename Protocol::endpoint* peer_endpoint_;
};
template <typename Socket, typename Protocol, typename Handler>
class reactive_socket_accept_op :
public reactive_socket_accept_op_base<Socket, Protocol>
{
public:
struct ptr { Handler* h; void* v; reactive_socket_accept_op* p; ~ptr() ; void reset() ; };
reactive_socket_accept_op(socket_type socket,
socket_ops::state_type state, Socket& peer, const Protocol& protocol,
typename Protocol::endpoint* peer_endpoint, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_CONNECT_OP_HPP
namespace boost {
namespace asio {
namespace detail {
class reactive_socket_connect_op_base : public reactor_op
{
public:
reactive_socket_connect_op_base(socket_type socket, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
socket_type socket_;
};
template <typename Handler>
class reactive_socket_connect_op : public reactive_socket_connect_op_base
{
public:
struct ptr { Handler* h; void* v; reactive_socket_connect_op* p; ~ptr() ; void reset() ; };
reactive_socket_connect_op(socket_type socket, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECVFROM_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename MutableBufferSequence, typename Endpoint>
class reactive_socket_recvfrom_op_base : public reactor_op
{
public:
reactive_socket_recvfrom_op_base(socket_type socket, int protocol_type,
const MutableBufferSequence& buffers, Endpoint& endpoint,
socket_base::message_flags flags, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
socket_type socket_;
int protocol_type_;
MutableBufferSequence buffers_;
Endpoint& sender_endpoint_;
socket_base::message_flags flags_;
};
template <typename MutableBufferSequence, typename Endpoint, typename Handler>
class reactive_socket_recvfrom_op :
public reactive_socket_recvfrom_op_base<MutableBufferSequence, Endpoint>
{
public:
struct ptr { Handler* h; void* v; reactive_socket_recvfrom_op* p; ~ptr() ; void reset() ; };
reactive_socket_recvfrom_op(socket_type socket, int protocol_type,
const MutableBufferSequence& buffers, Endpoint& endpoint,
socket_base::message_flags flags, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SENDTO_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename ConstBufferSequence, typename Endpoint>
class reactive_socket_sendto_op_base : public reactor_op
{
public:
reactive_socket_sendto_op_base(socket_type socket,
const ConstBufferSequence& buffers, const Endpoint& endpoint,
socket_base::message_flags flags, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
socket_type socket_;
ConstBufferSequence buffers_;
Endpoint destination_;
socket_base::message_flags flags_;
};
template <typename ConstBufferSequence, typename Endpoint, typename Handler>
class reactive_socket_sendto_op :
public reactive_socket_sendto_op_base<ConstBufferSequence, Endpoint>
{
public:
struct ptr { Handler* h; void* v; reactive_socket_sendto_op* p; ~ptr() ; void reset() ; };
reactive_socket_sendto_op(socket_type socket,
const ConstBufferSequence& buffers, const Endpoint& endpoint,
socket_base::message_flags flags, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_BASE_HPP
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECV_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename MutableBufferSequence>
class reactive_socket_recv_op_base : public reactor_op
{
public:
reactive_socket_recv_op_base(socket_type socket,
socket_ops::state_type state, const MutableBufferSequence& buffers,
socket_base::message_flags flags, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
socket_type socket_;
socket_ops::state_type state_;
MutableBufferSequence buffers_;
socket_base::message_flags flags_;
};
template <typename MutableBufferSequence, typename Handler>
class reactive_socket_recv_op :
public reactive_socket_recv_op_base<MutableBufferSequence>
{
public:
struct ptr { Handler* h; void* v; reactive_socket_recv_op* p; ~ptr() ; void reset() ; };
reactive_socket_recv_op(socket_type socket,
socket_ops::state_type state, const MutableBufferSequence& buffers,
socket_base::message_flags flags, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECVMSG_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename MutableBufferSequence>
class reactive_socket_recvmsg_op_base : public reactor_op
{
public:
reactive_socket_recvmsg_op_base(socket_type socket,
const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
socket_base::message_flags& out_flags, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
socket_type socket_;
MutableBufferSequence buffers_;
socket_base::message_flags in_flags_;
socket_base::message_flags& out_flags_;
};
template <typename MutableBufferSequence, typename Handler>
class reactive_socket_recvmsg_op :
public reactive_socket_recvmsg_op_base<MutableBufferSequence>
{
public:
struct ptr { Handler* h; void* v; reactive_socket_recvmsg_op* p; ~ptr() ; void reset() ; };
reactive_socket_recvmsg_op(socket_type socket,
const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
socket_base::message_flags& out_flags, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SEND_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename ConstBufferSequence>
class reactive_socket_send_op_base : public reactor_op
{
public:
reactive_socket_send_op_base(socket_type socket,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
socket_type socket_;
ConstBufferSequence buffers_;
socket_base::message_flags flags_;
};
template <typename ConstBufferSequence, typename Handler>
class reactive_socket_send_op :
public reactive_socket_send_op_base<ConstBufferSequence>
{
public:
struct ptr { Handler* h; void* v; reactive_socket_send_op* p; ~ptr() ; void reset() ; };
reactive_socket_send_op(socket_type socket,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
class reactive_socket_service_base
{
public:
typedef socket_type native_handle_type;
struct base_implementation_type
{
socket_type socket_;
socket_ops::state_type state_;
reactor::per_descriptor_data reactor_data_;
};
inline reactive_socket_service_base(
boost::asio::io_service& io_service);
inline void shutdown_service();
inline void construct(base_implementation_type& impl);
inline void base_move_construct(base_implementation_type& impl,
base_implementation_type& other_impl);
inline void base_move_assign(base_implementation_type& impl,
reactive_socket_service_base& other_service,
base_implementation_type& other_impl);
inline void destroy(base_implementation_type& impl);
bool is_open(const base_implementation_type& impl) const
;
inline boost::system::error_code close(
base_implementation_type& impl, boost::system::error_code& ec);
native_handle_type native_handle(base_implementation_type& impl)
;
inline boost::system::error_code cancel(
base_implementation_type& impl, boost::system::error_code& ec);
bool at_mark(const base_implementation_type& impl,
boost::system::error_code& ec) const
;
std::size_t available(const base_implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code listen(base_implementation_type& impl,
int backlog, boost::system::error_code& ec)
;
template <typename IO_Control_Command>
boost::system::error_code io_control(base_implementation_type& impl,
IO_Control_Command& command, boost::system::error_code& ec)
;
bool non_blocking(const base_implementation_type& impl) const
;
boost::system::error_code non_blocking(base_implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const base_implementation_type& impl) const
;
boost::system::error_code native_non_blocking(base_implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
boost::system::error_code shutdown(base_implementation_type& impl,
socket_base::shutdown_type what, boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
size_t send(base_implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
size_t send(base_implementation_type& impl, const null_buffers&,
socket_base::message_flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename Handler>
void async_send(base_implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, Handler& handler)
;
template <typename Handler>
void async_send(base_implementation_type& impl, const null_buffers&,
socket_base::message_flags, Handler& handler)
;
template <typename MutableBufferSequence>
size_t receive(base_implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
size_t receive(base_implementation_type& impl, const null_buffers&,
socket_base::message_flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename Handler>
void async_receive(base_implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags, Handler& handler)
;
template <typename Handler>
void async_receive(base_implementation_type& impl, const null_buffers&,
socket_base::message_flags flags, Handler& handler)
;
template <typename MutableBufferSequence>
size_t receive_with_flags(base_implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags in_flags,
socket_base::message_flags& out_flags, boost::system::error_code& ec)
;
size_t receive_with_flags(base_implementation_type& impl,
const null_buffers&, socket_base::message_flags,
socket_base::message_flags& out_flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename Handler>
void async_receive_with_flags(base_implementation_type& impl,
const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
socket_base::message_flags& out_flags, Handler& handler)
;
template <typename Handler>
void async_receive_with_flags(base_implementation_type& impl,
const null_buffers&, socket_base::message_flags in_flags,
socket_base::message_flags& out_flags, Handler& handler)
;
protected:
inline boost::system::error_code do_open(
base_implementation_type& impl, int af,
int type, int protocol, boost::system::error_code& ec);
inline boost::system::error_code do_assign(
base_implementation_type& impl, int type,
const native_handle_type& native_socket, boost::system::error_code& ec);
inline void start_op(base_implementation_type& impl, int op_type,
reactor_op* op, bool is_continuation, bool is_non_blocking, bool noop);
inline void start_accept_op(base_implementation_type& impl,
reactor_op* op, bool is_continuation, bool peer_is_open);
inline void start_connect_op(base_implementation_type& impl,
reactor_op* op, bool is_continuation,
const socket_addr_type* addr, size_t addrlen);
reactor& reactor_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_REACTIVE_SOCKET_SERVICE_BASE_IPP
namespace boost {
namespace asio {
namespace detail {
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Protocol>
class reactive_socket_service :
public reactive_socket_service_base
{
public:
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
typedef socket_type native_handle_type;
struct implementation_type :
reactive_socket_service_base::base_implementation_type
{
implementation_type()
;
protocol_type protocol_;
};
reactive_socket_service(boost::asio::io_service& io_service)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
reactive_socket_service_base& other_service,
implementation_type& other_impl)
;
template <typename Protocol1>
void converting_move_construct(implementation_type& impl,
typename reactive_socket_service<
Protocol1>::implementation_type& other_impl)
;
boost::system::error_code open(implementation_type& impl,
const protocol_type& protocol, boost::system::error_code& ec)
;
boost::system::error_code assign(implementation_type& impl,
const protocol_type& protocol, const native_handle_type& native_socket,
boost::system::error_code& ec)
;
native_handle_type native_handle(implementation_type& impl)
;
boost::system::error_code bind(implementation_type& impl,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
template <typename Option>
boost::system::error_code set_option(implementation_type& impl,
const Option& option, boost::system::error_code& ec)
;
template <typename Option>
boost::system::error_code get_option(const implementation_type& impl,
Option& option, boost::system::error_code& ec) const
;
endpoint_type local_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
endpoint_type remote_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
template <typename ConstBufferSequence>
size_t send_to(implementation_type& impl, const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags,
boost::system::error_code& ec)
;
size_t send_to(implementation_type& impl, const null_buffers&,
const endpoint_type&, socket_base::message_flags,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename Handler>
void async_send_to(implementation_type& impl,
const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags,
Handler& handler)
;
template <typename Handler>
void async_send_to(implementation_type& impl, const null_buffers&,
const endpoint_type&, socket_base::message_flags, Handler& handler)
;
template <typename MutableBufferSequence>
size_t receive_from(implementation_type& impl,
const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint, socket_base::message_flags flags,
boost::system::error_code& ec)
;
size_t receive_from(implementation_type& impl, const null_buffers&,
endpoint_type& sender_endpoint, socket_base::message_flags,
boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename Handler>
void async_receive_from(implementation_type& impl,
const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
socket_base::message_flags flags, Handler& handler)
;
template <typename Handler>
void async_receive_from(implementation_type& impl,
const null_buffers&, endpoint_type& sender_endpoint,
socket_base::message_flags flags, Handler& handler)
;
template <typename Socket>
boost::system::error_code accept(implementation_type& impl,
Socket& peer, endpoint_type* peer_endpoint, boost::system::error_code& ec)
;
template <typename Socket, typename Handler>
void async_accept(implementation_type& impl, Socket& peer,
endpoint_type* peer_endpoint, Handler& handler)
;
boost::system::error_code connect(implementation_type& impl,
const endpoint_type& peer_endpoint, boost::system::error_code& ec)
;
template <typename Handler>
void async_connect(implementation_type& impl,
const endpoint_type& peer_endpoint, Handler& handler)
;
};
}
}
}
namespace boost {
namespace asio {
template <typename Protocol>
class datagram_socket_service
: public boost::asio::detail::service_base<datagram_socket_service<Protocol> >
{
public:
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
private:
typedef detail::reactive_socket_service<Protocol> service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
typedef typename service_impl_type::native_handle_type native_type;
typedef typename service_impl_type::native_handle_type native_handle_type;
explicit datagram_socket_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
datagram_socket_service& other_service,
implementation_type& other_impl)
;
template <typename Protocol1>
void converting_move_construct(implementation_type& impl,
typename datagram_socket_service<
Protocol1>::implementation_type& other_impl,
typename enable_if<is_convertible<
Protocol1, Protocol>::value>::type* = 0)
;
void destroy(implementation_type& impl)
;
boost::system::error_code open(implementation_type& impl,
const protocol_type& protocol, boost::system::error_code& ec)
;
boost::system::error_code assign(implementation_type& impl,
const protocol_type& protocol, const native_handle_type& native_socket,
boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_type native(implementation_type& impl)
;
native_handle_type native_handle(implementation_type& impl)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
bool at_mark(const implementation_type& impl,
boost::system::error_code& ec) const
;
std::size_t available(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code bind(implementation_type& impl,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
boost::system::error_code connect(implementation_type& impl,
const endpoint_type& peer_endpoint, boost::system::error_code& ec)
;
template <typename ConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ConnectHandler, void (boost::system::error_code)>::type>::type
async_connect(implementation_type& impl,
const endpoint_type& peer_endpoint,
ConnectHandler&& handler)
;
template <typename SettableSocketOption>
boost::system::error_code set_option(implementation_type& impl,
const SettableSocketOption& option, boost::system::error_code& ec)
;
template <typename GettableSocketOption>
boost::system::error_code get_option(const implementation_type& impl,
GettableSocketOption& option, boost::system::error_code& ec) const
;
template <typename IoControlCommand>
boost::system::error_code io_control(implementation_type& impl,
IoControlCommand& command, boost::system::error_code& ec)
;
bool non_blocking(const implementation_type& impl) const
;
boost::system::error_code non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const implementation_type& impl) const
;
boost::system::error_code native_non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
endpoint_type local_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
endpoint_type remote_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code shutdown(implementation_type& impl,
socket_base::shutdown_type what, boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t send(implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(implementation_type& impl, const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename ConstBufferSequence>
std::size_t send_to(implementation_type& impl,
const ConstBufferSequence& buffers, const endpoint_type& destination,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send_to(implementation_type& impl,
const ConstBufferSequence& buffers, const endpoint_type& destination,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags,
ReadHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive_from(implementation_type& impl,
const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive_from(implementation_type& impl,
const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
socket_base::message_flags flags,
ReadHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename Protocol,
typename DatagramSocketService = datagram_socket_service<Protocol> >
class basic_datagram_socket
: public basic_socket<Protocol, DatagramSocketService>
{
public:
typedef typename DatagramSocketService::native_handle_type native_type;
typedef typename DatagramSocketService::native_handle_type native_handle_type;
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
explicit basic_datagram_socket(boost::asio::io_service& io_service)
;
basic_datagram_socket(boost::asio::io_service& io_service,
const protocol_type& protocol)
;
basic_datagram_socket(boost::asio::io_service& io_service,
const endpoint_type& endpoint)
;
basic_datagram_socket(boost::asio::io_service& io_service,
const protocol_type& protocol, const native_handle_type& native_socket)
;
basic_datagram_socket(basic_datagram_socket&& other)
;
basic_datagram_socket& operator=(basic_datagram_socket&& other)
;
template <typename Protocol1, typename DatagramSocketService1>
basic_datagram_socket(
basic_datagram_socket<Protocol1, DatagramSocketService1>&& other,
typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
;
template <typename Protocol1, typename DatagramSocketService1>
typename enable_if<is_convertible<Protocol1, Protocol>::value,
basic_datagram_socket>::type& operator=(
basic_datagram_socket<Protocol1, DatagramSocketService1>&& other)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename ConstBufferSequence>
std::size_t send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination)
;
template <typename ConstBufferSequence>
std::size_t send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags)
;
template <typename ConstBufferSequence>
std::size_t send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination,
WriteHandler&& handler)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags,
ReadHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint)
;
template <typename MutableBufferSequence>
std::size_t receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint, socket_base::message_flags flags)
;
template <typename MutableBufferSequence>
std::size_t receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint, socket_base::message_flags flags,
boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint,
ReadHandler&& handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint, socket_base::message_flags flags,
ReadHandler&& handler)
;
};
}
}
#define BOOST_ASIO_BASIC_DEADLINE_TIMER_HPP
#define BOOST_ASIO_DEADLINE_TIMER_SERVICE_HPP
#define BOOST_ASIO_DETAIL_DEADLINE_TIMER_SERVICE_HPP
#define BOOST_ASIO_DETAIL_TIMER_QUEUE_HPP
#define BOOST_ASIO_DETAIL_DATE_TIME_FWD_HPP
namespace boost {
namespace date_time {
template<class T, class TimeSystem>
class base_time;
}
namespace posix_time {
class ptime;
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Time_Traits>
class timer_queue
: public timer_queue_base
{
public:
typedef typename Time_Traits::time_type time_type;
typedef typename Time_Traits::duration_type duration_type;
class per_timer_data
{
public:
per_timer_data() ;
private:
friend class timer_queue;
op_queue<wait_op> op_queue_;
std::size_t heap_index_;
per_timer_data* next_;
per_timer_data* prev_;
};
timer_queue()
;
bool enqueue_timer(const time_type& time, per_timer_data& timer, wait_op* op)
;
virtual bool empty() const
;
virtual long wait_duration_msec(long max_duration) const
;
virtual long wait_duration_usec(long max_duration) const
;
virtual void get_ready_timers(op_queue<operation>& ops)
;
virtual void get_all_timers(op_queue<operation>& ops)
;
std::size_t cancel_timer(per_timer_data& timer, op_queue<operation>& ops,
std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)())
;
private:
void up_heap(std::size_t index)
;
void down_heap(std::size_t index)
;
void swap_heap(std::size_t index1, std::size_t index2)
;
void remove_timer(per_timer_data& timer)
;
template <typename Time_Type>
static bool is_positive_infinity(const Time_Type&)
;
template <typename T, typename TimeSystem>
static bool is_positive_infinity(
const boost::date_time::base_time<T, TimeSystem>& time)
;
template <typename Duration>
long to_msec(const Duration& d, long max_duration) const
;
template <typename Duration>
long to_usec(const Duration& d, long max_duration) const
;
per_timer_data* timers_;
struct heap_entry
{
time_type time_;
per_timer_data* timer_;
};
std::vector<heap_entry> heap_;
};
}
}
}
#define BOOST_ASIO_DETAIL_TIMER_SCHEDULER_HPP
#define BOOST_ASIO_DETAIL_TIMER_SCHEDULER_FWD_HPP
namespace boost {
namespace asio {
namespace detail {
typedef class epoll_reactor timer_scheduler;
}
}
}
#define BOOST_ASIO_DETAIL_WAIT_HANDLER_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Handler>
class wait_handler : public wait_op
{
public:
struct ptr { Handler* h; void* v; wait_handler* p; ~ptr() ; void reset() ; };
wait_handler(Handler& h)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Time_Traits>
class deadline_timer_service
{
public:
typedef typename Time_Traits::time_type time_type;
typedef typename Time_Traits::duration_type duration_type;
struct implementation_type
: private boost::asio::detail::noncopyable
{
time_type expiry;
bool might_have_pending_waits;
typename timer_queue<Time_Traits>::per_timer_data timer_data;
};
deadline_timer_service(boost::asio::io_service& io_service)
;
~deadline_timer_service()
;
void shutdown_service()
;
void construct(implementation_type& impl)
;
void destroy(implementation_type& impl)
;
std::size_t cancel(implementation_type& impl, boost::system::error_code& ec)
;
std::size_t cancel_one(implementation_type& impl,
boost::system::error_code& ec)
;
time_type expires_at(const implementation_type& impl) const
;
std::size_t expires_at(implementation_type& impl,
const time_type& expiry_time, boost::system::error_code& ec)
;
duration_type expires_from_now(const implementation_type& impl) const
;
std::size_t expires_from_now(implementation_type& impl,
const duration_type& expiry_time, boost::system::error_code& ec)
;
void wait(implementation_type& impl, boost::system::error_code& ec)
;
template <typename Handler>
void async_wait(implementation_type& impl, Handler& handler)
;
private:
template <typename Duration>
void do_wait(const Duration& timeout, boost::system::error_code& ec)
;
timer_queue<Time_Traits> timer_queue_;
timer_scheduler& scheduler_;
};
}
}
}
#define BOOST_ASIO_TIME_TRAITS_HPP
#define POSIX_TIME_TYPES_HPP___
#define DATE_TIME_TIME_CLOCK_HPP___
#define DATE_TIME_C_TIME_HPP___
#define _GLIBCXX_CTIME 1
#undef clock
#undef difftime
#undef mktime
#undef time
#undef asctime
#undef ctime
#undef gmtime
#undef localtime
#undef strftime
namespace std
{
using ::clock_t;
using ::time_t;
using ::tm;
using ::clock;
using ::difftime;
using ::mktime;
using ::time;
using ::asctime;
using ::ctime;
using ::gmtime;
using ::localtime;
using ::strftime;
}
#define DATE_TIME_COMPILER_CONFIG_HPP___
#define DATE_TIME_LOCALE_CONFIG_HPP___
#define BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK
#define BOOST_DATE_TIME_OPTIONAL_GREGORIAN_TYPES
#define BOOST_DATE_TIME_UNREACHABLE_EXPRESSION(x) std::abort()
#define BOOST_DATE_TIME_DECL
#define BOOST_LIB_NAME boost_date_time
#undef BOOST_LIB_NAME
#define BOOST_DATE_TIME_HAS_REENTRANT_STD_FUNCTIONS
#define _SYS_TIME_H 1
#define __need_time_t
#define __need_timeval
#undef __need_timeval
extern "C" {
#define TIMEVAL_TO_TIMESPEC(tv,ts) { (ts)->tv_sec = (tv)->tv_sec; (ts)->tv_nsec = (tv)->tv_usec * 1000; }
#define TIMESPEC_TO_TIMEVAL(tv,ts) { (tv)->tv_sec = (ts)->tv_sec; (tv)->tv_usec = (ts)->tv_nsec / 1000; }
struct timezone
{
int tz_minuteswest;
int tz_dsttime;
};
typedef struct timezone *__restrict __timezone_ptr_t;
extern int gettimeofday (struct timeval *__restrict __tv,
__timezone_ptr_t __tz) throw () __attribute__ ((__nonnull__ (1)));
extern int settimeofday (const struct timeval *__tv,
const struct timezone *__tz)
throw ();
extern int adjtime (const struct timeval *__delta,
struct timeval *__olddelta) throw ();
enum __itimer_which
{
ITIMER_REAL = 0,
#define ITIMER_REAL ITIMER_REAL
ITIMER_VIRTUAL = 1,
#define ITIMER_VIRTUAL ITIMER_VIRTUAL
ITIMER_PROF = 2
#define ITIMER_PROF ITIMER_PROF
};
struct itimerval
{
struct timeval it_interval;
struct timeval it_value;
};
typedef int __itimer_which_t;
extern int getitimer (__itimer_which_t __which,
struct itimerval *__value) throw ();
extern int setitimer (__itimer_which_t __which,
const struct itimerval *__restrict __new,
struct itimerval *__restrict __old) throw ();
extern int utimes (const char *__file, const struct timeval __tvp[2])
throw () __attribute__ ((__nonnull__ (1)));
extern int lutimes (const char *__file, const struct timeval __tvp[2])
throw () __attribute__ ((__nonnull__ (1)));
extern int futimes (int __fd, const struct timeval __tvp[2]) throw ();
extern int futimesat (int __fd, const char *__file,
const struct timeval __tvp[2]) throw ();
#define timerisset(tvp) ((tvp)->tv_sec || (tvp)->tv_usec)
#define timerclear(tvp) ((tvp)->tv_sec = (tvp)->tv_usec = 0)
#define timercmp(a,b,CMP) (((a)->tv_sec == (b)->tv_sec) ? ((a)->tv_usec CMP (b)->tv_usec) : ((a)->tv_sec CMP (b)->tv_sec))
#define timeradd(a,b,result) do { (result)->tv_sec = (a)->tv_sec + (b)->tv_sec; (result)->tv_usec = (a)->tv_usec + (b)->tv_usec; if ((result)->tv_usec >= 1000000) { ++(result)->tv_sec; (result)->tv_usec -= 1000000; } } while (0)
#define timersub(a,b,result) do { (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; (result)->tv_usec = (a)->tv_usec - (b)->tv_usec; if ((result)->tv_usec < 0) { --(result)->tv_sec; (result)->tv_usec += 1000000; } } while (0)
}
namespace boost {
namespace date_time {
struct c_time {
public:
static std::tm* localtime(const std::time_t* t, std::tm* result)
;
static std::tm* gmtime(const std::time_t* t, std::tm* result)
;
};
}}
#define BOOST_SHARED_PTR_HPP_INCLUDED
#define BOOST_SMART_PTR_SHARED_PTR_HPP_INCLUDED
#define BOOST_CONFIG_MEMORY
#define BOOST_TR1_NO_RECURSION
#define BOOST_CONFIG_NO_MEMORY_RECURSION
#undef BOOST_TR1_NO_RECURSION
#undef BOOST_CONFIG_NO_MEMORY_RECURSION
#undef BOOST_ASSERT
#undef _ASSERT_H
#undef assert
#undef __ASSERT_VOID_CAST
#undef assert_perror
#define _ASSERT_H 1
#define __ASSERT_VOID_CAST static_cast<void>
#define assert(expr) (__ASSERT_VOID_CAST (0))
#define assert_perror(errnum) (__ASSERT_VOID_CAST (0))
#define BOOST_ASSERT(expr) assert(expr)
#undef BOOST_ASSERT_MSG
#define BOOST_ASSERT_MSG(expr,msg) ((void)0)
#undef BOOST_VERIFY
#define BOOST_VERIFY(expr) ((void)(expr))
#define BOOST_CHECKED_DELETE_HPP_INCLUDED
namespace boost
{
template<class T> void checked_delete(T * x)
;
template<class T> void checked_array_delete(T * x)
;
template<class T> struct checked_deleter
{
typedef void result_type;
typedef T * argument_type;
void operator()(T * x) const
;
};
template<class T> struct checked_array_deleter
{
typedef void result_type;
typedef T * argument_type;
void operator()(T * x) const
;
};
}
#define BOOST_SMART_PTR_DETAIL_SHARED_COUNT_HPP_INCLUDED
#define BOOST_SMART_PTR_BAD_WEAK_PTR_HPP_INCLUDED
namespace boost
{
class bad_weak_ptr: public std::exception
{
public:
virtual char const * what() const throw()
;
};
}
#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_HPP_INCLUDED
#define BOOST_SMART_PTR_DETAIL_SP_HAS_SYNC_HPP_INCLUDED
#define BOOST_SP_HAS_SYNC
#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_GCC_X86_HPP_INCLUDED
#define BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED
namespace boost
{
namespace detail
{
typedef std::type_info sp_typeinfo;
}
}
#define BOOST_SP_TYPEID(T) typeid(T)
namespace boost
{
namespace detail
{
int atomic_exchange_and_add( int * pw, int dv )
;
void atomic_increment( int * pw )
;
int atomic_conditional_increment( int * pw )
;
class sp_counted_base
{
private:
sp_counted_base( sp_counted_base const & );
sp_counted_base & operator= ( sp_counted_base const & );
int use_count_;
int weak_count_;
public:
sp_counted_base()
;
virtual ~sp_counted_base()
;
virtual void dispose() = 0;
virtual void destroy()
;
virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
virtual void * get_untyped_deleter() = 0;
void add_ref_copy()
;
bool add_ref_lock()
;
void release()
;
void weak_add_ref()
;
void weak_release()
;
long use_count() const
;
};
}
}
#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_IMPL_HPP_INCLUDED
namespace boost
{
namespace detail
{
template<class X> class sp_counted_impl_p: public sp_counted_base
{
private:
X * px_;
sp_counted_impl_p( sp_counted_impl_p const & );
sp_counted_impl_p & operator= ( sp_counted_impl_p const & );
typedef sp_counted_impl_p<X> this_type;
public:
explicit sp_counted_impl_p( X * px )
;
virtual void dispose()
;
virtual void * get_deleter( detail::sp_typeinfo const & )
;
virtual void * get_untyped_deleter()
;
};
template<class P, class D> class sp_counted_impl_pd: public sp_counted_base
{
private:
P ptr;
D del;
sp_counted_impl_pd( sp_counted_impl_pd const & );
sp_counted_impl_pd & operator= ( sp_counted_impl_pd const & );
typedef sp_counted_impl_pd<P, D> this_type;
public:
sp_counted_impl_pd( P p, D & d )
;
sp_counted_impl_pd( P p )
;
virtual void dispose()
;
virtual void * get_deleter( detail::sp_typeinfo const & ti )
;
virtual void * get_untyped_deleter()
;
};
template<class P, class D, class A> class sp_counted_impl_pda: public sp_counted_base
{
private:
P p_;
D d_;
A a_;
sp_counted_impl_pda( sp_counted_impl_pda const & );
sp_counted_impl_pda & operator= ( sp_counted_impl_pda const & );
typedef sp_counted_impl_pda<P, D, A> this_type;
public:
sp_counted_impl_pda( P p, D & d, A a )
;
sp_counted_impl_pda( P p, A a )
;
virtual void dispose()
;
virtual void destroy()
;
virtual void * get_deleter( detail::sp_typeinfo const & ti )
;
virtual void * get_untyped_deleter()
;
};
}
}
#define BOOST_UTILITY_ADDRESSOF_HPP
namespace boost
{
namespace detail
{
template<class T> struct addr_impl_ref
{
T & v_;
addr_impl_ref( T & v ) ;
operator T& () const ;
private:
addr_impl_ref & operator=(const addr_impl_ref &);
};
template<class T> struct addressof_impl
{
static T * f( T & v, long )
;
static T * f( T * v, int )
;
};
}
template<class T> T * addressof( T & v )
;
}
namespace boost
{
namespace detail
{
struct sp_nothrow_tag {};
template< class D > struct sp_inplace_tag
{
};
template< class T > class sp_reference_wrapper
{
public:
explicit sp_reference_wrapper( T & t)
;
template< class Y > void operator()( Y * p ) const
;
private:
T * t_;
};
template< class D > struct sp_convert_reference
{
typedef D type;
};
template< class D > struct sp_convert_reference< D& >
{
typedef sp_reference_wrapper< D > type;
};
class weak_count;
class shared_count
{
private:
sp_counted_base * pi_;
friend class weak_count;
public:
shared_count()
;
template<class Y> explicit shared_count( Y * p )
;
template<class P, class D> shared_count( P p, D d )
;
template< class P, class D > shared_count( P p, sp_inplace_tag<D> )
;
template<class P, class D, class A> shared_count( P p, D d, A a )
;
template< class P, class D, class A > shared_count( P p, sp_inplace_tag< D >, A a )
;
template<class Y>
explicit shared_count( std::auto_ptr<Y> & r )
;
template<class Y, class D>
explicit shared_count( std::unique_ptr<Y, D> & r )
;
~shared_count()
;
shared_count(shared_count const & r)
;
shared_count(shared_count && r)
;
explicit shared_count(weak_count const & r);
shared_count( weak_count const & r, sp_nothrow_tag );
shared_count & operator= (shared_count const & r)
;
void swap(shared_count & r)
;
long use_count() const
;
bool unique() const
;
bool empty() const
;
friend bool operator==(shared_count const & a, shared_count const & b)
;
friend bool operator<(shared_count const & a, shared_count const & b)
;
void * get_deleter( sp_typeinfo const & ti ) const
;
void * get_untyped_deleter() const
;
};
class weak_count
{
private:
sp_counted_base * pi_;
friend class shared_count;
public:
weak_count()
;
weak_count(shared_count const & r)
;
weak_count(weak_count const & r)
;
weak_count(weak_count && r)
;
~weak_count()
;
weak_count & operator= (shared_count const & r)
;
weak_count & operator= (weak_count const & r)
;
void swap(weak_count & r)
;
long use_count() const
;
bool empty() const
;
friend bool operator==(weak_count const & a, weak_count const & b)
;
friend bool operator<(weak_count const & a, weak_count const & b)
;
};
}
}
#define BOOST_SMART_PTR_DETAIL_SP_CONVERTIBLE_HPP_INCLUDED
namespace boost
{
namespace detail
{
template< class Y, class T > struct sp_convertible
{
typedef char (&yes) [1];
typedef char (&no) [2];
static yes f( T* );
static no f( ... );
enum _vt { value = sizeof( (f)( static_cast<Y*>(0) ) ) == sizeof(yes) };
};
template< class Y, class T > struct sp_convertible< Y, T[] >
{
enum _vt { value = false };
};
template< class Y, class T > struct sp_convertible< Y[], T[] >
{
enum _vt { value = sp_convertible< Y[1], T[1] >::value };
};
template< class Y, std::size_t N, class T > struct sp_convertible< Y[N], T[] >
{
enum _vt { value = sp_convertible< Y[1], T[1] >::value };
};
struct sp_empty
{
};
template< bool > struct sp_enable_if_convertible_impl;
template<> struct sp_enable_if_convertible_impl<true>
{
typedef sp_empty type;
};
template<> struct sp_enable_if_convertible_impl<false>
{
};
template< class Y, class T > struct sp_enable_if_convertible: public sp_enable_if_convertible_impl< sp_convertible< Y, T >::value >
{
};
}
}
#define BOOST_SMART_PTR_DETAIL_SP_NULLPTR_T_HPP_INCLUDED
namespace boost
{
namespace detail
{
typedef std::nullptr_t sp_nullptr_t;
}
}
#define BOOST_SMART_PTR_DETAIL_SPINLOCK_POOL_HPP_INCLUDED
#define BOOST_SMART_PTR_DETAIL_SPINLOCK_HPP_INCLUDED
#define BOOST_SMART_PTR_DETAIL_SPINLOCK_SYNC_HPP_INCLUDED
#define BOOST_SMART_PTR_DETAIL_YIELD_K_HPP_INCLUDED
#define BOOST_SMT_PAUSE __asm__ __volatile__( "rep; nop" : : : "memory" );
namespace boost
{
namespace detail
{
void yield( unsigned k )
;
}
}
namespace boost
{
namespace detail
{
class spinlock
{
public:
int v_;
public:
bool try_lock()
;
void lock()
;
void unlock()
;
public:
class scoped_lock
{
private:
spinlock & sp_;
scoped_lock( scoped_lock const & );
scoped_lock & operator=( scoped_lock const & );
public:
explicit scoped_lock( spinlock & sp )
;
~scoped_lock()
;
};
};
}
}
#define BOOST_DETAIL_SPINLOCK_INIT {0}
namespace boost
{
namespace detail
{
template< int I > class spinlock_pool
{
private:
static spinlock pool_[ 41 ];
public:
static spinlock & spinlock_for( void const * pv )
;
class scoped_lock
{
private:
spinlock & sp_;
scoped_lock( scoped_lock const & );
scoped_lock & operator=( scoped_lock const & );
public:
explicit scoped_lock( void const * pv )
;
~scoped_lock()
;
};
};
template< int I > spinlock spinlock_pool< I >::pool_[ 41 ] =
{
{0}, {0}, {0}, {0}, {0},
{0}, {0}, {0}, {0}, {0},
{0}, {0}, {0}, {0}, {0},
{0}, {0}, {0}, {0}, {0},
{0}, {0}, {0}, {0}, {0},
{0}, {0}, {0}, {0}, {0},
{0}, {0}, {0}, {0}, {0},
{0}, {0}, {0}, {0}, {0},
{0}
};
}
}
#define BOOST_MEMORY_ORDER_HPP_INCLUDED
namespace boost
{
enum memory_order
{
memory_order_relaxed = 0,
memory_order_acquire = 1,
memory_order_release = 2,
memory_order_acq_rel = 3,
memory_order_seq_cst = 7,
memory_order_consume = 8
};
}
#define _GLIBCXX_ALGORITHM 1
#define _STL_ALGO_H 1
#define _GLIBCXX_ALGORITHMFWD_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _IIter, typename _Predicate>
bool
all_of(_IIter, _IIter, _Predicate);
template<typename _IIter, typename _Predicate>
bool
any_of(_IIter, _IIter, _Predicate);
template<typename _FIter, typename _Tp>
bool
binary_search(_FIter, _FIter, const _Tp&);
template<typename _FIter, typename _Tp, typename _Compare>
bool
binary_search(_FIter, _FIter, const _Tp&, _Compare);
template<typename _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);
template<typename _FIter>
void
rotate(_FIter, _FIter, _FIter);
template<typename _FIter, typename _OIter>
_OIter
rotate_copy(_FIter, _FIter, _FIter, _OIter);
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);
template<typename _Tp>
void
swap(_Tp&, _Tp&)
noexcept(__and_<is_nothrow_move_constructible<_Tp>,
is_nothrow_move_assignable<_Tp>>::value)
;
template<typename _Tp, size_t _Nm>
void
swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
noexcept(noexcept(swap(*__a, *__b)))
;
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);
}
#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)
;
template<typename _RandomAccessIterator, typename _Distance>
bool
__is_heap(_RandomAccessIterator __first, _Distance __n)
;
template<typename _RandomAccessIterator, typename _Compare,
typename _Distance>
bool
__is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
;
template<typename _RandomAccessIterator>
bool
__is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
bool
__is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
typename _Compare>
void
__push_heap(_RandomAccessIterator __first,
_Distance __holeIndex, _Distance __topIndex, _Tp __value,
_Compare __comp)
;
template<typename _RandomAccessIterator>
void
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Distance,
typename _Tp, typename _Compare>
void
__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
_Distance __len, _Tp __value, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_RandomAccessIterator __result, _Compare __comp)
;
template<typename _RandomAccessIterator>
void
pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
pop_heap(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator>
void
make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator>
void
sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator>
_RandomAccessIterator
is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
_RandomAccessIterator
is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator>
bool
is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
bool
is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
}
#define _GLIBCXX_RANDOM 1
#define _MATH_H 1
extern "C" {
#define HUGE_VAL (__builtin_huge_val())
#define HUGE_VALF (__builtin_huge_valf())
#define HUGE_VALL (__builtin_huge_vall())
#define INFINITY (__builtin_inff())
#define NAN (__builtin_nanf (""))
#define _MATH_H_MATHDEF 1
typedef float float_t;
typedef double double_t;
#define FP_ILOGB0 (-2147483647 - 1)
#define FP_ILOGBNAN (-2147483647 - 1)
#define __MATHCALL(function,suffix,args) __MATHDECL (_Mdouble_,function,suffix, args)
#define __MATHDECL(type,function,suffix,args) __MATHDECL_1(type, function,suffix, args); __MATHDECL_1(type, __CONCAT(__,function),suffix, args)
#define __MATHCALLX(function,suffix,args,attrib) __MATHDECLX (_Mdouble_,function,suffix, args, attrib)
#define __MATHDECLX(type,function,suffix,args,attrib) __MATHDECL_1(type, function,suffix, args) __attribute__ (attrib); __MATHDECL_1(type, __CONCAT(__,function),suffix, args) __attribute__ (attrib)
#define __MATHDECL_1(type,function,suffix,args) extern type __MATH_PRECNAME(function,suffix) args __THROW
#define _Mdouble_ double
#define __MATH_PRECNAME(name,r) __CONCAT(name,r)
#define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_STD
#define _Mdouble_END_NAMESPACE __END_NAMESPACE_STD
extern double acos (double __x) throw (); extern double __acos (double __x) throw ();
extern double asin (double __x) throw (); extern double __asin (double __x) throw ();
extern double atan (double __x) throw (); extern double __atan (double __x) throw ();
extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();
extern double cos (double __x) throw (); extern double __cos (double __x) throw ();
extern double sin (double __x) throw (); extern double __sin (double __x) throw ();
extern double tan (double __x) throw (); extern double __tan (double __x) throw ();
extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();
extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();
extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();
extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ();
extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();
extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();
extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();
extern double exp (double __x) throw (); extern double __exp (double __x) throw ();
extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();
extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();
extern double log (double __x) throw (); extern double __log (double __x) throw ();
extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();
extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw () __attribute__ ((__nonnull__ (2)));
extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();
extern double pow10 (double __x) throw (); extern double __pow10 (double __x) throw ();
extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();
extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();
extern double logb (double __x) throw (); extern double __logb (double __x) throw ();
extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();
extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();
extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();
extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();
extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();
extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();
extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));
extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));
extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));
extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();
extern int __isinf (double __value) throw () __attribute__ ((__const__));
extern int __finite (double __value) throw () __attribute__ ((__const__));
extern int isinf (double __value) throw () __attribute__ ((__const__));
extern int finite (double __value) throw () __attribute__ ((__const__));
extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();
extern double significand (double __x) throw (); extern double __significand (double __x) throw ();
extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));
extern double nan (const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (const char *__tagb) throw () __attribute__ ((__const__));
extern int __isnan (double __value) throw () __attribute__ ((__const__));
extern int isnan (double __value) throw () __attribute__ ((__const__));
extern double j0 (double) throw (); extern double __j0 (double) throw ();
extern double j1 (double) throw (); extern double __j1 (double) throw ();
extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
extern double y0 (double) throw (); extern double __y0 (double) throw ();
extern double y1 (double) throw (); extern double __y1 (double) throw ();
extern double yn (int, double) throw (); extern double __yn (int, double) throw ();
extern double erf (double) throw (); extern double __erf (double) throw ();
extern double erfc (double) throw (); extern double __erfc (double) throw ();
extern double lgamma (double) throw (); extern double __lgamma (double) throw ();
extern double tgamma (double) throw (); extern double __tgamma (double) throw ();
extern double gamma (double) throw (); extern double __gamma (double) throw ();
extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();
extern double rint (double __x) throw (); extern double __rint (double __x) throw ();
extern double nextafter (double __x, double __y) throw () __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) throw () __attribute__ ((__const__));
extern double nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) throw () __attribute__ ((__const__));
extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();
extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();
extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();
extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();
extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();
extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));
extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));
extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();
extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
__extension__
extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();
extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
__extension__
extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();
extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();
extern double fmax (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmax (double __x, double __y) throw () __attribute__ ((__const__));
extern double fmin (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmin (double __x, double __y) throw () __attribute__ ((__const__));
extern int __fpclassify (double __value) throw ()
__attribute__ ((__const__));
extern int __signbit (double __value) throw ()
__attribute__ ((__const__));
extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();
extern int __issignaling (double __value) throw ()
__attribute__ ((__const__));
extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
#undef _Mdouble_
#undef _Mdouble_BEGIN_NAMESPACE
#undef _Mdouble_END_NAMESPACE
#undef __MATH_PRECNAME
#define _Mfloat_ float
#define _Mdouble_ _Mfloat_
#define __MATH_PRECNAME(name,r) name ##f ##r
#define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_C99
#define _Mdouble_END_NAMESPACE __END_NAMESPACE_C99
extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();
extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();
extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();
extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();
extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();
extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();
extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();
extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();
extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();
extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();
extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw ();
extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();
extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();
extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();
extern float expf (float __x) throw (); extern float __expf (float __x) throw ();
extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();
extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();
extern float logf (float __x) throw (); extern float __logf (float __x) throw ();
extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();
extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw () __attribute__ ((__nonnull__ (2)));
extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();
extern float pow10f (float __x) throw (); extern float __pow10f (float __x) throw ();
extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();
extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();
extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();
extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();
extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();
extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();
extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();
extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();
extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();
extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));
extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));
extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));
extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();
extern int __isinff (float __value) throw () __attribute__ ((__const__));
extern int __finitef (float __value) throw () __attribute__ ((__const__));
extern int isinff (float __value) throw () __attribute__ ((__const__));
extern int finitef (float __value) throw () __attribute__ ((__const__));
extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();
extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();
extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));
extern float nanf (const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (const char *__tagb) throw () __attribute__ ((__const__));
extern int __isnanf (float __value) throw () __attribute__ ((__const__));
extern int isnanf (float __value) throw () __attribute__ ((__const__));
extern float j0f (float) throw (); extern float __j0f (float) throw ();
extern float j1f (float) throw (); extern float __j1f (float) throw ();
extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
extern float y0f (float) throw (); extern float __y0f (float) throw ();
extern float y1f (float) throw (); extern float __y1f (float) throw ();
extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();
extern float erff (float) throw (); extern float __erff (float) throw ();
extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();
extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();
extern float gammaf (float) throw (); extern float __gammaf (float) throw ();
extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();
extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();
extern float nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) throw () __attribute__ ((__const__));
extern float nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__));
extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();
extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();
extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();
extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();
extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();
extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));
extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));
extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();
extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
__extension__
extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();
extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
__extension__
extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();
extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();
extern float fmaxf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) throw () __attribute__ ((__const__));
extern float fminf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminf (float __x, float __y) throw () __attribute__ ((__const__));
extern int __fpclassifyf (float __value) throw ()
__attribute__ ((__const__));
extern int __signbitf (float __value) throw ()
__attribute__ ((__const__));
extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();
extern int __issignalingf (float __value) throw ()
__attribute__ ((__const__));
extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
#undef _Mdouble_
#undef _Mdouble_BEGIN_NAMESPACE
#undef _Mdouble_END_NAMESPACE
#undef __MATH_PRECNAME
#define _Mlong_double_ long double
#define _Mdouble_ _Mlong_double_
#define __MATH_PRECNAME(name,r) name ##l ##r
#define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_C99
#define _Mdouble_END_NAMESPACE __END_NAMESPACE_C99
#define __MATH_DECLARE_LDOUBLE 1
extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();
extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();
extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();
extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();
extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();
extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();
extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();
extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();
extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();
extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();
extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw ();
extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();
extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();
extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();
extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();
extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();
extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();
extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();
extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();
extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw () __attribute__ ((__nonnull__ (2)));
extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();
extern long double pow10l (long double __x) throw (); extern long double __pow10l (long double __x) throw ();
extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();
extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();
extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();
extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();
extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();
extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();
extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();
extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();
extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();
extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));
extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));
extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));
extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();
extern int __isinfl (long double __value) throw () __attribute__ ((__const__));
extern int __finitel (long double __value) throw () __attribute__ ((__const__));
extern int isinfl (long double __value) throw () __attribute__ ((__const__));
extern int finitel (long double __value) throw () __attribute__ ((__const__));
extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();
extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();
extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern long double nanl (const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (const char *__tagb) throw () __attribute__ ((__const__));
extern int __isnanl (long double __value) throw () __attribute__ ((__const__));
extern int isnanl (long double __value) throw () __attribute__ ((__const__));
extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();
extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();
extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();
extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();
extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();
extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();
extern long double nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern long double nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();
extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();
extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();
extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();
extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();
extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));
extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));
extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();
extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
__extension__
extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();
extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
__extension__
extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();
extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();
extern long double fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern long double fminl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern int __fpclassifyl (long double __value) throw ()
__attribute__ ((__const__));
extern int __signbitl (long double __value) throw ()
__attribute__ ((__const__));
extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();
extern int __issignalingl (long double __value) throw ()
__attribute__ ((__const__));
extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
#undef _Mdouble_
#undef _Mdouble_BEGIN_NAMESPACE
#undef _Mdouble_END_NAMESPACE
#undef __MATH_PRECNAME
#undef __MATHDECL_1
#undef __MATHDECL
#undef __MATHCALL
extern int signgam;
enum
{
FP_NAN =
#define FP_NAN 0
0,
FP_INFINITE =
#define FP_INFINITE 1
1,
FP_ZERO =
#define FP_ZERO 2
2,
FP_SUBNORMAL =
#define FP_SUBNORMAL 3
3,
FP_NORMAL =
#define FP_NORMAL 4
4
};
#define fpclassify(x) (sizeof (x) == sizeof (float) ? __fpclassifyf (x) : sizeof (x) == sizeof (double) ? __fpclassify (x) : __fpclassifyl (x))
#define signbit(x) (sizeof (x) == sizeof (float) ? __signbitf (x) : sizeof (x) == sizeof (double) ? __signbit (x) : __signbitl (x))
#define isfinite(x) (sizeof (x) == sizeof (float) ? __finitef (x) : sizeof (x) == sizeof (double) ? __finite (x) : __finitel (x))
#define isnormal(x) (fpclassify (x) == FP_NORMAL)
#define isnan(x) (sizeof (x) == sizeof (float) ? __isnanf (x) : sizeof (x) == sizeof (double) ? __isnan (x) : __isnanl (x))
#define isinf(x) (sizeof (x) == sizeof (float) ? __isinff (x) : sizeof (x) == sizeof (double) ? __isinf (x) : __isinfl (x))
#define MATH_ERRNO 1
#define MATH_ERREXCEPT 2
#define math_errhandling (MATH_ERRNO | MATH_ERREXCEPT)
#define issignaling(x) (sizeof (x) == sizeof (float) ? __issignalingf (x) : sizeof (x) == sizeof (double) ? __issignaling (x) : __issignalingl (x))
typedef enum
{
_IEEE_ = -1,
_SVID_,
_XOPEN_,
_POSIX_,
_ISOC_
} _LIB_VERSION_TYPE;
extern _LIB_VERSION_TYPE _LIB_VERSION;
struct __exception
{
int type;
char *name;
double arg1;
double arg2;
double retval;
};
extern int matherr (struct __exception *__exc) throw ();
#define X_TLOSS 1.41484755040568800000e+16
#define DOMAIN 1
#define SING 2
#define OVERFLOW 3
#define UNDERFLOW 4
#define TLOSS 5
#define PLOSS 6
#define HUGE 3.40282347e+38F
#define M_E 2.7182818284590452354
#define M_LOG2E 1.4426950408889634074
#define M_LOG10E 0.43429448190325182765
#define M_LN2 0.69314718055994530942
#define M_LN10 2.30258509299404568402
#define M_PI 3.14159265358979323846
#define M_PI_2 1.57079632679489661923
#define M_PI_4 0.78539816339744830962
#define M_1_PI 0.31830988618379067154
#define M_2_PI 0.63661977236758134308
#define M_2_SQRTPI 1.12837916709551257390
#define M_SQRT2 1.41421356237309504880
#define M_SQRT1_2 0.70710678118654752440
#define M_El 2.718281828459045235360287471352662498L
#define M_LOG2El 1.442695040888963407359924681001892137L
#define M_LOG10El 0.434294481903251827651128918916605082L
#define M_LN2l 0.693147180559945309417232121458176568L
#define M_LN10l 2.302585092994045684017991454684364208L
#define M_PIl 3.141592653589793238462643383279502884L
#define M_PI_2l 1.570796326794896619231321691639751442L
#define M_PI_4l 0.785398163397448309615660845819875721L
#define M_1_PIl 0.318309886183790671537767526745028724L
#define M_2_PIl 0.636619772367581343075535053490057448L
#define M_2_SQRTPIl 1.128379167095512573896158903121545172L
#define M_SQRT2l 1.414213562373095048801688724209698079L
#define M_SQRT1_2l 0.707106781186547524400844362104849039L
#define __NO_MATH_INLINES 1
#define isgreater(x,y) __builtin_isgreater(x, y)
#define isgreaterequal(x,y) __builtin_isgreaterequal(x, y)
#define isless(x,y) __builtin_isless(x, y)
#define islessequal(x,y) __builtin_islessequal(x, y)
#define islessgreater(x,y) __builtin_islessgreater(x, y)
#define isunordered(u,v) __builtin_isunordered(u, v)
}
#define _GLIBCXX_CMATH 1
#undef abs
#undef div
#undef acos
#undef asin
#undef atan
#undef atan2
#undef ceil
#undef cos
#undef cosh
#undef exp
#undef fabs
#undef floor
#undef fmod
#undef frexp
#undef ldexp
#undef log
#undef log10
#undef modf
#undef pow
#undef sin
#undef sinh
#undef sqrt
#undef tan
#undef tanh
namespace std __attribute__ ((__visibility__ ("default")))
{
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); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
abs(_Tp __x)
{ return __builtin_fabs(__x); }
using ::acos;
inline constexpr float
acos(float __x)
{ return __builtin_acosf(__x); }
inline constexpr long double
acos(long double __x)
{ return __builtin_acosl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
acos(_Tp __x)
{ return __builtin_acos(__x); }
using ::asin;
inline constexpr float
asin(float __x)
{ return __builtin_asinf(__x); }
inline constexpr long double
asin(long double __x)
{ return __builtin_asinl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
asin(_Tp __x)
{ return __builtin_asin(__x); }
using ::atan;
inline constexpr float
atan(float __x)
{ return __builtin_atanf(__x); }
inline constexpr long double
atan(long double __x)
{ return __builtin_atanl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
atan(_Tp __x)
{ return __builtin_atan(__x); }
using ::atan2;
inline constexpr float
atan2(float __y, float __x)
{ return __builtin_atan2f(__y, __x); }
inline constexpr long double
atan2(long double __y, long double __x)
{ return __builtin_atan2l(__y, __x); }
template<typename _Tp, typename _Up>
inline constexpr
typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
atan2(_Tp __y, _Up __x)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return atan2(__type(__y), __type(__x));
}
using ::ceil;
inline constexpr float
ceil(float __x)
{ return __builtin_ceilf(__x); }
inline constexpr long double
ceil(long double __x)
{ return __builtin_ceill(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
ceil(_Tp __x)
{ return __builtin_ceil(__x); }
using ::cos;
inline constexpr float
cos(float __x)
{ return __builtin_cosf(__x); }
inline constexpr long double
cos(long double __x)
{ return __builtin_cosl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
cos(_Tp __x)
{ return __builtin_cos(__x); }
using ::cosh;
inline constexpr float
cosh(float __x)
{ return __builtin_coshf(__x); }
inline constexpr long double
cosh(long double __x)
{ return __builtin_coshl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
cosh(_Tp __x)
{ return __builtin_cosh(__x); }
using ::exp;
inline constexpr float
exp(float __x)
{ return __builtin_expf(__x); }
inline constexpr long double
exp(long double __x)
{ return __builtin_expl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
exp(_Tp __x)
{ return __builtin_exp(__x); }
using ::fabs;
inline constexpr float
fabs(float __x)
{ return __builtin_fabsf(__x); }
inline constexpr long double
fabs(long double __x)
{ return __builtin_fabsl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
fabs(_Tp __x)
{ return __builtin_fabs(__x); }
using ::floor;
inline constexpr float
floor(float __x)
{ return __builtin_floorf(__x); }
inline constexpr long double
floor(long double __x)
{ return __builtin_floorl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
floor(_Tp __x)
{ return __builtin_floor(__x); }
using ::fmod;
inline constexpr float
fmod(float __x, float __y)
{ return __builtin_fmodf(__x, __y); }
inline constexpr long double
fmod(long double __x, long double __y)
{ return __builtin_fmodl(__x, __y); }
template<typename _Tp, typename _Up>
inline constexpr
typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
fmod(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return fmod(__type(__x), __type(__y));
}
using ::frexp;
float
frexp(float __x, int* __exp)
;
long double
frexp(long double __x, int* __exp)
;
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
frexp(_Tp __x, int* __exp)
{ return __builtin_frexp(__x, __exp); }
using ::ldexp;
inline constexpr float
ldexp(float __x, int __exp)
{ return __builtin_ldexpf(__x, __exp); }
inline constexpr long double
ldexp(long double __x, int __exp)
{ return __builtin_ldexpl(__x, __exp); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
ldexp(_Tp __x, int __exp)
{ return __builtin_ldexp(__x, __exp); }
using ::log;
inline constexpr float
log(float __x)
{ return __builtin_logf(__x); }
inline constexpr long double
log(long double __x)
{ return __builtin_logl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log(_Tp __x)
{ return __builtin_log(__x); }
using ::log10;
inline constexpr float
log10(float __x)
{ return __builtin_log10f(__x); }
inline constexpr long double
log10(long double __x)
{ return __builtin_log10l(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log10(_Tp __x)
{ return __builtin_log10(__x); }
using ::modf;
float
modf(float __x, float* __iptr)
;
long double
modf(long double __x, long double* __iptr)
;
using ::pow;
inline constexpr float
pow(float __x, float __y)
{ return __builtin_powf(__x, __y); }
inline constexpr long double
pow(long double __x, long double __y)
{ return __builtin_powl(__x, __y); }
template<typename _Tp, typename _Up>
inline constexpr
typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
pow(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return pow(__type(__x), __type(__y));
}
using ::sin;
inline constexpr float
sin(float __x)
{ return __builtin_sinf(__x); }
inline constexpr long double
sin(long double __x)
{ return __builtin_sinl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
sin(_Tp __x)
{ return __builtin_sin(__x); }
using ::sinh;
inline constexpr float
sinh(float __x)
{ return __builtin_sinhf(__x); }
inline constexpr long double
sinh(long double __x)
{ return __builtin_sinhl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
sinh(_Tp __x)
{ return __builtin_sinh(__x); }
using ::sqrt;
inline constexpr float
sqrt(float __x)
{ return __builtin_sqrtf(__x); }
inline constexpr long double
sqrt(long double __x)
{ return __builtin_sqrtl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
sqrt(_Tp __x)
{ return __builtin_sqrt(__x); }
using ::tan;
inline constexpr float
tan(float __x)
{ return __builtin_tanf(__x); }
inline constexpr long double
tan(long double __x)
{ return __builtin_tanl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
tan(_Tp __x)
{ return __builtin_tan(__x); }
using ::tanh;
inline constexpr float
tanh(float __x)
{ return __builtin_tanhf(__x); }
inline constexpr long double
tanh(long double __x)
{ return __builtin_tanhl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
tanh(_Tp __x)
{ return __builtin_tanh(__x); }
}
#undef fpclassify
#undef isfinite
#undef isinf
#undef isnan
#undef isnormal
#undef signbit
#undef isgreater
#undef isgreaterequal
#undef isless
#undef islessequal
#undef islessgreater
#undef isunordered
namespace std __attribute__ ((__visibility__ ("default")))
{
constexpr int
fpclassify(float __x)
{ return __builtin_fpclassify(0, 1, 4,
3, 2, __x); }
constexpr int
fpclassify(double __x)
{ return __builtin_fpclassify(0, 1, 4,
3, 2, __x); }
constexpr int
fpclassify(long double __x)
{ return __builtin_fpclassify(0, 1, 4,
3, 2, __x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
int>::__type
fpclassify(_Tp __x)
{ return __x != 0 ? 4 : 2; }
constexpr bool
isfinite(float __x)
{ return __builtin_isfinite(__x); }
constexpr bool
isfinite(double __x)
{ return __builtin_isfinite(__x); }
constexpr bool
isfinite(long double __x)
{ return __builtin_isfinite(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
isfinite(_Tp __x)
{ return true; }
constexpr bool
isinf(float __x)
{ return __builtin_isinf(__x); }
constexpr bool
isinf(double __x)
{ return __builtin_isinf(__x); }
constexpr bool
isinf(long double __x)
{ return __builtin_isinf(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
isinf(_Tp __x)
{ return false; }
constexpr bool
isnan(float __x)
{ return __builtin_isnan(__x); }
constexpr bool
isnan(double __x)
{ return __builtin_isnan(__x); }
constexpr bool
isnan(long double __x)
{ return __builtin_isnan(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
isnan(_Tp __x)
{ return false; }
constexpr bool
isnormal(float __x)
{ return __builtin_isnormal(__x); }
constexpr bool
isnormal(double __x)
{ return __builtin_isnormal(__x); }
constexpr bool
isnormal(long double __x)
{ return __builtin_isnormal(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
isnormal(_Tp __x)
{ return __x != 0 ? true : false; }
constexpr bool
signbit(float __x)
{ return __builtin_signbitf(__x); }
constexpr bool
signbit(double __x)
{ return __builtin_signbit(__x); }
constexpr bool
signbit(long double __x)
{ return __builtin_signbitl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
signbit(_Tp __x)
{ return __x < 0 ? true : false; }
constexpr bool
isgreater(float __x, float __y)
{ return __builtin_isgreater(__x, __y); }
constexpr bool
isgreater(double __x, double __y)
{ return __builtin_isgreater(__x, __y); }
constexpr bool
isgreater(long double __x, long double __y)
{ return __builtin_isgreater(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
isgreater(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_isgreater(__type(__x), __type(__y));
}
constexpr bool
isgreaterequal(float __x, float __y)
{ return __builtin_isgreaterequal(__x, __y); }
constexpr bool
isgreaterequal(double __x, double __y)
{ return __builtin_isgreaterequal(__x, __y); }
constexpr bool
isgreaterequal(long double __x, long double __y)
{ return __builtin_isgreaterequal(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
isgreaterequal(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_isgreaterequal(__type(__x), __type(__y));
}
constexpr bool
isless(float __x, float __y)
{ return __builtin_isless(__x, __y); }
constexpr bool
isless(double __x, double __y)
{ return __builtin_isless(__x, __y); }
constexpr bool
isless(long double __x, long double __y)
{ return __builtin_isless(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
isless(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_isless(__type(__x), __type(__y));
}
constexpr bool
islessequal(float __x, float __y)
{ return __builtin_islessequal(__x, __y); }
constexpr bool
islessequal(double __x, double __y)
{ return __builtin_islessequal(__x, __y); }
constexpr bool
islessequal(long double __x, long double __y)
{ return __builtin_islessequal(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
islessequal(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_islessequal(__type(__x), __type(__y));
}
constexpr bool
islessgreater(float __x, float __y)
{ return __builtin_islessgreater(__x, __y); }
constexpr bool
islessgreater(double __x, double __y)
{ return __builtin_islessgreater(__x, __y); }
constexpr bool
islessgreater(long double __x, long double __y)
{ return __builtin_islessgreater(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
islessgreater(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_islessgreater(__type(__x), __type(__y));
}
constexpr bool
isunordered(float __x, float __y)
{ return __builtin_isunordered(__x, __y); }
constexpr bool
isunordered(double __x, double __y)
{ return __builtin_isunordered(__x, __y); }
constexpr bool
isunordered(long double __x, long double __y)
{ return __builtin_isunordered(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
isunordered(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_isunordered(__type(__x), __type(__y));
}
}
#undef acosh
#undef acoshf
#undef acoshl
#undef asinh
#undef asinhf
#undef asinhl
#undef atanh
#undef atanhf
#undef atanhl
#undef cbrt
#undef cbrtf
#undef cbrtl
#undef copysign
#undef copysignf
#undef copysignl
#undef erf
#undef erff
#undef erfl
#undef erfc
#undef erfcf
#undef erfcl
#undef exp2
#undef exp2f
#undef exp2l
#undef expm1
#undef expm1f
#undef expm1l
#undef fdim
#undef fdimf
#undef fdiml
#undef fma
#undef fmaf
#undef fmal
#undef fmax
#undef fmaxf
#undef fmaxl
#undef fmin
#undef fminf
#undef fminl
#undef hypot
#undef hypotf
#undef hypotl
#undef ilogb
#undef ilogbf
#undef ilogbl
#undef lgamma
#undef lgammaf
#undef lgammal
#undef llrint
#undef llrintf
#undef llrintl
#undef llround
#undef llroundf
#undef llroundl
#undef log1p
#undef log1pf
#undef log1pl
#undef log2
#undef log2f
#undef log2l
#undef logb
#undef logbf
#undef logbl
#undef lrint
#undef lrintf
#undef lrintl
#undef lround
#undef lroundf
#undef lroundl
#undef nan
#undef nanf
#undef nanl
#undef nearbyint
#undef nearbyintf
#undef nearbyintl
#undef nextafter
#undef nextafterf
#undef nextafterl
#undef nexttoward
#undef nexttowardf
#undef nexttowardl
#undef remainder
#undef remainderf
#undef remainderl
#undef remquo
#undef remquof
#undef remquol
#undef rint
#undef rintf
#undef rintl
#undef round
#undef roundf
#undef roundl
#undef scalbln
#undef scalblnf
#undef scalblnl
#undef scalbn
#undef scalbnf
#undef scalbnl
#undef tgamma
#undef tgammaf
#undef tgammal
#undef trunc
#undef truncf
#undef truncl
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::double_t;
using ::float_t;
using ::acosh;
using ::acoshf;
using ::acoshl;
using ::asinh;
using ::asinhf;
using ::asinhl;
using ::atanh;
using ::atanhf;
using ::atanhl;
using ::cbrt;
using ::cbrtf;
using ::cbrtl;
using ::copysign;
using ::copysignf;
using ::copysignl;
using ::erf;
using ::erff;
using ::erfl;
using ::erfc;
using ::erfcf;
using ::erfcl;
using ::exp2;
using ::exp2f;
using ::exp2l;
using ::expm1;
using ::expm1f;
using ::expm1l;
using ::fdim;
using ::fdimf;
using ::fdiml;
using ::fma;
using ::fmaf;
using ::fmal;
using ::fmax;
using ::fmaxf;
using ::fmaxl;
using ::fmin;
using ::fminf;
using ::fminl;
using ::hypot;
using ::hypotf;
using ::hypotl;
using ::ilogb;
using ::ilogbf;
using ::ilogbl;
using ::lgamma;
using ::lgammaf;
using ::lgammal;
using ::llrint;
using ::llrintf;
using ::llrintl;
using ::llround;
using ::llroundf;
using ::llroundl;
using ::log1p;
using ::log1pf;
using ::log1pl;
using ::log2;
using ::log2f;
using ::log2l;
using ::logb;
using ::logbf;
using ::logbl;
using ::lrint;
using ::lrintf;
using ::lrintl;
using ::lround;
using ::lroundf;
using ::lroundl;
using ::nan;
using ::nanf;
using ::nanl;
using ::nearbyint;
using ::nearbyintf;
using ::nearbyintl;
using ::nextafter;
using ::nextafterf;
using ::nextafterl;
using ::nexttoward;
using ::nexttowardf;
using ::nexttowardl;
using ::remainder;
using ::remainderf;
using ::remainderl;
using ::remquo;
using ::remquof;
using ::remquol;
using ::rint;
using ::rintf;
using ::rintl;
using ::round;
using ::roundf;
using ::roundl;
using ::scalbln;
using ::scalblnf;
using ::scalblnl;
using ::scalbn;
using ::scalbnf;
using ::scalbnl;
using ::tgamma;
using ::tgammaf;
using ::tgammal;
using ::trunc;
using ::truncf;
using ::truncl;
constexpr float
acosh(float __x)
{ return __builtin_acoshf(__x); }
constexpr long double
acosh(long double __x)
{ return __builtin_acoshl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
acosh(_Tp __x)
{ return __builtin_acosh(__x); }
constexpr float
asinh(float __x)
{ return __builtin_asinhf(__x); }
constexpr long double
asinh(long double __x)
{ return __builtin_asinhl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
asinh(_Tp __x)
{ return __builtin_asinh(__x); }
constexpr float
atanh(float __x)
{ return __builtin_atanhf(__x); }
constexpr long double
atanh(long double __x)
{ return __builtin_atanhl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
atanh(_Tp __x)
{ return __builtin_atanh(__x); }
constexpr float
cbrt(float __x)
{ return __builtin_cbrtf(__x); }
constexpr long double
cbrt(long double __x)
{ return __builtin_cbrtl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
cbrt(_Tp __x)
{ return __builtin_cbrt(__x); }
constexpr float
copysign(float __x, float __y)
{ return __builtin_copysignf(__x, __y); }
constexpr long double
copysign(long double __x, long double __y)
{ return __builtin_copysignl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
copysign(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return copysign(__type(__x), __type(__y));
}
constexpr float
erf(float __x)
{ return __builtin_erff(__x); }
constexpr long double
erf(long double __x)
{ return __builtin_erfl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
erf(_Tp __x)
{ return __builtin_erf(__x); }
constexpr float
erfc(float __x)
{ return __builtin_erfcf(__x); }
constexpr long double
erfc(long double __x)
{ return __builtin_erfcl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
erfc(_Tp __x)
{ return __builtin_erfc(__x); }
constexpr float
exp2(float __x)
{ return __builtin_exp2f(__x); }
constexpr long double
exp2(long double __x)
{ return __builtin_exp2l(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
exp2(_Tp __x)
{ return __builtin_exp2(__x); }
constexpr float
expm1(float __x)
{ return __builtin_expm1f(__x); }
constexpr long double
expm1(long double __x)
{ return __builtin_expm1l(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
expm1(_Tp __x)
{ return __builtin_expm1(__x); }
constexpr float
fdim(float __x, float __y)
{ return __builtin_fdimf(__x, __y); }
constexpr long double
fdim(long double __x, long double __y)
{ return __builtin_fdiml(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
fdim(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return fdim(__type(__x), __type(__y));
}
constexpr float
fma(float __x, float __y, float __z)
{ return __builtin_fmaf(__x, __y, __z); }
constexpr long double
fma(long double __x, long double __y, long double __z)
{ return __builtin_fmal(__x, __y, __z); }
template<typename _Tp, typename _Up, typename _Vp>
constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
fma(_Tp __x, _Up __y, _Vp __z)
{
typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
return fma(__type(__x), __type(__y), __type(__z));
}
constexpr float
fmax(float __x, float __y)
{ return __builtin_fmaxf(__x, __y); }
constexpr long double
fmax(long double __x, long double __y)
{ return __builtin_fmaxl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
fmax(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return fmax(__type(__x), __type(__y));
}
constexpr float
fmin(float __x, float __y)
{ return __builtin_fminf(__x, __y); }
constexpr long double
fmin(long double __x, long double __y)
{ return __builtin_fminl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
fmin(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return fmin(__type(__x), __type(__y));
}
constexpr float
hypot(float __x, float __y)
{ return __builtin_hypotf(__x, __y); }
constexpr long double
hypot(long double __x, long double __y)
{ return __builtin_hypotl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
hypot(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return hypot(__type(__x), __type(__y));
}
constexpr int
ilogb(float __x)
{ return __builtin_ilogbf(__x); }
constexpr int
ilogb(long double __x)
{ return __builtin_ilogbl(__x); }
template<typename _Tp>
constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
int>::__type
ilogb(_Tp __x)
{ return __builtin_ilogb(__x); }
constexpr float
lgamma(float __x)
{ return __builtin_lgammaf(__x); }
constexpr long double
lgamma(long double __x)
{ return __builtin_lgammal(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
lgamma(_Tp __x)
{ return __builtin_lgamma(__x); }
constexpr long long
llrint(float __x)
{ return __builtin_llrintf(__x); }
constexpr long long
llrint(long double __x)
{ return __builtin_llrintl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
long long>::__type
llrint(_Tp __x)
{ return __builtin_llrint(__x); }
constexpr long long
llround(float __x)
{ return __builtin_llroundf(__x); }
constexpr long long
llround(long double __x)
{ return __builtin_llroundl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
long long>::__type
llround(_Tp __x)
{ return __builtin_llround(__x); }
constexpr float
log1p(float __x)
{ return __builtin_log1pf(__x); }
constexpr long double
log1p(long double __x)
{ return __builtin_log1pl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log1p(_Tp __x)
{ return __builtin_log1p(__x); }
constexpr float
log2(float __x)
{ return __builtin_log2f(__x); }
constexpr long double
log2(long double __x)
{ return __builtin_log2l(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log2(_Tp __x)
{ return __builtin_log2(__x); }
constexpr float
logb(float __x)
{ return __builtin_logbf(__x); }
constexpr long double
logb(long double __x)
{ return __builtin_logbl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
logb(_Tp __x)
{ return __builtin_logb(__x); }
constexpr long
lrint(float __x)
{ return __builtin_lrintf(__x); }
constexpr long
lrint(long double __x)
{ return __builtin_lrintl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
long>::__type
lrint(_Tp __x)
{ return __builtin_lrint(__x); }
constexpr long
lround(float __x)
{ return __builtin_lroundf(__x); }
constexpr long
lround(long double __x)
{ return __builtin_lroundl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
long>::__type
lround(_Tp __x)
{ return __builtin_lround(__x); }
constexpr float
nearbyint(float __x)
{ return __builtin_nearbyintf(__x); }
constexpr long double
nearbyint(long double __x)
{ return __builtin_nearbyintl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
nearbyint(_Tp __x)
{ return __builtin_nearbyint(__x); }
constexpr float
nextafter(float __x, float __y)
{ return __builtin_nextafterf(__x, __y); }
constexpr long double
nextafter(long double __x, long double __y)
{ return __builtin_nextafterl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
nextafter(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return nextafter(__type(__x), __type(__y));
}
constexpr float
nexttoward(float __x, long double __y)
{ return __builtin_nexttowardf(__x, __y); }
constexpr long double
nexttoward(long double __x, long double __y)
{ return __builtin_nexttowardl(__x, __y); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
nexttoward(_Tp __x, long double __y)
{ return __builtin_nexttoward(__x, __y); }
constexpr float
remainder(float __x, float __y)
{ return __builtin_remainderf(__x, __y); }
constexpr long double
remainder(long double __x, long double __y)
{ return __builtin_remainderl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
remainder(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return remainder(__type(__x), __type(__y));
}
inline float
remquo(float __x, float __y, int* __pquo)
{ return __builtin_remquof(__x, __y, __pquo); }
inline long double
remquo(long double __x, long double __y, int* __pquo)
{ return __builtin_remquol(__x, __y, __pquo); }
template<typename _Tp, typename _Up>
inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
remquo(_Tp __x, _Up __y, int* __pquo)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return remquo(__type(__x), __type(__y), __pquo);
}
constexpr float
rint(float __x)
{ return __builtin_rintf(__x); }
constexpr long double
rint(long double __x)
{ return __builtin_rintl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
rint(_Tp __x)
{ return __builtin_rint(__x); }
constexpr float
round(float __x)
{ return __builtin_roundf(__x); }
constexpr long double
round(long double __x)
{ return __builtin_roundl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
round(_Tp __x)
{ return __builtin_round(__x); }
constexpr float
scalbln(float __x, long __ex)
{ return __builtin_scalblnf(__x, __ex); }
constexpr long double
scalbln(long double __x, long __ex)
{ return __builtin_scalblnl(__x, __ex); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
scalbln(_Tp __x, long __ex)
{ return __builtin_scalbln(__x, __ex); }
constexpr float
scalbn(float __x, int __ex)
{ return __builtin_scalbnf(__x, __ex); }
constexpr long double
scalbn(long double __x, int __ex)
{ return __builtin_scalbnl(__x, __ex); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
scalbn(_Tp __x, int __ex)
{ return __builtin_scalbn(__x, __ex); }
constexpr float
tgamma(float __x)
{ return __builtin_tgammaf(__x); }
constexpr long double
tgamma(long double __x)
{ return __builtin_tgammal(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
tgamma(_Tp __x)
{ return __builtin_tgamma(__x); }
constexpr float
trunc(float __x)
{ return __builtin_truncf(__x); }
constexpr long double
trunc(long double __x)
{ return __builtin_truncl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
trunc(_Tp __x)
{ return __builtin_trunc(__x); }
}
#define _RANDOM_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _RealType, size_t __bits,
typename _UniformRandomNumberGenerator>
_RealType
generate_canonical(_UniformRandomNumberGenerator& __g);
namespace __detail
{
template<typename _UIntType, size_t __w,
bool = __w < static_cast<size_t>
(std::numeric_limits<_UIntType>::digits)>
struct _Shift
{ static const _UIntType __value = 0; };
template<typename _UIntType, size_t __w>
struct _Shift<_UIntType, __w, true>
{ static const _UIntType __value = _UIntType(1) << __w; };
template<int __s,
int __which = ((__s <= 8 * sizeof (int))
+ (__s <= 8 * sizeof (long))
+ (__s <= 8 * sizeof (long long))
+ (__s <= 128))>
struct _Select_uint_least_t
{
static_assert(__which < 0,
"sorry, would be too much trouble for a slow result");
};
template<int __s>
struct _Select_uint_least_t<__s, 4>
{ typedef unsigned int type; };
template<int __s>
struct _Select_uint_least_t<__s, 3>
{ typedef unsigned long type; };
template<int __s>
struct _Select_uint_least_t<__s, 2>
{ typedef unsigned long long type; };
template<int __s>
struct _Select_uint_least_t<__s, 1>
{ typedef unsigned __int128 type; };
template<typename _Tp, _Tp __m, _Tp __a, _Tp __c,
bool __big_enough = (!(__m & (__m - 1))
|| (_Tp(-1) - __c) / __a >= __m - 1),
bool __schrage_ok = __m % __a < __m / __a>
struct _Mod
{
typedef typename _Select_uint_least_t<std::__lg(__a)
+ std::__lg(__m) + 2>::type _Tp2;
static _Tp
__calc(_Tp __x)
;
};
template<typename _Tp, _Tp __m, _Tp __a, _Tp __c>
struct _Mod<_Tp, __m, __a, __c, false, true>
{
static _Tp
__calc(_Tp __x);
};
template<typename _Tp, _Tp __m, _Tp __a, _Tp __c, bool __s>
struct _Mod<_Tp, __m, __a, __c, true, __s>
{
static _Tp
__calc(_Tp __x)
;
};
template<typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0>
_Tp
__mod(_Tp __x)
;
template<typename _Tp>
bool
_Power_of_2(_Tp __x)
;;
template<typename _Engine, typename _DInputType>
struct _Adaptor
{
static_assert(std::is_floating_point<_DInputType>::value,
"template argument not a floating point type");
public:
_Adaptor(_Engine& __g) ;
_DInputType
min() const
;
_DInputType
max() const
;
_DInputType
operator()()
;
private:
_Engine& _M_g;
};
}
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
class linear_congruential_engine
{
static_assert(std::is_unsigned<_UIntType>::value, "template argument "
"substituting _UIntType not an unsigned integral type");
static_assert(__m == 0u || (__a < __m && __c < __m),
"template argument substituting __m out of bounds");
public:
typedef _UIntType result_type;
static constexpr result_type multiplier = __a;
static constexpr result_type increment = __c;
static constexpr result_type modulus = __m;
static constexpr result_type default_seed = 1u;
explicit
linear_congruential_engine(result_type __s = default_seed)
;
template<typename _Sseq, typename = typename
std::enable_if<!std::is_same<_Sseq, linear_congruential_engine>::value>
::type>
explicit
linear_congruential_engine(_Sseq& __q)
;
void
seed(result_type __s = default_seed);
template<typename _Sseq>
typename std::enable_if<std::is_class<_Sseq>::value>::type
seed(_Sseq& __q);
static constexpr result_type
min()
{ return __c == 0u ? 1u : 0u; }
static constexpr result_type
max()
{ return __m - 1u; }
void
discard(unsigned long long __z)
{
for (; __z != 0ULL; --__z)
(*this)();
}
result_type
operator()()
{
_M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x);
return _M_x;
}
friend bool
operator==(const linear_congruential_engine& __lhs,
const linear_congruential_engine& __rhs)
{ return __lhs._M_x == __rhs._M_x; }
template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
_UIntType1 __m1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::linear_congruential_engine<_UIntType1,
__a1, __c1, __m1>& __lcr);
template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
_UIntType1 __m1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::linear_congruential_engine<_UIntType1, __a1,
__c1, __m1>& __lcr);
private:
_UIntType _M_x;
};
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
bool
operator!=(const std::linear_congruential_engine<_UIntType, __a,
__c, __m>& __lhs,
const std::linear_congruential_engine<_UIntType, __a,
__c, __m>& __rhs)
;
template<typename _UIntType, size_t __w,
size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t,
_UIntType __c, size_t __l, _UIntType __f>
class mersenne_twister_engine
{
static_assert(std::is_unsigned<_UIntType>::value, "template argument "
"substituting _UIntType not an unsigned integral type");
static_assert(1u <= __m && __m <= __n,
"template argument substituting __m out of bounds");
static_assert(__r <= __w, "template argument substituting "
"__r out of bound");
static_assert(__u <= __w, "template argument substituting "
"__u out of bound");
static_assert(__s <= __w, "template argument substituting "
"__s out of bound");
static_assert(__t <= __w, "template argument substituting "
"__t out of bound");
static_assert(__l <= __w, "template argument substituting "
"__l out of bound");
static_assert(__w <= std::numeric_limits<_UIntType>::digits,
"template argument substituting __w out of bound");
static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1),
"template argument substituting __a out of bound");
static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1),
"template argument substituting __b out of bound");
static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1),
"template argument substituting __c out of bound");
static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1),
"template argument substituting __d out of bound");
static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1),
"template argument substituting __f out of bound");
public:
typedef _UIntType result_type;
static constexpr size_t word_size = __w;
static constexpr size_t state_size = __n;
static constexpr size_t shift_size = __m;
static constexpr size_t mask_bits = __r;
static constexpr result_type xor_mask = __a;
static constexpr size_t tempering_u = __u;
static constexpr result_type tempering_d = __d;
static constexpr size_t tempering_s = __s;
static constexpr result_type tempering_b = __b;
static constexpr size_t tempering_t = __t;
static constexpr result_type tempering_c = __c;
static constexpr size_t tempering_l = __l;
static constexpr result_type initialization_multiplier = __f;
static constexpr result_type default_seed = 5489u;
explicit
mersenne_twister_engine(result_type __sd = default_seed)
;
template<typename _Sseq, typename = typename
std::enable_if<!std::is_same<_Sseq, mersenne_twister_engine>::value>
::type>
explicit
mersenne_twister_engine(_Sseq& __q)
;
void
seed(result_type __sd = default_seed);
template<typename _Sseq>
typename std::enable_if<std::is_class<_Sseq>::value>::type
seed(_Sseq& __q);
static constexpr result_type
min()
{ return 0; };
static constexpr result_type
max()
{ return __detail::_Shift<_UIntType, __w>::__value - 1; }
void
discard(unsigned long long __z);
result_type
operator()();
friend bool
operator==(const mersenne_twister_engine& __lhs,
const mersenne_twister_engine& __rhs)
;
template<typename _UIntType1,
size_t __w1, size_t __n1,
size_t __m1, size_t __r1,
_UIntType1 __a1, size_t __u1,
_UIntType1 __d1, size_t __s1,
_UIntType1 __b1, size_t __t1,
_UIntType1 __c1, size_t __l1, _UIntType1 __f1,
typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::mersenne_twister_engine<_UIntType1, __w1, __n1,
__m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
__l1, __f1>& __x);
template<typename _UIntType1,
size_t __w1, size_t __n1,
size_t __m1, size_t __r1,
_UIntType1 __a1, size_t __u1,
_UIntType1 __d1, size_t __s1,
_UIntType1 __b1, size_t __t1,
_UIntType1 __c1, size_t __l1, _UIntType1 __f1,
typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::mersenne_twister_engine<_UIntType1, __w1, __n1, __m1,
__r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
__l1, __f1>& __x);
private:
void _M_gen_rand();
_UIntType _M_x[state_size];
size_t _M_p;
};
template<typename _UIntType, size_t __w,
size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t,
_UIntType __c, size_t __l, _UIntType __f>
bool
operator!=(const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
__r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs,
const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
__r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs)
;
template<typename _UIntType, size_t __w, size_t __s, size_t __r>
class subtract_with_carry_engine
{
static_assert(std::is_unsigned<_UIntType>::value, "template argument "
"substituting _UIntType not an unsigned integral type");
static_assert(0u < __s && __s < __r,
"template argument substituting __s out of bounds");
static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
"template argument substituting __w out of bounds");
public:
typedef _UIntType result_type;
static constexpr size_t word_size = __w;
static constexpr size_t short_lag = __s;
static constexpr size_t long_lag = __r;
static constexpr result_type default_seed = 19780503u;
explicit
subtract_with_carry_engine(result_type __sd = default_seed)
;
template<typename _Sseq, typename = typename
std::enable_if<!std::is_same<_Sseq, subtract_with_carry_engine>::value>
::type>
explicit
subtract_with_carry_engine(_Sseq& __q)
;
void
seed(result_type __sd = default_seed);
template<typename _Sseq>
typename std::enable_if<std::is_class<_Sseq>::value>::type
seed(_Sseq& __q);
static constexpr result_type
min()
{ return 0; }
static constexpr result_type
max()
{ return __detail::_Shift<_UIntType, __w>::__value - 1; }
void
discard(unsigned long long __z)
{
for (; __z != 0ULL; --__z)
(*this)();
}
result_type
operator()();
friend bool
operator==(const subtract_with_carry_engine& __lhs,
const subtract_with_carry_engine& __rhs)
;
template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::subtract_with_carry_engine<_UIntType1, __w1,
__s1, __r1>& __x);
template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::subtract_with_carry_engine<_UIntType1, __w1,
__s1, __r1>& __x);
private:
_UIntType _M_x[long_lag];
_UIntType _M_carry;
size_t _M_p;
};
template<typename _UIntType, size_t __w, size_t __s, size_t __r>
bool
operator!=(const std::subtract_with_carry_engine<_UIntType, __w,
__s, __r>& __lhs,
const std::subtract_with_carry_engine<_UIntType, __w,
__s, __r>& __rhs)
;
template<typename _RandomNumberEngine, size_t __p, size_t __r>
class discard_block_engine
{
static_assert(1 <= __r && __r <= __p,
"template argument substituting __r out of bounds");
public:
typedef typename _RandomNumberEngine::result_type result_type;
static constexpr size_t block_size = __p;
static constexpr size_t used_block = __r;
discard_block_engine()
: _M_b(), _M_n(0) { }
explicit
discard_block_engine(const _RandomNumberEngine& __rng)
: _M_b(__rng), _M_n(0) { }
explicit
discard_block_engine(_RandomNumberEngine&& __rng)
: _M_b(std::move(__rng)), _M_n(0) { }
explicit
discard_block_engine(result_type __s)
: _M_b(__s), _M_n(0) { }
template<typename _Sseq, typename = typename
std::enable_if<!std::is_same<_Sseq, discard_block_engine>::value
&& !std::is_same<_Sseq, _RandomNumberEngine>::value>
::type>
explicit
discard_block_engine(_Sseq& __q)
: _M_b(__q), _M_n(0)
{ }
void
seed()
;
void
seed(result_type __s)
;
template<typename _Sseq>
void
seed(_Sseq& __q)
;
const _RandomNumberEngine&
base() const noexcept
{ return _M_b; }
static constexpr result_type
min()
{ return _RandomNumberEngine::min(); }
static constexpr result_type
max()
{ return _RandomNumberEngine::max(); }
void
discard(unsigned long long __z)
{
for (; __z != 0ULL; --__z)
(*this)();
}
result_type
operator()();
friend bool
operator==(const discard_block_engine& __lhs,
const discard_block_engine& __rhs)
;
template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::discard_block_engine<_RandomNumberEngine1,
__p1, __r1>& __x);
template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::discard_block_engine<_RandomNumberEngine1,
__p1, __r1>& __x);
private:
_RandomNumberEngine _M_b;
size_t _M_n;
};
template<typename _RandomNumberEngine, size_t __p, size_t __r>
bool
operator!=(const std::discard_block_engine<_RandomNumberEngine, __p,
__r>& __lhs,
const std::discard_block_engine<_RandomNumberEngine, __p,
__r>& __rhs)
;
template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
class independent_bits_engine
{
static_assert(std::is_unsigned<_UIntType>::value, "template argument "
"substituting _UIntType not an unsigned integral type");
static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
"template argument substituting __w out of bounds");
public:
typedef _UIntType result_type;
independent_bits_engine() ;
explicit
independent_bits_engine(const _RandomNumberEngine& __rng) ;
explicit
independent_bits_engine(_RandomNumberEngine&& __rng) ;
explicit
independent_bits_engine(result_type __s) ;
template<typename _Sseq, typename = typename
std::enable_if<!std::is_same<_Sseq, independent_bits_engine>::value
&& !std::is_same<_Sseq, _RandomNumberEngine>::value>
::type>
explicit
independent_bits_engine(_Sseq& __q)
;
void
seed()
;
void
seed(result_type __s)
;
template<typename _Sseq>
void
seed(_Sseq& __q)
;
const _RandomNumberEngine&
base() const noexcept
{ return _M_b; }
static constexpr result_type
min()
{ return 0U; }
static constexpr result_type
max()
{ return __detail::_Shift<_UIntType, __w>::__value - 1; }
void
discard(unsigned long long __z)
{
for (; __z != 0ULL; --__z)
(*this)();
}
result_type
operator()();
friend bool
operator==(const independent_bits_engine& __lhs,
const independent_bits_engine& __rhs)
;
template<typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::independent_bits_engine<_RandomNumberEngine,
__w, _UIntType>& __x)
;
private:
_RandomNumberEngine _M_b;
};
template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
bool
operator!=(const std::independent_bits_engine<_RandomNumberEngine, __w,
_UIntType>& __lhs,
const std::independent_bits_engine<_RandomNumberEngine, __w,
_UIntType>& __rhs)
;
template<typename _RandomNumberEngine, size_t __w, typename _UIntType,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::independent_bits_engine<_RandomNumberEngine,
__w, _UIntType>& __x)
;
template<typename _RandomNumberEngine, size_t __k>
class shuffle_order_engine
{
static_assert(1u <= __k, "template argument substituting "
"__k out of bound");
public:
typedef typename _RandomNumberEngine::result_type result_type;
static constexpr size_t table_size = __k;
shuffle_order_engine()
;
explicit
shuffle_order_engine(const _RandomNumberEngine& __rng)
;
explicit
shuffle_order_engine(_RandomNumberEngine&& __rng)
;
explicit
shuffle_order_engine(result_type __s)
;
template<typename _Sseq, typename = typename
std::enable_if<!std::is_same<_Sseq, shuffle_order_engine>::value
&& !std::is_same<_Sseq, _RandomNumberEngine>::value>
::type>
explicit
shuffle_order_engine(_Sseq& __q)
;
void
seed()
;
void
seed(result_type __s)
;
template<typename _Sseq>
void
seed(_Sseq& __q)
;
const _RandomNumberEngine&
base() const noexcept
{ return _M_b; }
static constexpr result_type
min()
{ return _RandomNumberEngine::min(); }
static constexpr result_type
max()
{ return _RandomNumberEngine::max(); }
void
discard(unsigned long long __z)
{
for (; __z != 0ULL; --__z)
(*this)();
}
result_type
operator()();
friend bool
operator==(const shuffle_order_engine& __lhs,
const shuffle_order_engine& __rhs)
;
template<typename _RandomNumberEngine1, size_t __k1,
typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::shuffle_order_engine<_RandomNumberEngine1,
__k1>& __x);
template<typename _RandomNumberEngine1, size_t __k1,
typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::shuffle_order_engine<_RandomNumberEngine1, __k1>& __x);
private:
void _M_initialize()
;
_RandomNumberEngine _M_b;
result_type _M_v[__k];
result_type _M_y;
};
template<typename _RandomNumberEngine, size_t __k>
bool
operator!=(const std::shuffle_order_engine<_RandomNumberEngine,
__k>& __lhs,
const std::shuffle_order_engine<_RandomNumberEngine,
__k>& __rhs)
;
typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
minstd_rand0;
typedef linear_congruential_engine<uint_fast32_t, 48271UL, 0UL, 2147483647UL>
minstd_rand;
typedef mersenne_twister_engine<
uint_fast32_t,
32, 624, 397, 31,
0x9908b0dfUL, 11,
0xffffffffUL, 7,
0x9d2c5680UL, 15,
0xefc60000UL, 18, 1812433253UL> mt19937;
typedef mersenne_twister_engine<
uint_fast64_t,
64, 312, 156, 31,
0xb5026f5aa96619e9ULL, 29,
0x5555555555555555ULL, 17,
0x71d67fffeda60000ULL, 37,
0xfff7eee000000000ULL, 43,
6364136223846793005ULL> mt19937_64;
typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>
ranlux24_base;
typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>
ranlux48_base;
typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
typedef minstd_rand0 default_random_engine;
class random_device
{
public:
typedef unsigned int result_type;
explicit
random_device(const std::string& __token = "default")
;
~random_device()
;
static constexpr result_type
min()
{ return std::numeric_limits<result_type>::min(); }
static constexpr result_type
max()
{ return std::numeric_limits<result_type>::max(); }
double
entropy() const noexcept
{ return 0.0; }
result_type
operator()()
{
return this->_M_getval();
}
random_device(const random_device&) = delete;
void operator=(const random_device&) = delete;
private:
void _M_init(const std::string& __token);
void _M_init_pretr1(const std::string& __token);
void _M_fini();
result_type _M_getval();
result_type _M_getval_pretr1();
union
{
void* _M_file;
mt19937 _M_mt;
};
};
template<typename _IntType = int>
class uniform_int_distribution
{
static_assert(std::is_integral<_IntType>::value,
"template argument not 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())
;
result_type
a() const
;
result_type
b() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_IntType _M_a;
_IntType _M_b;
};
public:
explicit
uniform_int_distribution(_IntType __a = 0,
_IntType __b = std::numeric_limits<_IntType>::max())
;
explicit
uniform_int_distribution(const param_type& __p)
;
void
reset() ;
result_type
a() const
;
result_type
b() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const uniform_int_distribution& __d1,
const uniform_int_distribution& __d2)
;
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>
bool
operator!=(const std::uniform_int_distribution<_IntType>& __d1,
const std::uniform_int_distribution<_IntType>& __d2)
;
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>&,
const std::uniform_int_distribution<_IntType>&);
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>&,
std::uniform_int_distribution<_IntType>&);
template<typename _RealType = double>
class uniform_real_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef uniform_real_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __a = _RealType(0),
_RealType __b = _RealType(1))
;
result_type
a() const
;
result_type
b() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_a;
_RealType _M_b;
};
public:
explicit
uniform_real_distribution(_RealType __a = _RealType(0),
_RealType __b = _RealType(1))
;
explicit
uniform_real_distribution(const param_type& __p)
;
void
reset() ;
result_type
a() const
;
result_type
b() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const uniform_real_distribution& __d1,
const uniform_real_distribution& __d2)
;
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>
bool
operator!=(const std::uniform_real_distribution<_IntType>& __d1,
const std::uniform_real_distribution<_IntType>& __d2)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>&,
const std::uniform_real_distribution<_RealType>&);
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>&,
std::uniform_real_distribution<_RealType>&);
template<typename _RealType = double>
class normal_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef normal_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __mean = _RealType(0),
_RealType __stddev = _RealType(1))
;
_RealType
mean() const
;
_RealType
stddev() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_mean;
_RealType _M_stddev;
};
public:
explicit
normal_distribution(result_type __mean = result_type(0),
result_type __stddev = result_type(1))
;
explicit
normal_distribution(const param_type& __p)
;
void
reset()
;
_RealType
mean() const
;
_RealType
stddev() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _RealType1>
friend bool
operator==(const std::normal_distribution<_RealType1>& __d1,
const std::normal_distribution<_RealType1>& __d2);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::normal_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::normal_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
result_type _M_saved;
bool _M_saved_available;
};
template<typename _RealType>
bool
operator!=(const std::normal_distribution<_RealType>& __d1,
const std::normal_distribution<_RealType>& __d2)
;
template<typename _RealType = double>
class lognormal_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef lognormal_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __m = _RealType(0),
_RealType __s = _RealType(1))
;
_RealType
m() const
;
_RealType
s() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_m;
_RealType _M_s;
};
explicit
lognormal_distribution(_RealType __m = _RealType(0),
_RealType __s = _RealType(1))
;
explicit
lognormal_distribution(const param_type& __p)
;
void
reset()
;
_RealType
m() const
;
_RealType
s() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const lognormal_distribution& __d1,
const lognormal_distribution& __d2)
;
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::lognormal_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::lognormal_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
std::normal_distribution<result_type> _M_nd;
};
template<typename _RealType>
bool
operator!=(const std::lognormal_distribution<_RealType>& __d1,
const std::lognormal_distribution<_RealType>& __d2)
;
template<typename _RealType = double>
class gamma_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef gamma_distribution<_RealType> distribution_type;
friend class gamma_distribution<_RealType>;
explicit
param_type(_RealType __alpha_val = _RealType(1),
_RealType __beta_val = _RealType(1))
;
_RealType
alpha() const
;
_RealType
beta() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
void
_M_initialize();
_RealType _M_alpha;
_RealType _M_beta;
_RealType _M_malpha, _M_a2;
};
public:
explicit
gamma_distribution(_RealType __alpha_val = _RealType(1),
_RealType __beta_val = _RealType(1))
;
explicit
gamma_distribution(const param_type& __p)
;
void
reset()
;
_RealType
alpha() const
;
_RealType
beta() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const gamma_distribution& __d1,
const gamma_distribution& __d2)
;
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::gamma_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::gamma_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
std::normal_distribution<result_type> _M_nd;
};
template<typename _RealType>
bool
operator!=(const std::gamma_distribution<_RealType>& __d1,
const std::gamma_distribution<_RealType>& __d2)
;
template<typename _RealType = double>
class chi_squared_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef chi_squared_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __n = _RealType(1))
;
_RealType
n() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_n;
};
explicit
chi_squared_distribution(_RealType __n = _RealType(1))
;
explicit
chi_squared_distribution(const param_type& __p)
;
void
reset()
;
_RealType
n() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const chi_squared_distribution& __d1,
const chi_squared_distribution& __d2)
;
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::chi_squared_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::chi_squared_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const typename
std::gamma_distribution<result_type>::param_type& __p);
param_type _M_param;
std::gamma_distribution<result_type> _M_gd;
};
template<typename _RealType>
bool
operator!=(const std::chi_squared_distribution<_RealType>& __d1,
const std::chi_squared_distribution<_RealType>& __d2)
;
template<typename _RealType = double>
class cauchy_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef cauchy_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __a = _RealType(0),
_RealType __b = _RealType(1))
;
_RealType
a() const
;
_RealType
b() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_a;
_RealType _M_b;
};
explicit
cauchy_distribution(_RealType __a = _RealType(0),
_RealType __b = _RealType(1))
;
explicit
cauchy_distribution(const param_type& __p)
;
void
reset()
;
_RealType
a() const
;
_RealType
b() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const cauchy_distribution& __d1,
const cauchy_distribution& __d2)
;
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
template<typename _RealType>
bool
operator!=(const std::cauchy_distribution<_RealType>& __d1,
const std::cauchy_distribution<_RealType>& __d2)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::cauchy_distribution<_RealType>& __x);
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::cauchy_distribution<_RealType>& __x);
template<typename _RealType = double>
class fisher_f_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef fisher_f_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __m = _RealType(1),
_RealType __n = _RealType(1))
;
_RealType
m() const
;
_RealType
n() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_m;
_RealType _M_n;
};
explicit
fisher_f_distribution(_RealType __m = _RealType(1),
_RealType __n = _RealType(1))
;
explicit
fisher_f_distribution(const param_type& __p)
;
void
reset()
;
_RealType
m() const
;
_RealType
n() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const fisher_f_distribution& __d1,
const fisher_f_distribution& __d2)
;
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::fisher_f_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::fisher_f_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
std::gamma_distribution<result_type> _M_gd_x, _M_gd_y;
};
template<typename _RealType>
bool
operator!=(const std::fisher_f_distribution<_RealType>& __d1,
const std::fisher_f_distribution<_RealType>& __d2)
;
template<typename _RealType = double>
class student_t_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef student_t_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __n = _RealType(1))
;
_RealType
n() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_n;
};
explicit
student_t_distribution(_RealType __n = _RealType(1))
;
explicit
student_t_distribution(const param_type& __p)
;
void
reset()
;
_RealType
n() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const student_t_distribution& __d1,
const student_t_distribution& __d2)
;
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::student_t_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::student_t_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
std::normal_distribution<result_type> _M_nd;
std::gamma_distribution<result_type> _M_gd;
};
template<typename _RealType>
bool
operator!=(const std::student_t_distribution<_RealType>& __d1,
const std::student_t_distribution<_RealType>& __d2)
;
class bernoulli_distribution
{
public:
typedef bool result_type;
struct param_type
{
typedef bernoulli_distribution distribution_type;
explicit
param_type(double __p = 0.5)
;
double
p() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
double _M_p;
};
public:
explicit
bernoulli_distribution(double __p = 0.5)
;
explicit
bernoulli_distribution(const param_type& __p)
;
void
reset() ;
double
p() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng, const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const bernoulli_distribution& __d1,
const bernoulli_distribution& __d2)
;
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
bool
operator!=(const std::bernoulli_distribution& __d1,
const std::bernoulli_distribution& __d2)
;
template<typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::bernoulli_distribution& __x);
template<typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::bernoulli_distribution& __x)
{
double __p;
__is >> __p;
__x.param(bernoulli_distribution::param_type(__p));
return __is;
}
template<typename _IntType = int>
class binomial_distribution
{
static_assert(std::is_integral<_IntType>::value,
"template argument not an integral type");
public:
typedef _IntType result_type;
struct param_type
{
typedef binomial_distribution<_IntType> distribution_type;
friend class binomial_distribution<_IntType>;
explicit
param_type(_IntType __t = _IntType(1), double __p = 0.5)
: _M_t(__t), _M_p(__p)
{
;
_M_initialize();
}
_IntType
t() const
{ return _M_t; }
double
p() const
{ return _M_p; }
friend bool
operator==(const param_type& __p1, const param_type& __p2)
{ return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; }
private:
void
_M_initialize();
_IntType _M_t;
double _M_p;
double _M_q;
double _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
_M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
bool _M_easy;
};
explicit
binomial_distribution(_IntType __t = _IntType(1),
double __p = 0.5)
: _M_param(__t, __p), _M_nd()
{ }
explicit
binomial_distribution(const param_type& __p)
: _M_param(__p), _M_nd()
{ }
void
reset()
{ _M_nd.reset(); }
_IntType
t() const
{ return _M_param.t(); }
double
p() const
{ return _M_param.p(); }
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const binomial_distribution& __d1,
const binomial_distribution& __d2)
;
template<typename _IntType1,
typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::binomial_distribution<_IntType1>& __x);
template<typename _IntType1,
typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::binomial_distribution<_IntType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _UniformRandomNumberGenerator>
result_type
_M_waiting(_UniformRandomNumberGenerator& __urng,
_IntType __t, double __q);
param_type _M_param;
std::normal_distribution<double> _M_nd;
};
template<typename _IntType>
bool
operator!=(const std::binomial_distribution<_IntType>& __d1,
const std::binomial_distribution<_IntType>& __d2)
;
template<typename _IntType = int>
class geometric_distribution
{
static_assert(std::is_integral<_IntType>::value,
"template argument not an integral type");
public:
typedef _IntType result_type;
struct param_type
{
typedef geometric_distribution<_IntType> distribution_type;
friend class geometric_distribution<_IntType>;
explicit
param_type(double __p = 0.5)
;
double
p() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
void
_M_initialize()
;
double _M_p;
double _M_log_1_p;
};
explicit
geometric_distribution(double __p = 0.5)
;
explicit
geometric_distribution(const param_type& __p)
;
void
reset() ;
double
p() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const geometric_distribution& __d1,
const geometric_distribution& __d2)
;
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>
bool
operator!=(const std::geometric_distribution<_IntType>& __d1,
const std::geometric_distribution<_IntType>& __d2)
;
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::geometric_distribution<_IntType>& __x);
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::geometric_distribution<_IntType>& __x);
template<typename _IntType = int>
class negative_binomial_distribution
{
static_assert(std::is_integral<_IntType>::value,
"template argument not an integral type");
public:
typedef _IntType result_type;
struct param_type
{
typedef negative_binomial_distribution<_IntType> distribution_type;
explicit
param_type(_IntType __k = 1, double __p = 0.5)
;
_IntType
k() const
;
double
p() const
{ return _M_p; }
friend bool
operator==(const param_type& __p1, const param_type& __p2)
{ return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; }
private:
_IntType _M_k;
double _M_p;
};
explicit
negative_binomial_distribution(_IntType __k = 1, double __p = 0.5)
: _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p)
{ }
explicit
negative_binomial_distribution(const param_type& __p)
: _M_param(__p), _M_gd(__p.k(), (1.0 - __p.p()) / __p.p())
{ }
void
reset()
;
_IntType
k() const
;
double
p() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng);
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const negative_binomial_distribution& __d1,
const negative_binomial_distribution& __d2)
;
template<typename _IntType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::negative_binomial_distribution<_IntType1>& __x);
template<typename _IntType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::negative_binomial_distribution<_IntType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
std::gamma_distribution<double> _M_gd;
};
template<typename _IntType>
bool
operator!=(const std::negative_binomial_distribution<_IntType>& __d1,
const std::negative_binomial_distribution<_IntType>& __d2)
;
template<typename _IntType = int>
class poisson_distribution
{
static_assert(std::is_integral<_IntType>::value,
"template argument not an integral type");
public:
typedef _IntType result_type;
struct param_type
{
typedef poisson_distribution<_IntType> distribution_type;
friend class poisson_distribution<_IntType>;
explicit
param_type(double __mean = 1.0)
;
double
mean() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
void
_M_initialize();
double _M_mean;
double _M_lm_thr;
double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
};
explicit
poisson_distribution(double __mean = 1.0)
: _M_param(__mean), _M_nd()
{ }
explicit
poisson_distribution(const param_type& __p)
: _M_param(__p), _M_nd()
{ }
void
reset()
{ _M_nd.reset(); }
double
mean() const
{ return _M_param.mean(); }
param_type
param() const
{ return _M_param; }
void
param(const param_type& __param)
{ _M_param = __param; }
result_type
min() const
{ return 0; }
result_type
max() const
{ return std::numeric_limits<result_type>::max(); }
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
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)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const poisson_distribution& __d1,
const poisson_distribution& __d2)
;
template<typename _IntType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::poisson_distribution<_IntType1>& __x);
template<typename _IntType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::poisson_distribution<_IntType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
std::normal_distribution<double> _M_nd;
};
template<typename _IntType>
bool
operator!=(const std::poisson_distribution<_IntType>& __d1,
const std::poisson_distribution<_IntType>& __d2)
;
template<typename _RealType = double>
class exponential_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef exponential_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __lambda = _RealType(1))
;
_RealType
lambda() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_lambda;
};
public:
explicit
exponential_distribution(const result_type& __lambda = result_type(1))
;
explicit
exponential_distribution(const param_type& __p)
;
void
reset() ;
_RealType
lambda() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const exponential_distribution& __d1,
const exponential_distribution& __d2)
;
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
template<typename _RealType>
bool
operator!=(const std::exponential_distribution<_RealType>& __d1,
const std::exponential_distribution<_RealType>& __d2)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::exponential_distribution<_RealType>& __x);
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::exponential_distribution<_RealType>& __x);
template<typename _RealType = double>
class weibull_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef weibull_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __a = _RealType(1),
_RealType __b = _RealType(1))
;
_RealType
a() const
;
_RealType
b() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_a;
_RealType _M_b;
};
explicit
weibull_distribution(_RealType __a = _RealType(1),
_RealType __b = _RealType(1))
;
explicit
weibull_distribution(const param_type& __p)
;
void
reset()
;
_RealType
a() const
;
_RealType
b() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const weibull_distribution& __d1,
const weibull_distribution& __d2)
;
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
template<typename _RealType>
bool
operator!=(const std::weibull_distribution<_RealType>& __d1,
const std::weibull_distribution<_RealType>& __d2)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::weibull_distribution<_RealType>& __x);
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::weibull_distribution<_RealType>& __x);
template<typename _RealType = double>
class extreme_value_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef extreme_value_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __a = _RealType(0),
_RealType __b = _RealType(1))
;
_RealType
a() const
;
_RealType
b() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_a;
_RealType _M_b;
};
explicit
extreme_value_distribution(_RealType __a = _RealType(0),
_RealType __b = _RealType(1))
;
explicit
extreme_value_distribution(const param_type& __p)
;
void
reset()
;
_RealType
a() const
;
_RealType
b() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
friend bool
operator==(const extreme_value_distribution& __d1,
const extreme_value_distribution& __d2)
{ return __d1._M_param == __d2._M_param; }
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
template<typename _RealType>
inline bool
operator!=(const std::extreme_value_distribution<_RealType>& __d1,
const std::extreme_value_distribution<_RealType>& __d2)
{ return !(__d1 == __d2); }
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::extreme_value_distribution<_RealType>& __x);
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::extreme_value_distribution<_RealType>& __x);
template<typename _IntType = int>
class discrete_distribution
{
static_assert(std::is_integral<_IntType>::value,
"template argument not an integral type");
public:
typedef _IntType result_type;
struct param_type
{
typedef discrete_distribution<_IntType> distribution_type;
friend class discrete_distribution<_IntType>;
param_type()
: _M_prob(), _M_cp()
{ }
template<typename _InputIterator>
param_type(_InputIterator __wbegin,
_InputIterator __wend)
: _M_prob(__wbegin, __wend), _M_cp()
{ _M_initialize(); }
param_type(initializer_list<double> __wil)
: _M_prob(__wil.begin(), __wil.end()), _M_cp()
{ _M_initialize(); }
template<typename _Func>
param_type(size_t __nw, double __xmin, double __xmax,
_Func __fw);
param_type(const param_type&) = default;
param_type& operator=(const param_type&) = default;
std::vector<double>
probabilities() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
void
_M_initialize();
std::vector<double> _M_prob;
std::vector<double> _M_cp;
};
discrete_distribution()
;
template<typename _InputIterator>
discrete_distribution(_InputIterator __wbegin,
_InputIterator __wend)
;
discrete_distribution(initializer_list<double> __wl)
;
template<typename _Func>
discrete_distribution(size_t __nw, double __xmin, double __xmax,
_Func __fw)
;
explicit
discrete_distribution(const param_type& __p)
;
void
reset()
;
std::vector<double>
probabilities() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
friend bool
operator==(const discrete_distribution& __d1,
const discrete_distribution& __d2)
{ return __d1._M_param == __d2._M_param; }
template<typename _IntType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::discrete_distribution<_IntType1>& __x);
template<typename _IntType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::discrete_distribution<_IntType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
template<typename _IntType>
inline bool
operator!=(const std::discrete_distribution<_IntType>& __d1,
const std::discrete_distribution<_IntType>& __d2)
{ return !(__d1 == __d2); }
template<typename _RealType = double>
class piecewise_constant_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef piecewise_constant_distribution<_RealType> distribution_type;
friend class piecewise_constant_distribution<_RealType>;
param_type()
: _M_int(), _M_den(), _M_cp()
{ }
template<typename _InputIteratorB, typename _InputIteratorW>
param_type(_InputIteratorB __bfirst,
_InputIteratorB __bend,
_InputIteratorW __wbegin);
template<typename _Func>
param_type(initializer_list<_RealType> __bi, _Func __fw);
template<typename _Func>
param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
_Func __fw);
param_type(const param_type&) = default;
param_type& operator=(const param_type&) = default;
std::vector<_RealType>
intervals() const
{
if (_M_int.empty())
{
std::vector<_RealType> __tmp(2);
__tmp[1] = _RealType(1);
return __tmp;
}
else
return _M_int;
}
std::vector<double>
densities() const
{ return _M_den.empty() ? std::vector<double>(1, 1.0) : _M_den; }
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
void
_M_initialize();
std::vector<_RealType> _M_int;
std::vector<double> _M_den;
std::vector<double> _M_cp;
};
explicit
piecewise_constant_distribution()
;
template<typename _InputIteratorB, typename _InputIteratorW>
piecewise_constant_distribution(_InputIteratorB __bfirst,
_InputIteratorB __bend,
_InputIteratorW __wbegin)
;
template<typename _Func>
piecewise_constant_distribution(initializer_list<_RealType> __bl,
_Func __fw)
;
template<typename _Func>
piecewise_constant_distribution(size_t __nw,
_RealType __xmin, _RealType __xmax,
_Func __fw)
;
explicit
piecewise_constant_distribution(const param_type& __p)
;
void
reset()
;
std::vector<_RealType>
intervals() const
;
std::vector<double>
densities() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
friend bool
operator==(const piecewise_constant_distribution& __d1,
const piecewise_constant_distribution& __d2)
{ return __d1._M_param == __d2._M_param; }
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::piecewise_constant_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::piecewise_constant_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
template<typename _RealType>
inline bool
operator!=(const std::piecewise_constant_distribution<_RealType>& __d1,
const std::piecewise_constant_distribution<_RealType>& __d2)
{ return !(__d1 == __d2); }
template<typename _RealType = double>
class piecewise_linear_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef piecewise_linear_distribution<_RealType> distribution_type;
friend class piecewise_linear_distribution<_RealType>;
param_type()
: _M_int(), _M_den(), _M_cp(), _M_m()
{ }
template<typename _InputIteratorB, typename _InputIteratorW>
param_type(_InputIteratorB __bfirst,
_InputIteratorB __bend,
_InputIteratorW __wbegin);
template<typename _Func>
param_type(initializer_list<_RealType> __bl, _Func __fw);
template<typename _Func>
param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
_Func __fw);
param_type(const param_type&) = default;
param_type& operator=(const param_type&) = default;
std::vector<_RealType>
intervals() const
{
if (_M_int.empty())
{
std::vector<_RealType> __tmp(2);
__tmp[1] = _RealType(1);
return __tmp;
}
else
return _M_int;
}
std::vector<double>
densities() const
{ return _M_den.empty() ? std::vector<double>(2, 1.0) : _M_den; }
friend bool
operator==(const param_type& __p1, const param_type& __p2)
{ return (__p1._M_int == __p2._M_int
&& __p1._M_den == __p2._M_den); }
private:
void
_M_initialize();
std::vector<_RealType> _M_int;
std::vector<double> _M_den;
std::vector<double> _M_cp;
std::vector<double> _M_m;
};
explicit
piecewise_linear_distribution()
;
template<typename _InputIteratorB, typename _InputIteratorW>
piecewise_linear_distribution(_InputIteratorB __bfirst,
_InputIteratorB __bend,
_InputIteratorW __wbegin)
;
template<typename _Func>
piecewise_linear_distribution(initializer_list<_RealType> __bl,
_Func __fw)
;
template<typename _Func>
piecewise_linear_distribution(size_t __nw,
_RealType __xmin, _RealType __xmax,
_Func __fw)
;
explicit
piecewise_linear_distribution(const param_type& __p)
;
void
reset()
;
std::vector<_RealType>
intervals() const
;
std::vector<double>
densities() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const piecewise_linear_distribution& __d1,
const piecewise_linear_distribution& __d2)
{ return __d1._M_param == __d2._M_param; }
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::piecewise_linear_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::piecewise_linear_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
template<typename _RealType>
inline bool
operator!=(const std::piecewise_linear_distribution<_RealType>& __d1,
const std::piecewise_linear_distribution<_RealType>& __d2)
{ return !(__d1 == __d2); }
class seed_seq
{
public:
typedef uint_least32_t result_type;
seed_seq()
: _M_v()
{ }
template<typename _IntType>
seed_seq(std::initializer_list<_IntType> il);
template<typename _InputIterator>
seed_seq(_InputIterator __begin, _InputIterator __end);
template<typename _RandomAccessIterator>
void
generate(_RandomAccessIterator __begin, _RandomAccessIterator __end);
size_t size() const
{ return _M_v.size(); }
template<typename OutputIterator>
void
param(OutputIterator __dest) const
;
private:
std::vector<result_type> _M_v;
};
}
#define _BITS_OPT_RANDOM_H 1
#define _X86INTRIN_H_INCLUDED
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bsfd (int __X)
;
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bsrd (int __X)
;
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bswapd (int __X)
;
#pragma GCC push_options
#pragma GCC target("sse4.2")
#define __DISABLE_SSE4_2__
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__crc32b (unsigned int __C, unsigned char __V)
;
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__crc32w (unsigned int __C, unsigned short __V)
;
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__crc32d (unsigned int __C, unsigned int __V)
;
#undef __DISABLE_SSE4_2__
#pragma GCC pop_options
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__popcntd (unsigned int __X)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rdpmc (int __S)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rdtsc (void)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rdtscp (unsigned int *__A)
;
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rolb (unsigned char __X, int __C)
;
extern unsigned short
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rolw (unsigned short __X, int __C)
;
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rold (unsigned int __X, int __C)
;
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rorb (unsigned char __X, int __C)
;
extern unsigned short
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rorw (unsigned short __X, int __C)
;
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rord (unsigned int __X, int __C)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__pause (void)
;
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bsfq (long long __X)
;
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bsrq (long long __X)
;
extern long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bswapq (long long __X)
;
#pragma GCC push_options
#pragma GCC target("sse4.2")
#define __DISABLE_SSE4_2__
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__crc32q (unsigned long long __C, unsigned long long __V)
;
#undef __DISABLE_SSE4_2__
#pragma GCC pop_options
extern long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__popcntq (unsigned long long __X)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rolq (unsigned long long __X, int __C)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rorq (unsigned long long __X, int __C)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__readeflags (void)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__writeeflags (unsigned long long X)
;
#define _bswap64(a) __bswapq(a)
#define _popcnt64(a) __popcntq(a)
#define _lrotl(a,b) __rolq((a), (b))
#define _lrotr(a,b) __rorq((a), (b))
#define _bit_scan_forward(a) __bsfd(a)
#define _bit_scan_reverse(a) __bsrd(a)
#define _bswap(a) __bswapd(a)
#define _popcnt32(a) __popcntd(a)
#define _rdpmc(a) __rdpmc(a)
#define _rdtsc() __rdtsc()
#define _rdtscp(a) __rdtscp(a)
#define _rotwl(a,b) __rolw((a), (b))
#define _rotwr(a,b) __rorw((a), (b))
#define _rotl(a,b) __rold((a), (b))
#define _rotr(a,b) __rord((a), (b))
#define _MMINTRIN_H_INCLUDED
typedef int __m64 __attribute__ ((__vector_size__ (8), __may_alias__));
typedef int __v2si __attribute__ ((__vector_size__ (8)));
typedef short __v4hi __attribute__ ((__vector_size__ (8)));
typedef char __v8qi __attribute__ ((__vector_size__ (8)));
typedef long long __v1di __attribute__ ((__vector_size__ (8)));
typedef float __v2sf __attribute__ ((__vector_size__ (8)));
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_empty (void)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_empty (void)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi32_si64 (int __i)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_from_int (int __i)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_from_int64 (long long __i)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_m64 (long long __i)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64x_si64 (long long __i)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pi64x (long long __i)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_si32 (__m64 __i)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_to_int (__m64 __i)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_to_int64 (__m64 __i)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtm64_si64 (__m64 __i)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_si64x (__m64 __i)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packs_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_packsswb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packs_pi32 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_packssdw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packs_pu16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_packuswb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpckhbw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpckhwd (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_pi32 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpckhdq (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpcklbw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpcklwd (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_pi32 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpckldq (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_pi32 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddd (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_si64 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddsb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddsw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_pu8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddusb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_pu16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddusw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_pi32 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubd (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_si64 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubsb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubsw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_pu8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubusb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_pu16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubusw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_madd_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmaddwd (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mulhi_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmulhw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mullo_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmullw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_pi16 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psllw (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_pi16 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psllwi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_pi32 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pslld (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_pi32 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pslldi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_si64 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psllq (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_si64 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psllqi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sra_pi16 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psraw (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srai_pi16 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrawi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sra_pi32 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrad (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srai_pi32 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psradi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_pi16 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrlw (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_pi16 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrlwi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_pi32 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrld (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_pi32 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrldi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_si64 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrlq (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_si64 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrlqi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_and_si64 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pand (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_andnot_si64 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pandn (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_or_si64 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_por (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_xor_si64 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pxor (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpeqb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpgtb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpeqw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpgtw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_pi32 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpeqd (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_pi32 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpgtd (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setzero_si64 (void)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pi32 (int __i1, int __i0)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pi16 (short __w3, short __w2, short __w1, short __w0)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pi8 (char __b7, char __b6, char __b5, char __b4,
char __b3, char __b2, char __b1, char __b0)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_pi32 (int __i0, int __i1)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_pi16 (short __w0, short __w1, short __w2, short __w3)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_pi8 (char __b0, char __b1, char __b2, char __b3,
char __b4, char __b5, char __b6, char __b7)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_pi32 (int __i)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_pi16 (short __w)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_pi8 (char __b)
;
#define _XMMINTRIN_H_INCLUDED
#define _MM_MALLOC_H_INCLUDED
extern "C" int posix_memalign (void **, size_t, size_t) throw ();
static void *
_mm_malloc (size_t size, size_t alignment)
;
static void
_mm_free (void * ptr)
;
enum _mm_hint
{
_MM_HINT_ET0 = 7,
_MM_HINT_ET1 = 6,
_MM_HINT_T0 = 3,
_MM_HINT_T1 = 2,
_MM_HINT_T2 = 1,
_MM_HINT_NTA = 0
};
#define _mm_prefetch(P,I) __builtin_prefetch ((P), ((I & 0x4) >> 2), (I & 0x3))
typedef float __m128 __attribute__ ((__vector_size__ (16), __may_alias__));
typedef float __v4sf __attribute__ ((__vector_size__ (16)));
#define _MM_SHUFFLE(fp3,fp2,fp1,fp0) (((fp3) << 6) | ((fp2) << 4) | ((fp1) << 2) | (fp0))
#define _MM_EXCEPT_MASK 0x003f
#define _MM_EXCEPT_INVALID 0x0001
#define _MM_EXCEPT_DENORM 0x0002
#define _MM_EXCEPT_DIV_ZERO 0x0004
#define _MM_EXCEPT_OVERFLOW 0x0008
#define _MM_EXCEPT_UNDERFLOW 0x0010
#define _MM_EXCEPT_INEXACT 0x0020
#define _MM_MASK_MASK 0x1f80
#define _MM_MASK_INVALID 0x0080
#define _MM_MASK_DENORM 0x0100
#define _MM_MASK_DIV_ZERO 0x0200
#define _MM_MASK_OVERFLOW 0x0400
#define _MM_MASK_UNDERFLOW 0x0800
#define _MM_MASK_INEXACT 0x1000
#define _MM_ROUND_MASK 0x6000
#define _MM_ROUND_NEAREST 0x0000
#define _MM_ROUND_DOWN 0x2000
#define _MM_ROUND_UP 0x4000
#define _MM_ROUND_TOWARD_ZERO 0x6000
#define _MM_FLUSH_ZERO_MASK 0x8000
#define _MM_FLUSH_ZERO_ON 0x8000
#define _MM_FLUSH_ZERO_OFF 0x0000
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_undefined_ps (void)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setzero_ps (void)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_div_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sqrt_ss (__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rcp_ss (__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rsqrt_ss (__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_div_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sqrt_ps (__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rcp_ps (__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rsqrt_ps (__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_and_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_andnot_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_or_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_xor_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmple_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpge_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpneq_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnlt_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnle_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpngt_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnge_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpord_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpunord_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmple_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpge_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpneq_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnlt_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnle_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpngt_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnge_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpord_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpunord_ps (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comieq_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comilt_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comile_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comigt_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comige_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comineq_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomieq_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomilt_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomile_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomigt_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomige_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomineq_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_si32 (__m128 __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvt_ss2si (__m128 __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_si64 (__m128 __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_si64x (__m128 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtps_pi32 (__m128 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvt_ps2pi (__m128 __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_si32 (__m128 __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtt_ss2si (__m128 __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_si64 (__m128 __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_si64x (__m128 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttps_pi32 (__m128 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtt_ps2pi (__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi32_ss (__m128 __A, int __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvt_si2ss (__m128 __A, int __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_ss (__m128 __A, long long __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64x_ss (__m128 __A, long long __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpi32_ps (__m128 __A, __m64 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvt_pi2ps (__m128 __A, __m64 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpi16_ps (__m64 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpu16_ps (__m64 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpi8_ps (__m64 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpu8_ps(__m64 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpi32x2_ps(__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtps_pi16(__m128 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtps_pi8(__m128 __A)
;
#define _mm_shuffle_ps(A,B,MASK) ((__m128) __builtin_ia32_shufps ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(MASK)))
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadh_pi (__m128 __A, __m64 const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storeh_pi (__m64 *__P, __m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movehl_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movelh_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadl_pi (__m128 __A, __m64 const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storel_pi (__m64 *__P, __m128 __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movemask_ps (__m128 __A)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_getcsr (void)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_GET_EXCEPTION_STATE (void)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_GET_EXCEPTION_MASK (void)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_GET_ROUNDING_MODE (void)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_GET_FLUSH_ZERO_MODE (void)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setcsr (unsigned int __I)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_SET_EXCEPTION_STATE(unsigned int __mask)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_SET_EXCEPTION_MASK (unsigned int __mask)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_SET_ROUNDING_MODE (unsigned int __mode)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_SET_FLUSH_ZERO_MODE (unsigned int __mode)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_ss (float __F)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_ps (float __F)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_ps1 (float __F)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_ss (float const *__P)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load1_ps (float const *__P)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_ps1 (float const *__P)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_ps (float const *__P)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadu_ps (float const *__P)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadr_ps (float const *__P)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_ps (const float __Z, const float __Y, const float __X, const float __W)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_ps (float __Z, float __Y, float __X, float __W)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_ss (float *__P, __m128 __A)
;
extern float __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_f32 (__m128 __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_ps (float *__P, __m128 __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storeu_ps (float *__P, __m128 __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store1_ps (float *__P, __m128 __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_ps1 (float *__P, __m128 __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storer_ps (float *__P, __m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_move_ss (__m128 __A, __m128 __B)
;
#define _mm_extract_pi16(A,N) ((int) __builtin_ia32_vec_ext_v4hi ((__v4hi)(__m64)(A), (int)(N)))
#define _m_pextrw(A,N) _mm_extract_pi16(A, N)
#define _mm_insert_pi16(A,D,N) ((__m64) __builtin_ia32_vec_set_v4hi ((__v4hi)(__m64)(A), (int)(D), (int)(N)))
#define _m_pinsrw(A,D,N) _mm_insert_pi16(A, D, N)
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_pi16 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmaxsw (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_pu8 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmaxub (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_pi16 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pminsw (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_pu8 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pminub (__m64 __A, __m64 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movemask_pi8 (__m64 __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmovmskb (__m64 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mulhi_pu16 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmulhuw (__m64 __A, __m64 __B)
;
#define _mm_shuffle_pi16(A,N) ((__m64) __builtin_ia32_pshufw ((__v4hi)(__m64)(A), (int)(N)))
#define _m_pshufw(A,N) _mm_shuffle_pi16 (A, N)
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskmove_si64 (__m64 __A, __m64 __N, char *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_maskmovq (__m64 __A, __m64 __N, char *__P)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_avg_pu8 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pavgb (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_avg_pu16 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pavgw (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sad_pu8 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psadbw (__m64 __A, __m64 __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_pi (__m64 *__P, __m64 __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_ps (float *__P, __m128 __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sfence (void)
;
#define _MM_TRANSPOSE4_PS(row0,row1,row2,row3) do { __v4sf __r0 = (row0), __r1 = (row1), __r2 = (row2), __r3 = (row3); __v4sf __t0 = __builtin_ia32_unpcklps (__r0, __r1); __v4sf __t1 = __builtin_ia32_unpcklps (__r2, __r3); __v4sf __t2 = __builtin_ia32_unpckhps (__r0, __r1); __v4sf __t3 = __builtin_ia32_unpckhps (__r2, __r3); (row0) = __builtin_ia32_movlhps (__t0, __t1); (row1) = __builtin_ia32_movhlps (__t1, __t0); (row2) = __builtin_ia32_movlhps (__t2, __t3); (row3) = __builtin_ia32_movhlps (__t3, __t2); } while (0)
#define _EMMINTRIN_H_INCLUDED
typedef double __v2df __attribute__ ((__vector_size__ (16)));
typedef long long __v2di __attribute__ ((__vector_size__ (16)));
typedef int __v4si __attribute__ ((__vector_size__ (16)));
typedef short __v8hi __attribute__ ((__vector_size__ (16)));
typedef char __v16qi __attribute__ ((__vector_size__ (16)));
typedef long long __m128i __attribute__ ((__vector_size__ (16), __may_alias__));
typedef double __m128d __attribute__ ((__vector_size__ (16), __may_alias__));
#define _MM_SHUFFLE2(fp1,fp0) (((fp1) << 1) | (fp0))
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_sd (double __F)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_pd (double __F)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pd1 (double __F)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pd (double __W, double __X)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_pd (double __W, double __X)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_undefined_pd (void)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setzero_pd (void)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_move_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_pd (double const *__P)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadu_pd (double const *__P)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load1_pd (double const *__P)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_sd (double const *__P)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_pd1 (double const *__P)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadr_pd (double const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_pd (double *__P, __m128d __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storeu_pd (double *__P, __m128d __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_sd (double *__P, __m128d __A)
;
extern double __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_f64 (__m128d __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storel_pd (double *__P, __m128d __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storeh_pd (double *__P, __m128d __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store1_pd (double *__P, __m128d __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_pd1 (double *__P, __m128d __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storer_pd (double *__P, __m128d __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi128_si32 (__m128i __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi128_si64 (__m128i __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi128_si64x (__m128i __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_div_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_div_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sqrt_pd (__m128d __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sqrt_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_and_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_andnot_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_or_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_xor_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmple_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpge_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpneq_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnlt_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnle_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpngt_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnge_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpord_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpunord_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmple_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpge_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpneq_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnlt_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnle_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpngt_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnge_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpord_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpunord_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comieq_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comilt_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comile_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comigt_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comige_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comineq_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomieq_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomilt_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomile_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomigt_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomige_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomineq_sd (__m128d __A, __m128d __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_epi64x (long long __q1, long long __q0)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_epi64 (__m64 __q1, __m64 __q0)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_epi32 (int __q3, int __q2, int __q1, int __q0)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_epi16 (short __q7, short __q6, short __q5, short __q4,
short __q3, short __q2, short __q1, short __q0)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_epi8 (char __q15, char __q14, char __q13, char __q12,
char __q11, char __q10, char __q09, char __q08,
char __q07, char __q06, char __q05, char __q04,
char __q03, char __q02, char __q01, char __q00)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_epi64x (long long __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_epi64 (__m64 __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_epi32 (int __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_epi16 (short __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_epi8 (char __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_epi64 (__m64 __q0, __m64 __q1)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_epi32 (int __q0, int __q1, int __q2, int __q3)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_epi16 (short __q0, short __q1, short __q2, short __q3,
short __q4, short __q5, short __q6, short __q7)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_epi8 (char __q00, char __q01, char __q02, char __q03,
char __q04, char __q05, char __q06, char __q07,
char __q08, char __q09, char __q10, char __q11,
char __q12, char __q13, char __q14, char __q15)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_si128 (__m128i const *__P)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadu_si128 (__m128i const *__P)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadl_epi64 (__m128i const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_si128 (__m128i *__P, __m128i __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storeu_si128 (__m128i *__P, __m128i __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storel_epi64 (__m128i *__P, __m128i __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movepi64_pi64 (__m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movpi64_epi64 (__m64 __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_move_epi64 (__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_undefined_si128 (void)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setzero_si128 (void)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi32_pd (__m128i __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi32_ps (__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpd_epi32 (__m128d __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpd_pi32 (__m128d __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpd_ps (__m128d __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttpd_epi32 (__m128d __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttpd_pi32 (__m128d __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpi32_pd (__m64 __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtps_epi32 (__m128 __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttps_epi32 (__m128 __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtps_pd (__m128 __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_si32 (__m128d __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_si64 (__m128d __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_si64x (__m128d __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_si32 (__m128d __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_si64 (__m128d __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_si64x (__m128d __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_ss (__m128 __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi32_sd (__m128d __A, int __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_sd (__m128d __A, long long __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64x_sd (__m128d __A, long long __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_sd (__m128d __A, __m128 __B)
;
#define _mm_shuffle_pd(A,B,N) ((__m128d)__builtin_ia32_shufpd ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(N)))
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadh_pd (__m128d __A, double const *__B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadl_pd (__m128d __A, double const *__B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movemask_pd (__m128d __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packs_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packs_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packus_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_epi64 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_epi64 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_epi64 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_epu8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_epu16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_epi64 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_epu8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_epu16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_madd_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mulhi_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mullo_epi16 (__m128i __A, __m128i __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_su32 (__m64 __A, __m64 __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_epu32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_epi16 (__m128i __A, int __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_epi32 (__m128i __A, int __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_epi64 (__m128i __A, int __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srai_epi16 (__m128i __A, int __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srai_epi32 (__m128i __A, int __B)
;
#define _mm_srli_si128(A,N) ((__m128i)__builtin_ia32_psrldqi128 ((__m128i)(A), (int)(N) * 8))
#define _mm_slli_si128(A,N) ((__m128i)__builtin_ia32_pslldqi128 ((__m128i)(A), (int)(N) * 8))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_epi16 (__m128i __A, int __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_epi32 (__m128i __A, int __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_epi64 (__m128i __A, int __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_epi64 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sra_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sra_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_epi64 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_and_si128 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_andnot_si128 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_or_si128 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_xor_si128 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_epi32 (__m128i __A, __m128i __B)
;
#define _mm_extract_epi16(A,N) ((int) (unsigned short) __builtin_ia32_vec_ext_v8hi ((__v8hi)(__m128i)(A), (int)(N)))
#define _mm_insert_epi16(A,D,N) ((__m128i) __builtin_ia32_vec_set_v8hi ((__v8hi)(__m128i)(A), (int)(D), (int)(N)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_epu8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_epu8 (__m128i __A, __m128i __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movemask_epi8 (__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mulhi_epu16 (__m128i __A, __m128i __B)
;
#define _mm_shufflehi_epi16(A,N) ((__m128i)__builtin_ia32_pshufhw ((__v8hi)(__m128i)(A), (int)(N)))
#define _mm_shufflelo_epi16(A,N) ((__m128i)__builtin_ia32_pshuflw ((__v8hi)(__m128i)(A), (int)(N)))
#define _mm_shuffle_epi32(A,N) ((__m128i)__builtin_ia32_pshufd ((__v4si)(__m128i)(A), (int)(N)))
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskmoveu_si128 (__m128i __A, __m128i __B, char *__C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_avg_epu8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_avg_epu16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sad_epu8 (__m128i __A, __m128i __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_si32 (int *__A, int __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_si64 (long long int *__A, long long int __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_si128 (__m128i *__A, __m128i __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_pd (double *__A, __m128d __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_clflush (void const *__A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_lfence (void)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mfence (void)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi32_si128 (int __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_si128 (long long __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64x_si128 (long long __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castpd_ps(__m128d __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castpd_si128(__m128d __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castps_pd(__m128 __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castps_si128(__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castsi128_ps(__m128i __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castsi128_pd(__m128i __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_pause (void)
;
#define _PMMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("sse3")
#define __DISABLE_SSE3__
#define _MM_DENORMALS_ZERO_MASK 0x0040
#define _MM_DENORMALS_ZERO_ON 0x0040
#define _MM_DENORMALS_ZERO_OFF 0x0000
#define _MM_SET_DENORMALS_ZERO_MODE(mode) _mm_setcsr ((_mm_getcsr () & ~_MM_DENORMALS_ZERO_MASK) | (mode))
#define _MM_GET_DENORMALS_ZERO_MODE() (_mm_getcsr() & _MM_DENORMALS_ZERO_MASK)
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_addsub_ps (__m128 __X, __m128 __Y)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadd_ps (__m128 __X, __m128 __Y)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsub_ps (__m128 __X, __m128 __Y)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movehdup_ps (__m128 __X)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_moveldup_ps (__m128 __X)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_addsub_pd (__m128d __X, __m128d __Y)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadd_pd (__m128d __X, __m128d __Y)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsub_pd (__m128d __X, __m128d __Y)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loaddup_pd (double const *__P)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movedup_pd (__m128d __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_lddqu_si128 (__m128i const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_monitor (void const * __P, unsigned int __E, unsigned int __H)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mwait (unsigned int __E, unsigned int __H)
;
#undef __DISABLE_SSE3__
#pragma GCC pop_options
#define _TMMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("ssse3")
#define __DISABLE_SSSE3__
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadd_epi16 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadd_epi32 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadds_epi16 (__m128i __X, __m128i __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadd_pi16 (__m64 __X, __m64 __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadd_pi32 (__m64 __X, __m64 __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadds_pi16 (__m64 __X, __m64 __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsub_epi16 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsub_epi32 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsubs_epi16 (__m128i __X, __m128i __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsub_pi16 (__m64 __X, __m64 __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsub_pi32 (__m64 __X, __m64 __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsubs_pi16 (__m64 __X, __m64 __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maddubs_epi16 (__m128i __X, __m128i __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maddubs_pi16 (__m64 __X, __m64 __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mulhrs_epi16 (__m128i __X, __m128i __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mulhrs_pi16 (__m64 __X, __m64 __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shuffle_epi8 (__m128i __X, __m128i __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shuffle_pi8 (__m64 __X, __m64 __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sign_epi8 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sign_epi16 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sign_epi32 (__m128i __X, __m128i __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sign_pi8 (__m64 __X, __m64 __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sign_pi16 (__m64 __X, __m64 __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sign_pi32 (__m64 __X, __m64 __Y)
;
#define _mm_alignr_epi8(X,Y,N) ((__m128i) __builtin_ia32_palignr128 ((__v2di)(__m128i)(X), (__v2di)(__m128i)(Y), (int)(N) * 8))
#define _mm_alignr_pi8(X,Y,N) ((__m64) __builtin_ia32_palignr ((__v1di)(__m64)(X), (__v1di)(__m64)(Y), (int)(N) * 8))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_abs_epi8 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_abs_epi16 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_abs_epi32 (__m128i __X)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_abs_pi8 (__m64 __X)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_abs_pi16 (__m64 __X)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_abs_pi32 (__m64 __X)
;
#undef __DISABLE_SSSE3__
#pragma GCC pop_options
#define _AMMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("sse4a")
#define __DISABLE_SSE4A__
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_sd (double * __P, __m128d __Y)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_ss (float * __P, __m128 __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_extract_si64 (__m128i __X, __m128i __Y)
;
#define _mm_extracti_si64(X,I,L) ((__m128i) __builtin_ia32_extrqi ((__v2di)(__m128i)(X), (unsigned int)(I), (unsigned int)(L)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_insert_si64 (__m128i __X,__m128i __Y)
;
#define _mm_inserti_si64(X,Y,I,L) ((__m128i) __builtin_ia32_insertqi ((__v2di)(__m128i)(X), (__v2di)(__m128i)(Y), (unsigned int)(I), (unsigned int)(L)))
#undef __DISABLE_SSE4A__
#pragma GCC pop_options
#define _SMMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("sse4.1")
#define __DISABLE_SSE4_1__
#define _MM_FROUND_TO_NEAREST_INT 0x00
#define _MM_FROUND_TO_NEG_INF 0x01
#define _MM_FROUND_TO_POS_INF 0x02
#define _MM_FROUND_TO_ZERO 0x03
#define _MM_FROUND_CUR_DIRECTION 0x04
#define _MM_FROUND_RAISE_EXC 0x00
#define _MM_FROUND_NO_EXC 0x08
#define _MM_FROUND_NINT (_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_RAISE_EXC)
#define _MM_FROUND_FLOOR (_MM_FROUND_TO_NEG_INF | _MM_FROUND_RAISE_EXC)
#define _MM_FROUND_CEIL (_MM_FROUND_TO_POS_INF | _MM_FROUND_RAISE_EXC)
#define _MM_FROUND_TRUNC (_MM_FROUND_TO_ZERO | _MM_FROUND_RAISE_EXC)
#define _MM_FROUND_RINT (_MM_FROUND_CUR_DIRECTION | _MM_FROUND_RAISE_EXC)
#define _MM_FROUND_NEARBYINT (_MM_FROUND_CUR_DIRECTION | _MM_FROUND_NO_EXC)
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testz_si128 (__m128i __M, __m128i __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testc_si128 (__m128i __M, __m128i __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testnzc_si128 (__m128i __M, __m128i __V)
;
#define _mm_test_all_zeros(M,V) _mm_testz_si128 ((M), (V))
#define _mm_test_all_ones(V) _mm_testc_si128 ((V), _mm_cmpeq_epi32 ((V), (V)))
#define _mm_test_mix_ones_zeros(M,V) _mm_testnzc_si128 ((M), (V))
#define _mm_round_pd(V,M) ((__m128d) __builtin_ia32_roundpd ((__v2df)(__m128d)(V), (int)(M)))
#define _mm_round_sd(D,V,M) ((__m128d) __builtin_ia32_roundsd ((__v2df)(__m128d)(D), (__v2df)(__m128d)(V), (int)(M)))
#define _mm_round_ps(V,M) ((__m128) __builtin_ia32_roundps ((__v4sf)(__m128)(V), (int)(M)))
#define _mm_round_ss(D,V,M) ((__m128) __builtin_ia32_roundss ((__v4sf)(__m128)(D), (__v4sf)(__m128)(V), (int)(M)))
#define _mm_ceil_pd(V) _mm_round_pd ((V), _MM_FROUND_CEIL)
#define _mm_ceil_sd(D,V) _mm_round_sd ((D), (V), _MM_FROUND_CEIL)
#define _mm_floor_pd(V) _mm_round_pd((V), _MM_FROUND_FLOOR)
#define _mm_floor_sd(D,V) _mm_round_sd ((D), (V), _MM_FROUND_FLOOR)
#define _mm_ceil_ps(V) _mm_round_ps ((V), _MM_FROUND_CEIL)
#define _mm_ceil_ss(D,V) _mm_round_ss ((D), (V), _MM_FROUND_CEIL)
#define _mm_floor_ps(V) _mm_round_ps ((V), _MM_FROUND_FLOOR)
#define _mm_floor_ss(D,V) _mm_round_ss ((D), (V), _MM_FROUND_FLOOR)
#define _mm_blend_epi16(X,Y,M) ((__m128i) __builtin_ia32_pblendw128 ((__v8hi)(__m128i)(X), (__v8hi)(__m128i)(Y), (int)(M)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_blendv_epi8 (__m128i __X, __m128i __Y, __m128i __M)
;
#define _mm_blend_ps(X,Y,M) ((__m128) __builtin_ia32_blendps ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(M)))
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_blendv_ps (__m128 __X, __m128 __Y, __m128 __M)
;
#define _mm_blend_pd(X,Y,M) ((__m128d) __builtin_ia32_blendpd ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(M)))
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_blendv_pd (__m128d __X, __m128d __Y, __m128d __M)
;
#define _mm_dp_ps(X,Y,M) ((__m128) __builtin_ia32_dpps ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(M)))
#define _mm_dp_pd(X,Y,M) ((__m128d) __builtin_ia32_dppd ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(M)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_epi64 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_epi8 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_epi8 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_epu16 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_epu16 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_epi32 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_epi32 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_epu32 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_epu32 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mullo_epi32 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_epi32 (__m128i __X, __m128i __Y)
;
#define _mm_insert_ps(D,S,N) ((__m128) __builtin_ia32_insertps128 ((__v4sf)(__m128)(D), (__v4sf)(__m128)(S), (int)(N)))
#define _MM_MK_INSERTPS_NDX(S,D,M) (((S) << 6) | ((D) << 4) | (M))
#define _mm_extract_ps(X,N) (__extension__ ({ union { int i; float f; } __tmp; __tmp.f = __builtin_ia32_vec_ext_v4sf ((__v4sf)(__m128)(X), (int)(N)); __tmp.i; }))
#define _MM_EXTRACT_FLOAT(D,S,N) { (D) = __builtin_ia32_vec_ext_v4sf ((__v4sf)(S), (N)); }
#define _MM_PICK_OUT_PS(X,N) _mm_insert_ps (_mm_setzero_ps (), (X), _MM_MK_INSERTPS_NDX ((N), 0, 0x0e))
#define _mm_insert_epi8(D,S,N) ((__m128i) __builtin_ia32_vec_set_v16qi ((__v16qi)(__m128i)(D), (int)(S), (int)(N)))
#define _mm_insert_epi32(D,S,N) ((__m128i) __builtin_ia32_vec_set_v4si ((__v4si)(__m128i)(D), (int)(S), (int)(N)))
#define _mm_insert_epi64(D,S,N) ((__m128i) __builtin_ia32_vec_set_v2di ((__v2di)(__m128i)(D), (long long)(S), (int)(N)))
#define _mm_extract_epi8(X,N) ((int) (unsigned char) __builtin_ia32_vec_ext_v16qi ((__v16qi)(__m128i)(X), (int)(N)))
#define _mm_extract_epi32(X,N) ((int) __builtin_ia32_vec_ext_v4si ((__v4si)(__m128i)(X), (int)(N)))
#define _mm_extract_epi64(X,N) ((long long) __builtin_ia32_vec_ext_v2di ((__v2di)(__m128i)(X), (int)(N)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_minpos_epu16 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi8_epi32 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi16_epi32 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi8_epi64 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi32_epi64 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi16_epi64 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi8_epi16 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepu8_epi32 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepu16_epi32 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepu8_epi64 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepu32_epi64 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepu16_epi64 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepu8_epi16 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packus_epi32 (__m128i __X, __m128i __Y)
;
#define _mm_mpsadbw_epu8(X,Y,M) ((__m128i) __builtin_ia32_mpsadbw128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_load_si128 (__m128i *__X)
;
#pragma GCC push_options
#pragma GCC target("sse4.2")
#define __DISABLE_SSE4_2__
#define _SIDD_UBYTE_OPS 0x00
#define _SIDD_UWORD_OPS 0x01
#define _SIDD_SBYTE_OPS 0x02
#define _SIDD_SWORD_OPS 0x03
#define _SIDD_CMP_EQUAL_ANY 0x00
#define _SIDD_CMP_RANGES 0x04
#define _SIDD_CMP_EQUAL_EACH 0x08
#define _SIDD_CMP_EQUAL_ORDERED 0x0c
#define _SIDD_POSITIVE_POLARITY 0x00
#define _SIDD_NEGATIVE_POLARITY 0x10
#define _SIDD_MASKED_POSITIVE_POLARITY 0x20
#define _SIDD_MASKED_NEGATIVE_POLARITY 0x30
#define _SIDD_LEAST_SIGNIFICANT 0x00
#define _SIDD_MOST_SIGNIFICANT 0x40
#define _SIDD_BIT_MASK 0x00
#define _SIDD_UNIT_MASK 0x40
#define _mm_cmpistrm(X,Y,M) ((__m128i) __builtin_ia32_pcmpistrm128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
#define _mm_cmpistri(X,Y,M) ((int) __builtin_ia32_pcmpistri128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
#define _mm_cmpestrm(X,LX,Y,LY,M) ((__m128i) __builtin_ia32_pcmpestrm128 ((__v16qi)(__m128i)(X), (int)(LX), (__v16qi)(__m128i)(Y), (int)(LY), (int)(M)))
#define _mm_cmpestri(X,LX,Y,LY,M) ((int) __builtin_ia32_pcmpestri128 ((__v16qi)(__m128i)(X), (int)(LX), (__v16qi)(__m128i)(Y), (int)(LY), (int)(M)))
#define _mm_cmpistra(X,Y,M) ((int) __builtin_ia32_pcmpistria128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
#define _mm_cmpistrc(X,Y,M) ((int) __builtin_ia32_pcmpistric128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
#define _mm_cmpistro(X,Y,M) ((int) __builtin_ia32_pcmpistrio128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
#define _mm_cmpistrs(X,Y,M) ((int) __builtin_ia32_pcmpistris128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
#define _mm_cmpistrz(X,Y,M) ((int) __builtin_ia32_pcmpistriz128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
#define _mm_cmpestra(X,LX,Y,LY,M) ((int) __builtin_ia32_pcmpestria128 ((__v16qi)(__m128i)(X), (int)(LX), (__v16qi)(__m128i)(Y), (int)(LY), (int)(M)))
#define _mm_cmpestrc(X,LX,Y,LY,M) ((int) __builtin_ia32_pcmpestric128 ((__v16qi)(__m128i)(X), (int)(LX), (__v16qi)(__m128i)(Y), (int)(LY), (int)(M)))
#define _mm_cmpestro(X,LX,Y,LY,M) ((int) __builtin_ia32_pcmpestrio128 ((__v16qi)(__m128i)(X), (int)(LX), (__v16qi)(__m128i)(Y), (int)(LY), (int)(M)))
#define _mm_cmpestrs(X,LX,Y,LY,M) ((int) __builtin_ia32_pcmpestris128 ((__v16qi)(__m128i)(X), (int)(LX), (__v16qi)(__m128i)(Y), (int)(LY), (int)(M)))
#define _mm_cmpestrz(X,LX,Y,LY,M) ((int) __builtin_ia32_pcmpestriz128 ((__v16qi)(__m128i)(X), (int)(LX), (__v16qi)(__m128i)(Y), (int)(LY), (int)(M)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_epi64 (__m128i __X, __m128i __Y)
;
#undef __DISABLE_SSE4_2__
#pragma GCC pop_options
#undef __DISABLE_SSE4_1__
#pragma GCC pop_options
#define _POPCNTINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("popcnt")
#define __DISABLE_POPCNT__
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_popcnt_u32 (unsigned int __X)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_popcnt_u64 (unsigned long long __X)
;
#undef __DISABLE_POPCNT__
#pragma GCC pop_options
#pragma GCC push_options
#pragma GCC target("sse4.1")
#define __DISABLE_SSE4_1__
#pragma GCC push_options
#pragma GCC target("sse4.2")
#define __DISABLE_SSE4_2__
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_crc32_u8 (unsigned int __C, unsigned char __V)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_crc32_u16 (unsigned int __C, unsigned short __V)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_crc32_u32 (unsigned int __C, unsigned int __V)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_crc32_u64 (unsigned long long __C, unsigned long long __V)
;
#undef __DISABLE_SSE4_2__
#pragma GCC pop_options
#undef __DISABLE_SSE4_1__
#pragma GCC pop_options
#define _WMMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("aes")
#define __DISABLE_AES__
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_aesdec_si128 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_aesdeclast_si128 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_aesenc_si128 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_aesenclast_si128 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_aesimc_si128 (__m128i __X)
;
#define _mm_aeskeygenassist_si128(X,C) ((__m128i) __builtin_ia32_aeskeygenassist128 ((__v2di)(__m128i)(X), (int)(C)))
#undef __DISABLE_AES__
#pragma GCC pop_options
#pragma GCC push_options
#pragma GCC target("pclmul")
#define __DISABLE_PCLMUL__
#define _mm_clmulepi64_si128(X,Y,I) ((__m128i) __builtin_ia32_pclmulqdq128 ((__v2di)(__m128i)(X), (__v2di)(__m128i)(Y), (int)(I)))
#undef __DISABLE_PCLMUL__
#pragma GCC pop_options
#define _IMMINTRIN_H_INCLUDED
#define _AVXINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("avx")
#define __DISABLE_AVX__
typedef double __v4df __attribute__ ((__vector_size__ (32)));
typedef float __v8sf __attribute__ ((__vector_size__ (32)));
typedef long long __v4di __attribute__ ((__vector_size__ (32)));
typedef int __v8si __attribute__ ((__vector_size__ (32)));
typedef short __v16hi __attribute__ ((__vector_size__ (32)));
typedef char __v32qi __attribute__ ((__vector_size__ (32)));
typedef float __m256 __attribute__ ((__vector_size__ (32),
__may_alias__));
typedef long long __m256i __attribute__ ((__vector_size__ (32),
__may_alias__));
typedef double __m256d __attribute__ ((__vector_size__ (32),
__may_alias__));
#define _CMP_EQ_OQ 0x00
#define _CMP_LT_OS 0x01
#define _CMP_LE_OS 0x02
#define _CMP_UNORD_Q 0x03
#define _CMP_NEQ_UQ 0x04
#define _CMP_NLT_US 0x05
#define _CMP_NLE_US 0x06
#define _CMP_ORD_Q 0x07
#define _CMP_EQ_UQ 0x08
#define _CMP_NGE_US 0x09
#define _CMP_NGT_US 0x0a
#define _CMP_FALSE_OQ 0x0b
#define _CMP_NEQ_OQ 0x0c
#define _CMP_GE_OS 0x0d
#define _CMP_GT_OS 0x0e
#define _CMP_TRUE_UQ 0x0f
#define _CMP_EQ_OS 0x10
#define _CMP_LT_OQ 0x11
#define _CMP_LE_OQ 0x12
#define _CMP_UNORD_S 0x13
#define _CMP_NEQ_US 0x14
#define _CMP_NLT_UQ 0x15
#define _CMP_NLE_UQ 0x16
#define _CMP_ORD_S 0x17
#define _CMP_EQ_US 0x18
#define _CMP_NGE_UQ 0x19
#define _CMP_NGT_UQ 0x1a
#define _CMP_FALSE_OS 0x1b
#define _CMP_NEQ_OS 0x1c
#define _CMP_GE_OQ 0x1d
#define _CMP_GT_OQ 0x1e
#define _CMP_TRUE_US 0x1f
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_add_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_add_ps (__m256 __A, __m256 __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_addsub_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_addsub_ps (__m256 __A, __m256 __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_and_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_and_ps (__m256 __A, __m256 __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_andnot_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_andnot_ps (__m256 __A, __m256 __B)
;
#define _mm256_blend_pd(X,Y,M) ((__m256d) __builtin_ia32_blendpd256 ((__v4df)(__m256d)(X), (__v4df)(__m256d)(Y), (int)(M)))
#define _mm256_blend_ps(X,Y,M) ((__m256) __builtin_ia32_blendps256 ((__v8sf)(__m256)(X), (__v8sf)(__m256)(Y), (int)(M)))
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_blendv_pd (__m256d __X, __m256d __Y, __m256d __M)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_blendv_ps (__m256 __X, __m256 __Y, __m256 __M)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_div_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_div_ps (__m256 __A, __m256 __B)
;
#define _mm256_dp_ps(X,Y,M) ((__m256) __builtin_ia32_dpps256 ((__v8sf)(__m256)(X), (__v8sf)(__m256)(Y), (int)(M)))
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hadd_pd (__m256d __X, __m256d __Y)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hadd_ps (__m256 __X, __m256 __Y)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hsub_pd (__m256d __X, __m256d __Y)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hsub_ps (__m256 __X, __m256 __Y)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_ps (__m256 __A, __m256 __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_ps (__m256 __A, __m256 __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mul_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mul_ps (__m256 __A, __m256 __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_or_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_or_ps (__m256 __A, __m256 __B)
;
#define _mm256_shuffle_pd(A,B,N) ((__m256d)__builtin_ia32_shufpd256 ((__v4df)(__m256d)(A), (__v4df)(__m256d)(B), (int)(N)))
#define _mm256_shuffle_ps(A,B,N) ((__m256) __builtin_ia32_shufps256 ((__v8sf)(__m256)(A), (__v8sf)(__m256)(B), (int)(N)))
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sub_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sub_ps (__m256 __A, __m256 __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_xor_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_xor_ps (__m256 __A, __m256 __B)
;
#define _mm_cmp_pd(X,Y,P) ((__m128d) __builtin_ia32_cmppd ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P)))
#define _mm_cmp_ps(X,Y,P) ((__m128) __builtin_ia32_cmpps ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P)))
#define _mm256_cmp_pd(X,Y,P) ((__m256d) __builtin_ia32_cmppd256 ((__v4df)(__m256d)(X), (__v4df)(__m256d)(Y), (int)(P)))
#define _mm256_cmp_ps(X,Y,P) ((__m256) __builtin_ia32_cmpps256 ((__v8sf)(__m256)(X), (__v8sf)(__m256)(Y), (int)(P)))
#define _mm_cmp_sd(X,Y,P) ((__m128d) __builtin_ia32_cmpsd ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P)))
#define _mm_cmp_ss(X,Y,P) ((__m128) __builtin_ia32_cmpss ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P)))
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi32_pd (__m128i __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi32_ps (__m256i __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtpd_ps (__m256d __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtps_epi32 (__m256 __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtps_pd (__m128 __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvttpd_epi32 (__m256d __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtpd_epi32 (__m256d __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvttps_epi32 (__m256 __A)
;
#define _mm256_extractf128_pd(X,N) ((__m128d) __builtin_ia32_vextractf128_pd256 ((__v4df)(__m256d)(X), (int)(N)))
#define _mm256_extractf128_ps(X,N) ((__m128) __builtin_ia32_vextractf128_ps256 ((__v8sf)(__m256)(X), (int)(N)))
#define _mm256_extractf128_si256(X,N) ((__m128i) __builtin_ia32_vextractf128_si256 ((__v8si)(__m256i)(X), (int)(N)))
#define _mm256_extract_epi32(X,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 2); _mm_extract_epi32 (__Y, (N) % 4); }))
#define _mm256_extract_epi16(X,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 3); _mm_extract_epi16 (__Y, (N) % 8); }))
#define _mm256_extract_epi8(X,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 4); _mm_extract_epi8 (__Y, (N) % 16); }))
#define _mm256_extract_epi64(X,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 1); _mm_extract_epi64 (__Y, (N) % 2); }))
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_zeroall (void)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_zeroupper (void)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_permutevar_pd (__m128d __A, __m128i __C)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_permutevar_pd (__m256d __A, __m256i __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_permutevar_ps (__m128 __A, __m128i __C)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_permutevar_ps (__m256 __A, __m256i __C)
;
#define _mm_permute_pd(X,C) ((__m128d) __builtin_ia32_vpermilpd ((__v2df)(__m128d)(X), (int)(C)))
#define _mm256_permute_pd(X,C) ((__m256d) __builtin_ia32_vpermilpd256 ((__v4df)(__m256d)(X), (int)(C)))
#define _mm_permute_ps(X,C) ((__m128) __builtin_ia32_vpermilps ((__v4sf)(__m128)(X), (int)(C)))
#define _mm256_permute_ps(X,C) ((__m256) __builtin_ia32_vpermilps256 ((__v8sf)(__m256)(X), (int)(C)))
#define _mm256_permute2f128_pd(X,Y,C) ((__m256d) __builtin_ia32_vperm2f128_pd256 ((__v4df)(__m256d)(X), (__v4df)(__m256d)(Y), (int)(C)))
#define _mm256_permute2f128_ps(X,Y,C) ((__m256) __builtin_ia32_vperm2f128_ps256 ((__v8sf)(__m256)(X), (__v8sf)(__m256)(Y), (int)(C)))
#define _mm256_permute2f128_si256(X,Y,C) ((__m256i) __builtin_ia32_vperm2f128_si256 ((__v8si)(__m256i)(X), (__v8si)(__m256i)(Y), (int)(C)))
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_broadcast_ss (float const *__X)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcast_sd (double const *__X)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcast_ss (float const *__X)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcast_pd (__m128d const *__X)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcast_ps (__m128 const *__X)
;
#define _mm256_insertf128_pd(X,Y,O) ((__m256d) __builtin_ia32_vinsertf128_pd256 ((__v4df)(__m256d)(X), (__v2df)(__m128d)(Y), (int)(O)))
#define _mm256_insertf128_ps(X,Y,O) ((__m256) __builtin_ia32_vinsertf128_ps256 ((__v8sf)(__m256)(X), (__v4sf)(__m128)(Y), (int)(O)))
#define _mm256_insertf128_si256(X,Y,O) ((__m256i) __builtin_ia32_vinsertf128_si256 ((__v8si)(__m256i)(X), (__v4si)(__m128i)(Y), (int)(O)))
#define _mm256_insert_epi32(X,D,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 2); __Y = _mm_insert_epi32 (__Y, (D), (N) % 4); _mm256_insertf128_si256 ((X), __Y, (N) >> 2); }))
#define _mm256_insert_epi16(X,D,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 3); __Y = _mm_insert_epi16 (__Y, (D), (N) % 8); _mm256_insertf128_si256 ((X), __Y, (N) >> 3); }))
#define _mm256_insert_epi8(X,D,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 4); __Y = _mm_insert_epi8 (__Y, (D), (N) % 16); _mm256_insertf128_si256 ((X), __Y, (N) >> 4); }))
#define _mm256_insert_epi64(X,D,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 1); __Y = _mm_insert_epi64 (__Y, (D), (N) % 2); _mm256_insertf128_si256 ((X), __Y, (N) >> 1); }))
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_load_pd (double const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_store_pd (double *__P, __m256d __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_load_ps (float const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_store_ps (float *__P, __m256 __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_loadu_pd (double const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_storeu_pd (double *__P, __m256d __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_loadu_ps (float const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_storeu_ps (float *__P, __m256 __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_load_si256 (__m256i const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_store_si256 (__m256i *__P, __m256i __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_loadu_si256 (__m256i const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_storeu_si256 (__m256i *__P, __m256i __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskload_pd (double const *__P, __m128i __M)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskstore_pd (double *__P, __m128i __M, __m128d __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskload_pd (double const *__P, __m256i __M)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskstore_pd (double *__P, __m256i __M, __m256d __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskload_ps (float const *__P, __m128i __M)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskstore_ps (float *__P, __m128i __M, __m128 __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskload_ps (float const *__P, __m256i __M)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskstore_ps (float *__P, __m256i __M, __m256 __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_movehdup_ps (__m256 __X)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_moveldup_ps (__m256 __X)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_movedup_pd (__m256d __X)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_lddqu_si256 (__m256i const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_stream_si256 (__m256i *__A, __m256i __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_stream_pd (double *__A, __m256d __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_stream_ps (float *__P, __m256 __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_rcp_ps (__m256 __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_rsqrt_ps (__m256 __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sqrt_pd (__m256d __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sqrt_ps (__m256 __A)
;
#define _mm256_round_pd(V,M) ((__m256d) __builtin_ia32_roundpd256 ((__v4df)(__m256d)(V), (int)(M)))
#define _mm256_round_ps(V,M) ((__m256) __builtin_ia32_roundps256 ((__v8sf)(__m256)(V), (int)(M)))
#define _mm256_ceil_pd(V) _mm256_round_pd ((V), _MM_FROUND_CEIL)
#define _mm256_floor_pd(V) _mm256_round_pd ((V), _MM_FROUND_FLOOR)
#define _mm256_ceil_ps(V) _mm256_round_ps ((V), _MM_FROUND_CEIL)
#define _mm256_floor_ps(V) _mm256_round_ps ((V), _MM_FROUND_FLOOR)
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpackhi_pd (__m256d __A, __m256d __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpacklo_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpackhi_ps (__m256 __A, __m256 __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpacklo_ps (__m256 __A, __m256 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testz_pd (__m128d __M, __m128d __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testc_pd (__m128d __M, __m128d __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testnzc_pd (__m128d __M, __m128d __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testz_ps (__m128 __M, __m128 __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testc_ps (__m128 __M, __m128 __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testnzc_ps (__m128 __M, __m128 __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testz_pd (__m256d __M, __m256d __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testc_pd (__m256d __M, __m256d __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testnzc_pd (__m256d __M, __m256d __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testz_ps (__m256 __M, __m256 __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testc_ps (__m256 __M, __m256 __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testnzc_ps (__m256 __M, __m256 __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testz_si256 (__m256i __M, __m256i __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testc_si256 (__m256i __M, __m256i __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testnzc_si256 (__m256i __M, __m256i __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_movemask_pd (__m256d __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_movemask_ps (__m256 __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_undefined_pd (void)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_undefined_ps (void)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_undefined_si256 (void)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setzero_pd (void)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setzero_ps (void)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setzero_si256 (void)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set_pd (double __A, double __B, double __C, double __D)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set_ps (float __A, float __B, float __C, float __D,
float __E, float __F, float __G, float __H)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set_epi32 (int __A, int __B, int __C, int __D,
int __E, int __F, int __G, int __H)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set_epi16 (short __q15, short __q14, short __q13, short __q12,
short __q11, short __q10, short __q09, short __q08,
short __q07, short __q06, short __q05, short __q04,
short __q03, short __q02, short __q01, short __q00)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set_epi8 (char __q31, char __q30, char __q29, char __q28,
char __q27, char __q26, char __q25, char __q24,
char __q23, char __q22, char __q21, char __q20,
char __q19, char __q18, char __q17, char __q16,
char __q15, char __q14, char __q13, char __q12,
char __q11, char __q10, char __q09, char __q08,
char __q07, char __q06, char __q05, char __q04,
char __q03, char __q02, char __q01, char __q00)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set_epi64x (long long __A, long long __B, long long __C,
long long __D)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set1_pd (double __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set1_ps (float __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set1_epi32 (int __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set1_epi16 (short __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set1_epi8 (char __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set1_epi64x (long long __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setr_pd (double __A, double __B, double __C, double __D)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setr_ps (float __A, float __B, float __C, float __D,
float __E, float __F, float __G, float __H)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setr_epi32 (int __A, int __B, int __C, int __D,
int __E, int __F, int __G, int __H)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setr_epi16 (short __q15, short __q14, short __q13, short __q12,
short __q11, short __q10, short __q09, short __q08,
short __q07, short __q06, short __q05, short __q04,
short __q03, short __q02, short __q01, short __q00)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setr_epi8 (char __q31, char __q30, char __q29, char __q28,
char __q27, char __q26, char __q25, char __q24,
char __q23, char __q22, char __q21, char __q20,
char __q19, char __q18, char __q17, char __q16,
char __q15, char __q14, char __q13, char __q12,
char __q11, char __q10, char __q09, char __q08,
char __q07, char __q06, char __q05, char __q04,
char __q03, char __q02, char __q01, char __q00)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setr_epi64x (long long __A, long long __B, long long __C,
long long __D)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castpd_ps (__m256d __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castpd_si256 (__m256d __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castps_pd (__m256 __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castps_si256(__m256 __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castsi256_ps (__m256i __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castsi256_pd (__m256i __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castpd256_pd128 (__m256d __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castps256_ps128 (__m256 __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castsi256_si128 (__m256i __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castpd128_pd256 (__m128d __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castps128_ps256 (__m128 __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castsi128_si256 (__m128i __A)
;
#undef __DISABLE_AVX__
#pragma GCC pop_options
#define _AVX2INTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("avx2")
#define __DISABLE_AVX2__
#define _mm256_mpsadbw_epu8(X,Y,M) ((__m256i) __builtin_ia32_mpsadbw256 ((__v32qi)(__m256i)(X), (__v32qi)(__m256i)(Y), (int)(M)))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_abs_epi8 (__m256i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_abs_epi16 (__m256i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_abs_epi32 (__m256i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_packs_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_packs_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_packus_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_packus_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_add_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_add_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_add_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_add_epi64 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_adds_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_adds_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_adds_epu8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_adds_epu16 (__m256i __A, __m256i __B)
;
#define _mm256_alignr_epi8(A,B,N) ((__m256i) __builtin_ia32_palignr256 ((__v4di)(__m256i)(A), (__v4di)(__m256i)(B), (int)(N) * 8))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_and_si256 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_andnot_si256 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_avg_epu8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_avg_epu16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_blendv_epi8 (__m256i __X, __m256i __Y, __m256i __M)
;
#define _mm256_blend_epi16(X,Y,M) ((__m256i) __builtin_ia32_pblendw256 ((__v16hi)(__m256i)(X), (__v16hi)(__m256i)(Y), (int)(M)))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpeq_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpeq_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpeq_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpeq_epi64 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpgt_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpgt_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpgt_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpgt_epi64 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hadd_epi16 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hadd_epi32 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hadds_epi16 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hsub_epi16 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hsub_epi32 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hsubs_epi16 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maddubs_epi16 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_madd_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_epu8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_epu16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_epu32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_epu8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_epu16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_epu32 (__m256i __A, __m256i __B)
;
extern int
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_movemask_epi8 (__m256i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi8_epi16 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi8_epi32 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi8_epi64 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi16_epi32 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi16_epi64 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi32_epi64 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepu8_epi16 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepu8_epi32 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepu8_epi64 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepu16_epi32 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepu16_epi64 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepu32_epi64 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mul_epi32 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mulhrs_epi16 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mulhi_epu16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mulhi_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mullo_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mullo_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mul_epu32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_or_si256 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sad_epu8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_shuffle_epi8 (__m256i __X, __m256i __Y)
;
#define _mm256_shuffle_epi32(A,N) ((__m256i)__builtin_ia32_pshufd256 ((__v8si)(__m256i)(A), (int)(N)))
#define _mm256_shufflehi_epi16(A,N) ((__m256i)__builtin_ia32_pshufhw256 ((__v16hi)(__m256i)(A), (int)(N)))
#define _mm256_shufflelo_epi16(A,N) ((__m256i)__builtin_ia32_pshuflw256 ((__v16hi)(__m256i)(A), (int)(N)))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sign_epi8 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sign_epi16 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sign_epi32 (__m256i __X, __m256i __Y)
;
#define _mm256_slli_si256(A,N) ((__m256i)__builtin_ia32_pslldqi256 ((__m256i)(A), (int)(N) * 8))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_slli_epi16 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sll_epi16 (__m256i __A, __m128i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_slli_epi32 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sll_epi32 (__m256i __A, __m128i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_slli_epi64 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sll_epi64 (__m256i __A, __m128i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srai_epi16 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sra_epi16 (__m256i __A, __m128i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srai_epi32 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sra_epi32 (__m256i __A, __m128i __B)
;
#define _mm256_srli_si256(A,N) ((__m256i)__builtin_ia32_psrldqi256 ((__m256i)(A), (int)(N) * 8))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srli_epi16 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srl_epi16 (__m256i __A, __m128i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srli_epi32 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srl_epi32 (__m256i __A, __m128i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srli_epi64 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srl_epi64 (__m256i __A, __m128i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sub_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sub_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sub_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sub_epi64 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_subs_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_subs_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_subs_epu8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_subs_epu16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpackhi_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpackhi_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpackhi_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpackhi_epi64 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpacklo_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpacklo_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpacklo_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpacklo_epi64 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_xor_si256 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_stream_load_si256 (__m256i const *__X)
;
extern __m128
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_broadcastss_ps (__m128 __X)
;
extern __m256
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcastss_ps (__m128 __X)
;
extern __m256d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcastsd_pd (__m128d __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcastsi128_si256 (__m128i __X)
;
#define _mm_blend_epi32(X,Y,M) ((__m128i) __builtin_ia32_pblendd128 ((__v4si)(__m128i)(X), (__v4si)(__m128i)(Y), (int)(M)))
#define _mm256_blend_epi32(X,Y,M) ((__m256i) __builtin_ia32_pblendd256 ((__v8si)(__m256i)(X), (__v8si)(__m256i)(Y), (int)(M)))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcastb_epi8 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcastw_epi16 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcastd_epi32 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcastq_epi64 (__m128i __X)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_broadcastb_epi8 (__m128i __X)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_broadcastw_epi16 (__m128i __X)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_broadcastd_epi32 (__m128i __X)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_broadcastq_epi64 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_permutevar8x32_epi32 (__m256i __X, __m256i __Y)
;
#define _mm256_permute4x64_pd(X,M) ((__m256d) __builtin_ia32_permdf256 ((__v4df)(__m256d)(X), (int)(M)))
extern __m256
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_permutevar8x32_ps (__m256 __X, __m256i __Y)
;
#define _mm256_permute4x64_epi64(X,M) ((__m256i) __builtin_ia32_permdi256 ((__v4di)(__m256i)(X), (int)(M)))
#define _mm256_permute2x128_si256(X,Y,M) ((__m256i) __builtin_ia32_permti256 ((__v4di)(__m256i)(X), (__v4di)(__m256i)(Y), (int)(M)))
#define _mm256_extracti128_si256(X,M) ((__m128i) __builtin_ia32_extract128i256 ((__v4di)(__m256i)(X), (int)(M)))
#define _mm256_inserti128_si256(X,Y,M) ((__m256i) __builtin_ia32_insert128i256 ((__v4di)(__m256i)(X), (__v2di)(__m128i)(Y), (int)(M)))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskload_epi32 (int const *__X, __m256i __M )
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskload_epi64 (long long const *__X, __m256i __M )
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskload_epi32 (int const *__X, __m128i __M )
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskload_epi64 (long long const *__X, __m128i __M )
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskstore_epi32 (int *__X, __m256i __M, __m256i __Y )
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskstore_epi64 (long long *__X, __m256i __M, __m256i __Y )
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskstore_epi32 (int *__X, __m128i __M, __m128i __Y )
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskstore_epi64 (long long *__X, __m128i __M, __m128i __Y )
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sllv_epi32 (__m256i __X, __m256i __Y)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sllv_epi32 (__m128i __X, __m128i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sllv_epi64 (__m256i __X, __m256i __Y)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sllv_epi64 (__m128i __X, __m128i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srav_epi32 (__m256i __X, __m256i __Y)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_srav_epi32 (__m128i __X, __m128i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srlv_epi32 (__m256i __X, __m256i __Y)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_srlv_epi32 (__m128i __X, __m128i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srlv_epi64 (__m256i __X, __m256i __Y)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_srlv_epi64 (__m128i __X, __m128i __Y)
;
#define _mm_i32gather_pd(BASE,INDEX,SCALE) (__m128d) __builtin_ia32_gathersiv2df ((__v2df) _mm_setzero_pd (), (double const *)BASE, (__v4si)(__m128i)INDEX, (__v2df)_mm_set1_pd( (double)(long long int) -1), (int)SCALE)
#define _mm_mask_i32gather_pd(SRC,BASE,INDEX,MASK,SCALE) (__m128d) __builtin_ia32_gathersiv2df ((__v2df)(__m128d)SRC, (double const *)BASE, (__v4si)(__m128i)INDEX, (__v2df)(__m128d)MASK, (int)SCALE)
#define _mm256_i32gather_pd(BASE,INDEX,SCALE) (__m256d) __builtin_ia32_gathersiv4df ((__v4df) _mm256_setzero_pd (), (double const *)BASE, (__v4si)(__m128i)INDEX, (__v4df)_mm256_set1_pd( (double)(long long int) -1), (int)SCALE)
#define _mm256_mask_i32gather_pd(SRC,BASE,INDEX,MASK,SCALE) (__m256d) __builtin_ia32_gathersiv4df ((__v4df)(__m256d)SRC, (double const *)BASE, (__v4si)(__m128i)INDEX, (__v4df)(__m256d)MASK, (int)SCALE)
#define _mm_i64gather_pd(BASE,INDEX,SCALE) (__m128d) __builtin_ia32_gatherdiv2df ((__v2df) _mm_setzero_pd (), (double const *)BASE, (__v2di)(__m128i)INDEX, (__v2df)_mm_set1_pd( (double)(long long int) -1), (int)SCALE)
#define _mm_mask_i64gather_pd(SRC,BASE,INDEX,MASK,SCALE) (__m128d) __builtin_ia32_gatherdiv2df ((__v2df)(__m128d)SRC, (double const *)BASE, (__v2di)(__m128i)INDEX, (__v2df)(__m128d)MASK, (int)SCALE)
#define _mm256_i64gather_pd(BASE,INDEX,SCALE) (__m256d) __builtin_ia32_gatherdiv4df ((__v4df) _mm256_setzero_pd (), (double const *)BASE, (__v4di)(__m256i)INDEX, (__v4df)_mm256_set1_pd( (double)(long long int) -1), (int)SCALE)
#define _mm256_mask_i64gather_pd(SRC,BASE,INDEX,MASK,SCALE) (__m256d) __builtin_ia32_gatherdiv4df ((__v4df)(__m256d)SRC, (double const *)BASE, (__v4di)(__m256i)INDEX, (__v4df)(__m256d)MASK, (int)SCALE)
#define _mm_i32gather_ps(BASE,INDEX,SCALE) (__m128) __builtin_ia32_gathersiv4sf ((__v4sf) _mm_setzero_ps (), (float const *)BASE, (__v4si)(__m128i)INDEX, _mm_set1_ps ((float)(int) -1), (int)SCALE)
#define _mm_mask_i32gather_ps(SRC,BASE,INDEX,MASK,SCALE) (__m128) __builtin_ia32_gathersiv4sf ((__v4sf)(__m128d)SRC, (float const *)BASE, (__v4si)(__m128i)INDEX, (__v4sf)(__m128d)MASK, (int)SCALE)
#define _mm256_i32gather_ps(BASE,INDEX,SCALE) (__m256) __builtin_ia32_gathersiv8sf ((__v8sf) _mm256_setzero_ps (), (float const *)BASE, (__v8si)(__m256i)INDEX, (__v8sf)_mm256_set1_ps ( (float)(int) -1), (int)SCALE)
#define _mm256_mask_i32gather_ps(SRC,BASE,INDEX,MASK,SCALE) (__m256) __builtin_ia32_gathersiv8sf ((__v8sf)(__m256)SRC, (float const *)BASE, (__v8si)(__m256i)INDEX, (__v8sf)(__m256d)MASK, (int)SCALE)
#define _mm_i64gather_ps(BASE,INDEX,SCALE) (__m128) __builtin_ia32_gatherdiv4sf ((__v4sf) _mm_setzero_pd (), (float const *)BASE, (__v2di)(__m128i)INDEX, (__v4sf)_mm_set1_ps ( (float)(int) -1), (int)SCALE)
#define _mm_mask_i64gather_ps(SRC,BASE,INDEX,MASK,SCALE) (__m128) __builtin_ia32_gatherdiv4sf ((__v4sf)(__m128)SRC, (float const *)BASE, (__v2di)(__m128i)INDEX, (__v4sf)(__m128d)MASK, (int)SCALE)
#define _mm256_i64gather_ps(BASE,INDEX,SCALE) (__m128) __builtin_ia32_gatherdiv4sf256 ((__v4sf) _mm_setzero_ps (), (float const *)BASE, (__v4di)(__m256i)INDEX, (__v4sf)_mm_set1_ps( (float)(int) -1), (int)SCALE)
#define _mm256_mask_i64gather_ps(SRC,BASE,INDEX,MASK,SCALE) (__m128) __builtin_ia32_gatherdiv4sf256 ((__v4sf)(__m128)SRC, (float const *)BASE, (__v4di)(__m256i)INDEX, (__v4sf)(__m128)MASK, (int)SCALE)
#define _mm_i32gather_epi64(BASE,INDEX,SCALE) (__m128i) __builtin_ia32_gathersiv2di ((__v2di) _mm_setzero_si128 (), (long long const *)BASE, (__v4si)(__m128i)INDEX, (__v2di)_mm_set1_epi64x (-1), (int)SCALE)
#define _mm_mask_i32gather_epi64(SRC,BASE,INDEX,MASK,SCALE) (__m128i) __builtin_ia32_gathersiv2di ((__v2di)(__m128i)SRC, (long long const *)BASE, (__v4si)(__m128i)INDEX, (__v2di)(__m128i)MASK, (int)SCALE)
#define _mm256_i32gather_epi64(BASE,INDEX,SCALE) (__m256i) __builtin_ia32_gathersiv4di ((__v4di) _mm256_setzero_si256 (), (long long const *)BASE, (__v4si)(__m128i)INDEX, (__v4di)_mm256_set1_epi64x (-1), (int)SCALE)
#define _mm256_mask_i32gather_epi64(SRC,BASE,INDEX,MASK,SCALE) (__m256i) __builtin_ia32_gathersiv4di ((__v4di)(__m256i)SRC, (long long const *)BASE, (__v4si)(__m128i)INDEX, (__v4di)(__m256i)MASK, (int)SCALE)
#define _mm_i64gather_epi64(BASE,INDEX,SCALE) (__m128i) __builtin_ia32_gatherdiv2di ((__v2di) _mm_setzero_si128 (), (long long const *)BASE, (__v2di)(__m128i)INDEX, (__v2di)_mm_set1_epi64x (-1), (int)SCALE)
#define _mm_mask_i64gather_epi64(SRC,BASE,INDEX,MASK,SCALE) (__m128i) __builtin_ia32_gatherdiv2di ((__v2di)(__m128i)SRC, (long long const *)BASE, (__v2di)(__m128i)INDEX, (__v2di)(__m128i)MASK, (int)SCALE)
#define _mm256_i64gather_epi64(BASE,INDEX,SCALE) (__m256i) __builtin_ia32_gatherdiv4di ((__v4di) _mm256_setzero_si256 (), (long long const *)BASE, (__v4di)(__m256i)INDEX, (__v4di)_mm256_set1_epi64x (-1), (int)SCALE)
#define _mm256_mask_i64gather_epi64(SRC,BASE,INDEX,MASK,SCALE) (__m256i) __builtin_ia32_gatherdiv4di ((__v4di)(__m256i)SRC, (long long const *)BASE, (__v4di)(__m256i)INDEX, (__v4di)(__m256i)MASK, (int)SCALE)
#define _mm_i32gather_epi32(BASE,INDEX,SCALE) (__m128i) __builtin_ia32_gathersiv4si ((__v4si) _mm_setzero_si128 (), (int const *)BASE, (__v4si)(__m128i)INDEX, (__v4si)_mm_set1_epi32 (-1), (int)SCALE)
#define _mm_mask_i32gather_epi32(SRC,BASE,INDEX,MASK,SCALE) (__m128i) __builtin_ia32_gathersiv4si ((__v4si)(__m128i)SRC, (int const *)BASE, (__v4si)(__m128i)INDEX, (__v4si)(__m128i)MASK, (int)SCALE)
#define _mm256_i32gather_epi32(BASE,INDEX,SCALE) (__m256i) __builtin_ia32_gathersiv8si ((__v8si) _mm256_setzero_si256 (), (int const *)BASE, (__v8si)(__m256i)INDEX, (__v8si)_mm256_set1_epi32 (-1), (int)SCALE)
#define _mm256_mask_i32gather_epi32(SRC,BASE,INDEX,MASK,SCALE) (__m256i) __builtin_ia32_gathersiv8si ((__v8si)(__m256i)SRC, (int const *)BASE, (__v8si)(__m256i)INDEX, (__v8si)(__m256i)MASK, (int)SCALE)
#define _mm_i64gather_epi32(BASE,INDEX,SCALE) (__m128i) __builtin_ia32_gatherdiv4si ((__v4si) _mm_setzero_si128 (), (int const *)BASE, (__v2di)(__m128i)INDEX, (__v4si)_mm_set1_epi32 (-1), (int)SCALE)
#define _mm_mask_i64gather_epi32(SRC,BASE,INDEX,MASK,SCALE) (__m128i) __builtin_ia32_gatherdiv4si ((__v4si)(__m128i)SRC, (int const *)BASE, (__v2di)(__m128i)INDEX, (__v4si)(__m128i)MASK, (int)SCALE)
#define _mm256_i64gather_epi32(BASE,INDEX,SCALE) (__m128i) __builtin_ia32_gatherdiv4si256 ((__v4si) _mm_setzero_si128 (), (int const *)BASE, (__v4di)(__m256i)INDEX, (__v4si)_mm_set1_epi32(-1), (int)SCALE)
#define _mm256_mask_i64gather_epi32(SRC,BASE,INDEX,MASK,SCALE) (__m128i) __builtin_ia32_gatherdiv4si256 ((__v4si)(__m128i)SRC, (int const *)BASE, (__v4di)(__m256i)INDEX, (__v4si)(__m128i)MASK, (int)SCALE)
#undef __DISABLE_AVX2__
#pragma GCC pop_options
#define _AVX512FINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("avx512f")
#define __DISABLE_AVX512F__
typedef double __v8df __attribute__ ((__vector_size__ (64)));
typedef float __v16sf __attribute__ ((__vector_size__ (64)));
typedef long long __v8di __attribute__ ((__vector_size__ (64)));
typedef int __v16si __attribute__ ((__vector_size__ (64)));
typedef short __v32hi __attribute__ ((__vector_size__ (64)));
typedef char __v64qi __attribute__ ((__vector_size__ (64)));
typedef float __m512 __attribute__ ((__vector_size__ (64), __may_alias__));
typedef long long __m512i __attribute__ ((__vector_size__ (64), __may_alias__));
typedef double __m512d __attribute__ ((__vector_size__ (64), __may_alias__));
typedef unsigned char __mmask8;
typedef unsigned short __mmask16;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set_epi64 (long long __A, long long __B, long long __C,
long long __D, long long __E, long long __F,
long long __G, long long __H)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set_epi32 (int __A, int __B, int __C, int __D,
int __E, int __F, int __G, int __H,
int __I, int __J, int __K, int __L,
int __M, int __N, int __O, int __P)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set_pd (double __A, double __B, double __C, double __D,
double __E, double __F, double __G, double __H)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set_ps (float __A, float __B, float __C, float __D,
float __E, float __F, float __G, float __H,
float __I, float __J, float __K, float __L,
float __M, float __N, float __O, float __P)
;
#define _mm512_setr_epi64(e0,e1,e2,e3,e4,e5,e6,e7) _mm512_set_epi64(e7,e6,e5,e4,e3,e2,e1,e0)
#define _mm512_setr_epi32(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15) _mm512_set_epi32(e15,e14,e13,e12,e11,e10,e9,e8,e7,e6,e5,e4,e3,e2,e1,e0)
#define _mm512_setr_pd(e0,e1,e2,e3,e4,e5,e6,e7) _mm512_set_pd(e7,e6,e5,e4,e3,e2,e1,e0)
#define _mm512_setr_ps(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15) _mm512_set_ps(e15,e14,e13,e12,e11,e10,e9,e8,e7,e6,e5,e4,e3,e2,e1,e0)
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_undefined_ps (void)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_undefined_pd (void)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_undefined_si512 (void)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set1_epi8 (char __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set1_epi16 (short __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set1_pd (double __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set1_ps (float __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set4_epi32 (int __A, int __B, int __C, int __D)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set4_epi64 (long long __A, long long __B, long long __C,
long long __D)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set4_pd (double __A, double __B, double __C, double __D)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set4_ps (float __A, float __B, float __C, float __D)
;
#define _mm512_setr4_epi64(e0,e1,e2,e3) _mm512_set4_epi64(e3,e2,e1,e0)
#define _mm512_setr4_epi32(e0,e1,e2,e3) _mm512_set4_epi32(e3,e2,e1,e0)
#define _mm512_setr4_pd(e0,e1,e2,e3) _mm512_set4_pd(e3,e2,e1,e0)
#define _mm512_setr4_ps(e0,e1,e2,e3) _mm512_set4_ps(e3,e2,e1,e0)
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_setzero_ps (void)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_setzero_pd (void)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_setzero_epi32 (void)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_setzero_si512 (void)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mov_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mov_pd (__mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mov_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mov_ps (__mmask16 __U, __m512 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_load_pd (void const *__P)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_load_pd (__m512d __W, __mmask8 __U, void const *__P)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_load_pd (__mmask8 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_store_pd (void *__P, __m512d __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_store_pd (void *__P, __mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_load_ps (void const *__P)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_load_ps (__m512 __W, __mmask16 __U, void const *__P)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_load_ps (__mmask16 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_store_ps (void *__P, __m512 __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_store_ps (void *__P, __mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mov_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mov_epi64 (__mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_load_epi64 (void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_load_epi64 (__m512i __W, __mmask8 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_load_epi64 (__mmask8 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_store_epi64 (void *__P, __m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_store_epi64 (void *__P, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mov_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mov_epi32 (__mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_load_si512 (void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_load_epi32 (void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_load_epi32 (__m512i __W, __mmask16 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_load_epi32 (__mmask16 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_store_si512 (void *__P, __m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_store_epi32 (void *__P, __m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_store_epi32 (void *__P, __mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mullo_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mullo_epi32 (__mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mullo_epi32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sllv_epi32 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sllv_epi32 (__m512i __W, __mmask16 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sllv_epi32 (__mmask16 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_srav_epi32 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_srav_epi32 (__m512i __W, __mmask16 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_srav_epi32 (__mmask16 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_srlv_epi32 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_srlv_epi32 (__m512i __W, __mmask16 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_srlv_epi32 (__mmask16 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_add_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_add_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_add_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sub_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sub_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sub_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sllv_epi64 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sllv_epi64 (__m512i __W, __mmask8 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sllv_epi64 (__mmask8 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_srav_epi64 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_srav_epi64 (__m512i __W, __mmask8 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_srav_epi64 (__mmask8 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_srlv_epi64 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_srlv_epi64 (__m512i __W, __mmask8 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_srlv_epi64 (__mmask8 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_add_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_add_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_add_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mul_epi32 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mul_epi32 (__m512i __W, __mmask8 __M, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mul_epi32 (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sub_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sub_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sub_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mul_epu32 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mul_epu32 (__m512i __W, __mmask8 __M, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mul_epu32 (__mmask8 __M, __m512i __X, __m512i __Y)
;
#define _mm512_slli_epi64(X,C) ((__m512i) __builtin_ia32_psllqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_undefined_si512 (), (__mmask8)-1))
#define _mm512_mask_slli_epi64(W,U,X,C) ((__m512i) __builtin_ia32_psllqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_slli_epi64(U,X,C) ((__m512i) __builtin_ia32_psllqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_setzero_si512 (), (__mmask8)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sll_epi64 (__m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sll_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sll_epi64 (__mmask8 __U, __m512i __A, __m128i __B)
;
#define _mm512_srli_epi64(X,C) ((__m512i) __builtin_ia32_psrlqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_undefined_si512 (), (__mmask8)-1))
#define _mm512_mask_srli_epi64(W,U,X,C) ((__m512i) __builtin_ia32_psrlqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_srli_epi64(U,X,C) ((__m512i) __builtin_ia32_psrlqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_setzero_si512 (), (__mmask8)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_srl_epi64 (__m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_srl_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_srl_epi64 (__mmask8 __U, __m512i __A, __m128i __B)
;
#define _mm512_srai_epi64(X,C) ((__m512i) __builtin_ia32_psraqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_undefined_si512 (), (__mmask8)-1))
#define _mm512_mask_srai_epi64(W,U,X,C) ((__m512i) __builtin_ia32_psraqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_srai_epi64(U,X,C) ((__m512i) __builtin_ia32_psraqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_setzero_si512 (), (__mmask8)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sra_epi64 (__m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sra_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sra_epi64 (__mmask8 __U, __m512i __A, __m128i __B)
;
#define _mm512_slli_epi32(X,C) ((__m512i) __builtin_ia32_pslldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_undefined_si512 (), (__mmask16)-1))
#define _mm512_mask_slli_epi32(W,U,X,C) ((__m512i) __builtin_ia32_pslldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_slli_epi32(U,X,C) ((__m512i) __builtin_ia32_pslldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sll_epi32 (__m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sll_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sll_epi32 (__mmask16 __U, __m512i __A, __m128i __B)
;
#define _mm512_srli_epi32(X,C) ((__m512i) __builtin_ia32_psrldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_undefined_si512 (), (__mmask16)-1))
#define _mm512_mask_srli_epi32(W,U,X,C) ((__m512i) __builtin_ia32_psrldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_srli_epi32(U,X,C) ((__m512i) __builtin_ia32_psrldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_srl_epi32 (__m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_srl_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_srl_epi32 (__mmask16 __U, __m512i __A, __m128i __B)
;
#define _mm512_srai_epi32(X,C) ((__m512i) __builtin_ia32_psradi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_undefined_si512 (), (__mmask16)-1))
#define _mm512_mask_srai_epi32(W,U,X,C) ((__m512i) __builtin_ia32_psradi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_srai_epi32(U,X,C) ((__m512i) __builtin_ia32_psradi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sra_epi32 (__m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sra_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sra_epi32 (__mmask16 __U, __m512i __A, __m128i __B)
;
#define _mm_add_round_sd(A,B,C) (__m128d)__builtin_ia32_addsd_round(A, B, C)
#define _mm_add_round_ss(A,B,C) (__m128)__builtin_ia32_addss_round(A, B, C)
#define _mm_sub_round_sd(A,B,C) (__m128d)__builtin_ia32_subsd_round(A, B, C)
#define _mm_sub_round_ss(A,B,C) (__m128)__builtin_ia32_subss_round(A, B, C)
#define _mm512_ternarylogic_epi64(A,B,C,I) ((__m512i) __builtin_ia32_pternlogq512_mask ((__v8di)(__m512i)(A), (__v8di)(__m512i)(B), (__v8di)(__m512i)(C), (int)(I), (__mmask8)-1))
#define _mm512_mask_ternarylogic_epi64(A,U,B,C,I) ((__m512i) __builtin_ia32_pternlogq512_mask ((__v8di)(__m512i)(A), (__v8di)(__m512i)(B), (__v8di)(__m512i)(C), (int)(I), (__mmask8)(U)))
#define _mm512_maskz_ternarylogic_epi64(U,A,B,C,I) ((__m512i) __builtin_ia32_pternlogq512_maskz ((__v8di)(__m512i)(A), (__v8di)(__m512i)(B), (__v8di)(__m512i)(C), (int)(I), (__mmask8)(U)))
#define _mm512_ternarylogic_epi32(A,B,C,I) ((__m512i) __builtin_ia32_pternlogd512_mask ((__v16si)(__m512i)(A), (__v16si)(__m512i)(B), (__v16si)(__m512i)(C), (int)(I), (__mmask16)-1))
#define _mm512_mask_ternarylogic_epi32(A,U,B,C,I) ((__m512i) __builtin_ia32_pternlogd512_mask ((__v16si)(__m512i)(A), (__v16si)(__m512i)(B), (__v16si)(__m512i)(C), (int)(I), (__mmask16)(U)))
#define _mm512_maskz_ternarylogic_epi32(U,A,B,C,I) ((__m512i) __builtin_ia32_pternlogd512_maskz ((__v16si)(__m512i)(A), (__v16si)(__m512i)(B), (__v16si)(__m512i)(C), (int)(I), (__mmask16)(U)))
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rcp14_pd (__m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rcp14_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rcp14_pd (__mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rcp14_ps (__m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rcp14_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rcp14_ps (__mmask16 __U, __m512 __A)
;
extern __m128d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_rcp14_sd (__m128d __A, __m128d __B)
;
extern __m128
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_rcp14_ss (__m128 __A, __m128 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rsqrt14_pd (__m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rsqrt14_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rsqrt14_pd (__mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rsqrt14_ps (__m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rsqrt14_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rsqrt14_ps (__mmask16 __U, __m512 __A)
;
extern __m128d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_rsqrt14_sd (__m128d __A, __m128d __B)
;
extern __m128
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_rsqrt14_ss (__m128 __A, __m128 __B)
;
#define _mm512_sqrt_round_pd(A,C) (__m512d)__builtin_ia32_sqrtpd512_mask(A, (__v8df)_mm512_undefined_pd(), -1, C)
#define _mm512_mask_sqrt_round_pd(W,U,A,C) (__m512d)__builtin_ia32_sqrtpd512_mask(A, W, U, C)
#define _mm512_maskz_sqrt_round_pd(U,A,C) (__m512d)__builtin_ia32_sqrtpd512_mask(A, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_sqrt_round_ps(A,C) (__m512)__builtin_ia32_sqrtps512_mask(A, (__v16sf)_mm512_undefined_ps(), -1, C)
#define _mm512_mask_sqrt_round_ps(W,U,A,C) (__m512)__builtin_ia32_sqrtps512_mask(A, W, U, C)
#define _mm512_maskz_sqrt_round_ps(U,A,C) (__m512)__builtin_ia32_sqrtps512_mask(A, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm_sqrt_round_sd(A,B,C) (__m128d)__builtin_ia32_sqrtsd_round(A, B, C)
#define _mm_sqrt_round_ss(A,B,C) (__m128)__builtin_ia32_sqrtss_round(A, B, C)
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi8_epi32 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi8_epi32 (__m512i __W, __mmask16 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi8_epi32 (__mmask16 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi8_epi64 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi8_epi64 (__m512i __W, __mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi8_epi64 (__mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi16_epi32 (__m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi16_epi32 (__m512i __W, __mmask16 __U, __m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi16_epi32 (__mmask16 __U, __m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi16_epi64 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi16_epi64 (__m512i __W, __mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi16_epi64 (__mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi32_epi64 (__m256i __X)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi32_epi64 (__m512i __W, __mmask8 __U, __m256i __X)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi32_epi64 (__mmask8 __U, __m256i __X)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepu8_epi32 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepu8_epi32 (__m512i __W, __mmask16 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepu8_epi32 (__mmask16 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepu8_epi64 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepu8_epi64 (__m512i __W, __mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepu8_epi64 (__mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepu16_epi32 (__m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepu16_epi32 (__m512i __W, __mmask16 __U, __m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepu16_epi32 (__mmask16 __U, __m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepu16_epi64 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepu16_epi64 (__m512i __W, __mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepu16_epi64 (__mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepu32_epi64 (__m256i __X)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepu32_epi64 (__m512i __W, __mmask8 __U, __m256i __X)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepu32_epi64 (__mmask8 __U, __m256i __X)
;
#define _mm512_add_round_pd(A,B,C) (__m512d)__builtin_ia32_addpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, C)
#define _mm512_mask_add_round_pd(W,U,A,B,C) (__m512d)__builtin_ia32_addpd512_mask(A, B, W, U, C)
#define _mm512_maskz_add_round_pd(U,A,B,C) (__m512d)__builtin_ia32_addpd512_mask(A, B, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_add_round_ps(A,B,C) (__m512)__builtin_ia32_addps512_mask(A, B, (__v16sf)_mm512_undefined_ps(), -1, C)
#define _mm512_mask_add_round_ps(W,U,A,B,C) (__m512)__builtin_ia32_addps512_mask(A, B, W, U, C)
#define _mm512_maskz_add_round_ps(U,A,B,C) (__m512)__builtin_ia32_addps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm512_sub_round_pd(A,B,C) (__m512d)__builtin_ia32_subpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, C)
#define _mm512_mask_sub_round_pd(W,U,A,B,C) (__m512d)__builtin_ia32_subpd512_mask(A, B, W, U, C)
#define _mm512_maskz_sub_round_pd(U,A,B,C) (__m512d)__builtin_ia32_subpd512_mask(A, B, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_sub_round_ps(A,B,C) (__m512)__builtin_ia32_subps512_mask(A, B, (__v16sf)_mm512_undefined_ps(), -1, C)
#define _mm512_mask_sub_round_ps(W,U,A,B,C) (__m512)__builtin_ia32_subps512_mask(A, B, W, U, C)
#define _mm512_maskz_sub_round_ps(U,A,B,C) (__m512)__builtin_ia32_subps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm512_mul_round_pd(A,B,C) (__m512d)__builtin_ia32_mulpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, C)
#define _mm512_mask_mul_round_pd(W,U,A,B,C) (__m512d)__builtin_ia32_mulpd512_mask(A, B, W, U, C)
#define _mm512_maskz_mul_round_pd(U,A,B,C) (__m512d)__builtin_ia32_mulpd512_mask(A, B, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_mul_round_ps(A,B,C) (__m512)__builtin_ia32_mulps512_mask(A, B, (__v16sf)_mm512_undefined_ps(), -1, C)
#define _mm512_mask_mul_round_ps(W,U,A,B,C) (__m512)__builtin_ia32_mulps512_mask(A, B, W, U, C)
#define _mm512_maskz_mul_round_ps(U,A,B,C) (__m512)__builtin_ia32_mulps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm512_div_round_pd(A,B,C) (__m512d)__builtin_ia32_divpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, C)
#define _mm512_mask_div_round_pd(W,U,A,B,C) (__m512d)__builtin_ia32_divpd512_mask(A, B, W, U, C)
#define _mm512_maskz_div_round_pd(U,A,B,C) (__m512d)__builtin_ia32_divpd512_mask(A, B, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_div_round_ps(A,B,C) (__m512)__builtin_ia32_divps512_mask(A, B, (__v16sf)_mm512_undefined_ps(), -1, C)
#define _mm512_mask_div_round_ps(W,U,A,B,C) (__m512)__builtin_ia32_divps512_mask(A, B, W, U, C)
#define _mm512_maskz_div_round_ps(U,A,B,C) (__m512)__builtin_ia32_divps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm_mul_round_sd(A,B,C) (__m128d)__builtin_ia32_mulsd_round(A, B, C)
#define _mm_mul_round_ss(A,B,C) (__m128)__builtin_ia32_mulss_round(A, B, C)
#define _mm_div_round_sd(A,B,C) (__m128d)__builtin_ia32_divsd_round(A, B, C)
#define _mm_div_round_ss(A,B,C) (__m128)__builtin_ia32_divss_round(A, B, C)
#define _mm512_max_round_pd(A,B,R) (__m512d)__builtin_ia32_maxpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, R)
#define _mm512_mask_max_round_pd(W,U,A,B,R) (__m512d)__builtin_ia32_maxpd512_mask(A, B, W, U, R)
#define _mm512_maskz_max_round_pd(U,A,B,R) (__m512d)__builtin_ia32_maxpd512_mask(A, B, (__v8df)_mm512_setzero_pd(), U, R)
#define _mm512_max_round_ps(A,B,R) (__m512)__builtin_ia32_maxps512_mask(A, B, (__v16sf)_mm512_undefined_pd(), -1, R)
#define _mm512_mask_max_round_ps(W,U,A,B,R) (__m512)__builtin_ia32_maxps512_mask(A, B, W, U, R)
#define _mm512_maskz_max_round_ps(U,A,B,R) (__m512)__builtin_ia32_maxps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, R)
#define _mm512_min_round_pd(A,B,R) (__m512d)__builtin_ia32_minpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, R)
#define _mm512_mask_min_round_pd(W,U,A,B,R) (__m512d)__builtin_ia32_minpd512_mask(A, B, W, U, R)
#define _mm512_maskz_min_round_pd(U,A,B,R) (__m512d)__builtin_ia32_minpd512_mask(A, B, (__v8df)_mm512_setzero_pd(), U, R)
#define _mm512_min_round_ps(A,B,R) (__m512)__builtin_ia32_minps512_mask(A, B, (__v16sf)_mm512_undefined_ps(), -1, R)
#define _mm512_mask_min_round_ps(W,U,A,B,R) (__m512)__builtin_ia32_minps512_mask(A, B, W, U, R)
#define _mm512_maskz_min_round_ps(U,A,B,R) (__m512)__builtin_ia32_minps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, R)
#define _mm512_scalef_round_pd(A,B,C) (__m512d)__builtin_ia32_scalefpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, C)
#define _mm512_mask_scalef_round_pd(W,U,A,B,C) (__m512d)__builtin_ia32_scalefpd512_mask(A, B, W, U, C)
#define _mm512_maskz_scalef_round_pd(U,A,B,C) (__m512d)__builtin_ia32_scalefpd512_mask(A, B, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_scalef_round_ps(A,B,C) (__m512)__builtin_ia32_scalefps512_mask(A, B, (__v16sf)_mm512_undefined_ps(), -1, C)
#define _mm512_mask_scalef_round_ps(W,U,A,B,C) (__m512)__builtin_ia32_scalefps512_mask(A, B, W, U, C)
#define _mm512_maskz_scalef_round_ps(U,A,B,C) (__m512)__builtin_ia32_scalefps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm_scalef_round_sd(A,B,C) (__m128d)__builtin_ia32_scalefsd_round(A, B, C)
#define _mm_scalef_round_ss(A,B,C) (__m128)__builtin_ia32_scalefss_round(A, B, C)
#define _mm512_fmadd_round_pd(A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_mask(A, B, C, -1, R)
#define _mm512_mask_fmadd_round_pd(A,U,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_mask(A, B, C, U, R)
#define _mm512_mask3_fmadd_round_pd(A,B,C,U,R) (__m512d)__builtin_ia32_vfmaddpd512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmadd_round_pd(U,A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_maskz(A, B, C, U, R)
#define _mm512_fmadd_round_ps(A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_mask(A, B, C, -1, R)
#define _mm512_mask_fmadd_round_ps(A,U,B,C,R) (__m512)__builtin_ia32_vfmaddps512_mask(A, B, C, U, R)
#define _mm512_mask3_fmadd_round_ps(A,B,C,U,R) (__m512)__builtin_ia32_vfmaddps512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmadd_round_ps(U,A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_maskz(A, B, C, U, R)
#define _mm512_fmsub_round_pd(A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_mask(A, B, -(C), -1, R)
#define _mm512_mask_fmsub_round_pd(A,U,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_mask(A, B, -(C), U, R)
#define _mm512_mask3_fmsub_round_pd(A,B,C,U,R) (__m512d)__builtin_ia32_vfmsubpd512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmsub_round_pd(U,A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_maskz(A, B, -(C), U, R)
#define _mm512_fmsub_round_ps(A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_mask(A, B, -(C), -1, R)
#define _mm512_mask_fmsub_round_ps(A,U,B,C,R) (__m512)__builtin_ia32_vfmaddps512_mask(A, B, -(C), U, R)
#define _mm512_mask3_fmsub_round_ps(A,B,C,U,R) (__m512)__builtin_ia32_vfmsubps512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmsub_round_ps(U,A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_maskz(A, B, -(C), U, R)
#define _mm512_fmaddsub_round_pd(A,B,C,R) (__m512d)__builtin_ia32_vfmaddsubpd512_mask(A, B, C, -1, R)
#define _mm512_mask_fmaddsub_round_pd(A,U,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_mask(A, B, C, U, R)
#define _mm512_mask3_fmaddsub_round_pd(A,B,C,U,R) (__m512d)__builtin_ia32_vfmaddsubpd512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmaddsub_round_pd(U,A,B,C,R) (__m512d)__builtin_ia32_vfmaddsubpd512_maskz(A, B, C, U, R)
#define _mm512_fmaddsub_round_ps(A,B,C,R) (__m512)__builtin_ia32_vfmaddsubps512_mask(A, B, C, -1, R)
#define _mm512_mask_fmaddsub_round_ps(A,U,B,C,R) (__m512)__builtin_ia32_vfmaddsubps512_mask(A, B, C, U, R)
#define _mm512_mask3_fmaddsub_round_ps(A,B,C,U,R) (__m512)__builtin_ia32_vfmaddsubps512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmaddsub_round_ps(U,A,B,C,R) (__m512)__builtin_ia32_vfmaddsubps512_maskz(A, B, C, U, R)
#define _mm512_fmsubadd_round_pd(A,B,C,R) (__m512d)__builtin_ia32_vfmaddsubpd512_mask(A, B, -(C), -1, R)
#define _mm512_mask_fmsubadd_round_pd(A,U,B,C,R) (__m512d)__builtin_ia32_vfmaddsubpd512_mask(A, B, -(C), U, R)
#define _mm512_mask3_fmsubadd_round_pd(A,B,C,U,R) (__m512d)__builtin_ia32_vfmsubaddpd512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmsubadd_round_pd(U,A,B,C,R) (__m512d)__builtin_ia32_vfmaddsubpd512_maskz(A, B, -(C), U, R)
#define _mm512_fmsubadd_round_ps(A,B,C,R) (__m512)__builtin_ia32_vfmaddsubps512_mask(A, B, -(C), -1, R)
#define _mm512_mask_fmsubadd_round_ps(A,U,B,C,R) (__m512)__builtin_ia32_vfmaddsubps512_mask(A, B, -(C), U, R)
#define _mm512_mask3_fmsubadd_round_ps(A,B,C,U,R) (__m512)__builtin_ia32_vfmsubaddps512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmsubadd_round_ps(U,A,B,C,R) (__m512)__builtin_ia32_vfmaddsubps512_maskz(A, B, -(C), U, R)
#define _mm512_fnmadd_round_pd(A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_mask(-(A), B, C, -1, R)
#define _mm512_mask_fnmadd_round_pd(A,U,B,C,R) (__m512d)__builtin_ia32_vfnmaddpd512_mask(-(A), B, C, U, R)
#define _mm512_mask3_fnmadd_round_pd(A,B,C,U,R) (__m512d)__builtin_ia32_vfmaddpd512_mask3(-(A), B, C, U, R)
#define _mm512_maskz_fnmadd_round_pd(U,A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_maskz(-(A), B, C, U, R)
#define _mm512_fnmadd_round_ps(A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_mask(-(A), B, C, -1, R)
#define _mm512_mask_fnmadd_round_ps(A,U,B,C,R) (__m512)__builtin_ia32_vfnmaddps512_mask(-(A), B, C, U, R)
#define _mm512_mask3_fnmadd_round_ps(A,B,C,U,R) (__m512)__builtin_ia32_vfmaddps512_mask3(-(A), B, C, U, R)
#define _mm512_maskz_fnmadd_round_ps(U,A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_maskz(-(A), B, C, U, R)
#define _mm512_fnmsub_round_pd(A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_mask(-(A), B, -(C), -1, R)
#define _mm512_mask_fnmsub_round_pd(A,U,B,C,R) (__m512d)__builtin_ia32_vfnmsubpd512_mask(A, B, C, U, R)
#define _mm512_mask3_fnmsub_round_pd(A,B,C,U,R) (__m512d)__builtin_ia32_vfnmsubpd512_mask3(A, B, C, U, R)
#define _mm512_maskz_fnmsub_round_pd(U,A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_maskz(-(A), B, -(C), U, R)
#define _mm512_fnmsub_round_ps(A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_mask(-(A), B, -(C), -1, R)
#define _mm512_mask_fnmsub_round_ps(A,U,B,C,R) (__m512)__builtin_ia32_vfnmsubps512_mask(A, B, C, U, R)
#define _mm512_mask3_fnmsub_round_ps(A,B,C,U,R) (__m512)__builtin_ia32_vfnmsubps512_mask3(A, B, C, U, R)
#define _mm512_maskz_fnmsub_round_ps(U,A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_maskz(-(A), B, -(C), U, R)
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_abs_epi64 (__m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_abs_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_abs_epi64 (__mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_abs_epi32 (__m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_abs_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_abs_epi32 (__mmask16 __U, __m512i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcastss_ps (__m128 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcastss_ps (__m512 __O, __mmask16 __M, __m128 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcastss_ps (__mmask16 __M, __m128 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcastsd_pd (__m128d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcastsd_pd (__m512d __O, __mmask8 __M, __m128d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcastsd_pd (__mmask8 __M, __m128d __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcastd_epi32 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcastd_epi32 (__m512i __O, __mmask16 __M, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcastd_epi32 (__mmask16 __M, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set1_epi32 (int __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_set1_epi32 (__m512i __O, __mmask16 __M, int __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_set1_epi32 (__mmask16 __M, int __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcastq_epi64 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcastq_epi64 (__m512i __O, __mmask8 __M, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcastq_epi64 (__mmask8 __M, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set1_epi64 (long long __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_set1_epi64 (__m512i __O, __mmask8 __M, long long __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_set1_epi64 (__mmask8 __M, long long __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcast_f32x4 (__m128 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcast_f32x4 (__m512 __O, __mmask16 __M, __m128 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcast_f32x4 (__mmask16 __M, __m128 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcast_i32x4 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcast_i32x4 (__m512i __O, __mmask16 __M, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcast_i32x4 (__mmask16 __M, __m128i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcast_f64x4 (__m256d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcast_f64x4 (__m512d __O, __mmask8 __M, __m256d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcast_f64x4 (__mmask8 __M, __m256d __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcast_i64x4 (__m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcast_i64x4 (__m512i __O, __mmask8 __M, __m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcast_i64x4 (__mmask8 __M, __m256i __A)
;
typedef enum
{
_MM_PERM_AAAA = 0x00, _MM_PERM_AAAB = 0x01, _MM_PERM_AAAC = 0x02,
_MM_PERM_AAAD = 0x03, _MM_PERM_AABA = 0x04, _MM_PERM_AABB = 0x05,
_MM_PERM_AABC = 0x06, _MM_PERM_AABD = 0x07, _MM_PERM_AACA = 0x08,
_MM_PERM_AACB = 0x09, _MM_PERM_AACC = 0x0A, _MM_PERM_AACD = 0x0B,
_MM_PERM_AADA = 0x0C, _MM_PERM_AADB = 0x0D, _MM_PERM_AADC = 0x0E,
_MM_PERM_AADD = 0x0F, _MM_PERM_ABAA = 0x10, _MM_PERM_ABAB = 0x11,
_MM_PERM_ABAC = 0x12, _MM_PERM_ABAD = 0x13, _MM_PERM_ABBA = 0x14,
_MM_PERM_ABBB = 0x15, _MM_PERM_ABBC = 0x16, _MM_PERM_ABBD = 0x17,
_MM_PERM_ABCA = 0x18, _MM_PERM_ABCB = 0x19, _MM_PERM_ABCC = 0x1A,
_MM_PERM_ABCD = 0x1B, _MM_PERM_ABDA = 0x1C, _MM_PERM_ABDB = 0x1D,
_MM_PERM_ABDC = 0x1E, _MM_PERM_ABDD = 0x1F, _MM_PERM_ACAA = 0x20,
_MM_PERM_ACAB = 0x21, _MM_PERM_ACAC = 0x22, _MM_PERM_ACAD = 0x23,
_MM_PERM_ACBA = 0x24, _MM_PERM_ACBB = 0x25, _MM_PERM_ACBC = 0x26,
_MM_PERM_ACBD = 0x27, _MM_PERM_ACCA = 0x28, _MM_PERM_ACCB = 0x29,
_MM_PERM_ACCC = 0x2A, _MM_PERM_ACCD = 0x2B, _MM_PERM_ACDA = 0x2C,
_MM_PERM_ACDB = 0x2D, _MM_PERM_ACDC = 0x2E, _MM_PERM_ACDD = 0x2F,
_MM_PERM_ADAA = 0x30, _MM_PERM_ADAB = 0x31, _MM_PERM_ADAC = 0x32,
_MM_PERM_ADAD = 0x33, _MM_PERM_ADBA = 0x34, _MM_PERM_ADBB = 0x35,
_MM_PERM_ADBC = 0x36, _MM_PERM_ADBD = 0x37, _MM_PERM_ADCA = 0x38,
_MM_PERM_ADCB = 0x39, _MM_PERM_ADCC = 0x3A, _MM_PERM_ADCD = 0x3B,
_MM_PERM_ADDA = 0x3C, _MM_PERM_ADDB = 0x3D, _MM_PERM_ADDC = 0x3E,
_MM_PERM_ADDD = 0x3F, _MM_PERM_BAAA = 0x40, _MM_PERM_BAAB = 0x41,
_MM_PERM_BAAC = 0x42, _MM_PERM_BAAD = 0x43, _MM_PERM_BABA = 0x44,
_MM_PERM_BABB = 0x45, _MM_PERM_BABC = 0x46, _MM_PERM_BABD = 0x47,
_MM_PERM_BACA = 0x48, _MM_PERM_BACB = 0x49, _MM_PERM_BACC = 0x4A,
_MM_PERM_BACD = 0x4B, _MM_PERM_BADA = 0x4C, _MM_PERM_BADB = 0x4D,
_MM_PERM_BADC = 0x4E, _MM_PERM_BADD = 0x4F, _MM_PERM_BBAA = 0x50,
_MM_PERM_BBAB = 0x51, _MM_PERM_BBAC = 0x52, _MM_PERM_BBAD = 0x53,
_MM_PERM_BBBA = 0x54, _MM_PERM_BBBB = 0x55, _MM_PERM_BBBC = 0x56,
_MM_PERM_BBBD = 0x57, _MM_PERM_BBCA = 0x58, _MM_PERM_BBCB = 0x59,
_MM_PERM_BBCC = 0x5A, _MM_PERM_BBCD = 0x5B, _MM_PERM_BBDA = 0x5C,
_MM_PERM_BBDB = 0x5D, _MM_PERM_BBDC = 0x5E, _MM_PERM_BBDD = 0x5F,
_MM_PERM_BCAA = 0x60, _MM_PERM_BCAB = 0x61, _MM_PERM_BCAC = 0x62,
_MM_PERM_BCAD = 0x63, _MM_PERM_BCBA = 0x64, _MM_PERM_BCBB = 0x65,
_MM_PERM_BCBC = 0x66, _MM_PERM_BCBD = 0x67, _MM_PERM_BCCA = 0x68,
_MM_PERM_BCCB = 0x69, _MM_PERM_BCCC = 0x6A, _MM_PERM_BCCD = 0x6B,
_MM_PERM_BCDA = 0x6C, _MM_PERM_BCDB = 0x6D, _MM_PERM_BCDC = 0x6E,
_MM_PERM_BCDD = 0x6F, _MM_PERM_BDAA = 0x70, _MM_PERM_BDAB = 0x71,
_MM_PERM_BDAC = 0x72, _MM_PERM_BDAD = 0x73, _MM_PERM_BDBA = 0x74,
_MM_PERM_BDBB = 0x75, _MM_PERM_BDBC = 0x76, _MM_PERM_BDBD = 0x77,
_MM_PERM_BDCA = 0x78, _MM_PERM_BDCB = 0x79, _MM_PERM_BDCC = 0x7A,
_MM_PERM_BDCD = 0x7B, _MM_PERM_BDDA = 0x7C, _MM_PERM_BDDB = 0x7D,
_MM_PERM_BDDC = 0x7E, _MM_PERM_BDDD = 0x7F, _MM_PERM_CAAA = 0x80,
_MM_PERM_CAAB = 0x81, _MM_PERM_CAAC = 0x82, _MM_PERM_CAAD = 0x83,
_MM_PERM_CABA = 0x84, _MM_PERM_CABB = 0x85, _MM_PERM_CABC = 0x86,
_MM_PERM_CABD = 0x87, _MM_PERM_CACA = 0x88, _MM_PERM_CACB = 0x89,
_MM_PERM_CACC = 0x8A, _MM_PERM_CACD = 0x8B, _MM_PERM_CADA = 0x8C,
_MM_PERM_CADB = 0x8D, _MM_PERM_CADC = 0x8E, _MM_PERM_CADD = 0x8F,
_MM_PERM_CBAA = 0x90, _MM_PERM_CBAB = 0x91, _MM_PERM_CBAC = 0x92,
_MM_PERM_CBAD = 0x93, _MM_PERM_CBBA = 0x94, _MM_PERM_CBBB = 0x95,
_MM_PERM_CBBC = 0x96, _MM_PERM_CBBD = 0x97, _MM_PERM_CBCA = 0x98,
_MM_PERM_CBCB = 0x99, _MM_PERM_CBCC = 0x9A, _MM_PERM_CBCD = 0x9B,
_MM_PERM_CBDA = 0x9C, _MM_PERM_CBDB = 0x9D, _MM_PERM_CBDC = 0x9E,
_MM_PERM_CBDD = 0x9F, _MM_PERM_CCAA = 0xA0, _MM_PERM_CCAB = 0xA1,
_MM_PERM_CCAC = 0xA2, _MM_PERM_CCAD = 0xA3, _MM_PERM_CCBA = 0xA4,
_MM_PERM_CCBB = 0xA5, _MM_PERM_CCBC = 0xA6, _MM_PERM_CCBD = 0xA7,
_MM_PERM_CCCA = 0xA8, _MM_PERM_CCCB = 0xA9, _MM_PERM_CCCC = 0xAA,
_MM_PERM_CCCD = 0xAB, _MM_PERM_CCDA = 0xAC, _MM_PERM_CCDB = 0xAD,
_MM_PERM_CCDC = 0xAE, _MM_PERM_CCDD = 0xAF, _MM_PERM_CDAA = 0xB0,
_MM_PERM_CDAB = 0xB1, _MM_PERM_CDAC = 0xB2, _MM_PERM_CDAD = 0xB3,
_MM_PERM_CDBA = 0xB4, _MM_PERM_CDBB = 0xB5, _MM_PERM_CDBC = 0xB6,
_MM_PERM_CDBD = 0xB7, _MM_PERM_CDCA = 0xB8, _MM_PERM_CDCB = 0xB9,
_MM_PERM_CDCC = 0xBA, _MM_PERM_CDCD = 0xBB, _MM_PERM_CDDA = 0xBC,
_MM_PERM_CDDB = 0xBD, _MM_PERM_CDDC = 0xBE, _MM_PERM_CDDD = 0xBF,
_MM_PERM_DAAA = 0xC0, _MM_PERM_DAAB = 0xC1, _MM_PERM_DAAC = 0xC2,
_MM_PERM_DAAD = 0xC3, _MM_PERM_DABA = 0xC4, _MM_PERM_DABB = 0xC5,
_MM_PERM_DABC = 0xC6, _MM_PERM_DABD = 0xC7, _MM_PERM_DACA = 0xC8,
_MM_PERM_DACB = 0xC9, _MM_PERM_DACC = 0xCA, _MM_PERM_DACD = 0xCB,
_MM_PERM_DADA = 0xCC, _MM_PERM_DADB = 0xCD, _MM_PERM_DADC = 0xCE,
_MM_PERM_DADD = 0xCF, _MM_PERM_DBAA = 0xD0, _MM_PERM_DBAB = 0xD1,
_MM_PERM_DBAC = 0xD2, _MM_PERM_DBAD = 0xD3, _MM_PERM_DBBA = 0xD4,
_MM_PERM_DBBB = 0xD5, _MM_PERM_DBBC = 0xD6, _MM_PERM_DBBD = 0xD7,
_MM_PERM_DBCA = 0xD8, _MM_PERM_DBCB = 0xD9, _MM_PERM_DBCC = 0xDA,
_MM_PERM_DBCD = 0xDB, _MM_PERM_DBDA = 0xDC, _MM_PERM_DBDB = 0xDD,
_MM_PERM_DBDC = 0xDE, _MM_PERM_DBDD = 0xDF, _MM_PERM_DCAA = 0xE0,
_MM_PERM_DCAB = 0xE1, _MM_PERM_DCAC = 0xE2, _MM_PERM_DCAD = 0xE3,
_MM_PERM_DCBA = 0xE4, _MM_PERM_DCBB = 0xE5, _MM_PERM_DCBC = 0xE6,
_MM_PERM_DCBD = 0xE7, _MM_PERM_DCCA = 0xE8, _MM_PERM_DCCB = 0xE9,
_MM_PERM_DCCC = 0xEA, _MM_PERM_DCCD = 0xEB, _MM_PERM_DCDA = 0xEC,
_MM_PERM_DCDB = 0xED, _MM_PERM_DCDC = 0xEE, _MM_PERM_DCDD = 0xEF,
_MM_PERM_DDAA = 0xF0, _MM_PERM_DDAB = 0xF1, _MM_PERM_DDAC = 0xF2,
_MM_PERM_DDAD = 0xF3, _MM_PERM_DDBA = 0xF4, _MM_PERM_DDBB = 0xF5,
_MM_PERM_DDBC = 0xF6, _MM_PERM_DDBD = 0xF7, _MM_PERM_DDCA = 0xF8,
_MM_PERM_DDCB = 0xF9, _MM_PERM_DDCC = 0xFA, _MM_PERM_DDCD = 0xFB,
_MM_PERM_DDDA = 0xFC, _MM_PERM_DDDB = 0xFD, _MM_PERM_DDDC = 0xFE,
_MM_PERM_DDDD = 0xFF
} _MM_PERM_ENUM;
#define _mm512_shuffle_epi32(X,C) ((__m512i) __builtin_ia32_pshufd512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_undefined_si512 (), (__mmask16)-1))
#define _mm512_mask_shuffle_epi32(W,U,X,C) ((__m512i) __builtin_ia32_pshufd512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_shuffle_epi32(U,X,C) ((__m512i) __builtin_ia32_pshufd512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)(U)))
#define _mm512_shuffle_i64x2(X,Y,C) ((__m512i) __builtin_ia32_shuf_i64x2_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(C), (__v8di)(__m512i)_mm512_undefined_si512 (), (__mmask8)-1))
#define _mm512_mask_shuffle_i64x2(W,U,X,Y,C) ((__m512i) __builtin_ia32_shuf_i64x2_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(C), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_shuffle_i64x2(U,X,Y,C) ((__m512i) __builtin_ia32_shuf_i64x2_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(C), (__v8di)(__m512i)_mm512_setzero_si512 (), (__mmask8)(U)))
#define _mm512_shuffle_i32x4(X,Y,C) ((__m512i) __builtin_ia32_shuf_i32x4_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(C), (__v16si)(__m512i)_mm512_undefined_si512 (), (__mmask16)-1))
#define _mm512_mask_shuffle_i32x4(W,U,X,Y,C) ((__m512i) __builtin_ia32_shuf_i32x4_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_shuffle_i32x4(U,X,Y,C) ((__m512i) __builtin_ia32_shuf_i32x4_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)(U)))
#define _mm512_shuffle_f64x2(X,Y,C) ((__m512d) __builtin_ia32_shuf_f64x2_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(C), (__v8df)(__m512d)_mm512_undefined_pd(), (__mmask8)-1))
#define _mm512_mask_shuffle_f64x2(W,U,X,Y,C) ((__m512d) __builtin_ia32_shuf_f64x2_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(C), (__v8df)(__m512d)(W), (__mmask8)(U)))
#define _mm512_maskz_shuffle_f64x2(U,X,Y,C) ((__m512d) __builtin_ia32_shuf_f64x2_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(C), (__v8df)(__m512d)_mm512_setzero_pd(), (__mmask8)(U)))
#define _mm512_shuffle_f32x4(X,Y,C) ((__m512) __builtin_ia32_shuf_f32x4_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(C), (__v16sf)(__m512)_mm512_undefined_ps(), (__mmask16)-1))
#define _mm512_mask_shuffle_f32x4(W,U,X,Y,C) ((__m512) __builtin_ia32_shuf_f32x4_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(C), (__v16sf)(__m512)(W), (__mmask16)(U)))
#define _mm512_maskz_shuffle_f32x4(U,X,Y,C) ((__m512) __builtin_ia32_shuf_f32x4_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(C), (__v16sf)(__m512)_mm512_setzero_ps(), (__mmask16)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rolv_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rolv_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rolv_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rorv_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rorv_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rorv_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rolv_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rolv_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rolv_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rorv_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rorv_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rorv_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
#define _mm512_cvtt_roundpd_epi32(A,B) ((__m256i)__builtin_ia32_cvttpd2dq512_mask(A, (__v8si)_mm256_undefined_si256(), -1, B))
#define _mm512_mask_cvtt_roundpd_epi32(W,U,A,B) ((__m256i)__builtin_ia32_cvttpd2dq512_mask(A, (__v8si)(W), U, B))
#define _mm512_maskz_cvtt_roundpd_epi32(U,A,B) ((__m256i)__builtin_ia32_cvttpd2dq512_mask(A, (__v8si)_mm256_setzero_si256(), U, B))
#define _mm512_cvtt_roundpd_epu32(A,B) ((__m256i)__builtin_ia32_cvttpd2udq512_mask(A, (__v8si)_mm256_undefined_si256(), -1, B))
#define _mm512_mask_cvtt_roundpd_epu32(W,U,A,B) ((__m256i)__builtin_ia32_cvttpd2udq512_mask(A, (__v8si)(W), U, B))
#define _mm512_maskz_cvtt_roundpd_epu32(U,A,B) ((__m256i)__builtin_ia32_cvttpd2udq512_mask(A, (__v8si)_mm256_setzero_si256(), U, B))
#define _mm512_cvt_roundpd_epi32(A,B) ((__m256i)__builtin_ia32_cvtpd2dq512_mask(A, (__v8si)_mm256_undefined_si256(), -1, B))
#define _mm512_mask_cvt_roundpd_epi32(W,U,A,B) ((__m256i)__builtin_ia32_cvtpd2dq512_mask(A, (__v8si)(W), U, B))
#define _mm512_maskz_cvt_roundpd_epi32(U,A,B) ((__m256i)__builtin_ia32_cvtpd2dq512_mask(A, (__v8si)_mm256_setzero_si256(), U, B))
#define _mm512_cvt_roundpd_epu32(A,B) ((__m256i)__builtin_ia32_cvtpd2udq512_mask(A, (__v8si)_mm256_undefined_si256(), -1, B))
#define _mm512_mask_cvt_roundpd_epu32(W,U,A,B) ((__m256i)__builtin_ia32_cvtpd2udq512_mask(A, (__v8si)(W), U, B))
#define _mm512_maskz_cvt_roundpd_epu32(U,A,B) ((__m256i)__builtin_ia32_cvtpd2udq512_mask(A, (__v8si)_mm256_setzero_si256(), U, B))
#define _mm512_cvtt_roundps_epi32(A,B) ((__m512i)__builtin_ia32_cvttps2dq512_mask(A, (__v16si)_mm512_undefined_si512 (), -1, B))
#define _mm512_mask_cvtt_roundps_epi32(W,U,A,B) ((__m512i)__builtin_ia32_cvttps2dq512_mask(A, (__v16si)(W), U, B))
#define _mm512_maskz_cvtt_roundps_epi32(U,A,B) ((__m512i)__builtin_ia32_cvttps2dq512_mask(A, (__v16si)_mm512_setzero_si512 (), U, B))
#define _mm512_cvtt_roundps_epu32(A,B) ((__m512i)__builtin_ia32_cvttps2udq512_mask(A, (__v16si)_mm512_undefined_si512 (), -1, B))
#define _mm512_mask_cvtt_roundps_epu32(W,U,A,B) ((__m512i)__builtin_ia32_cvttps2udq512_mask(A, (__v16si)(W), U, B))
#define _mm512_maskz_cvtt_roundps_epu32(U,A,B) ((__m512i)__builtin_ia32_cvttps2udq512_mask(A, (__v16si)_mm512_setzero_si512 (), U, B))
#define _mm512_cvt_roundps_epi32(A,B) ((__m512i)__builtin_ia32_cvtps2dq512_mask(A, (__v16si)_mm512_undefined_si512 (), -1, B))
#define _mm512_mask_cvt_roundps_epi32(W,U,A,B) ((__m512i)__builtin_ia32_cvtps2dq512_mask(A, (__v16si)(W), U, B))
#define _mm512_maskz_cvt_roundps_epi32(U,A,B) ((__m512i)__builtin_ia32_cvtps2dq512_mask(A, (__v16si)_mm512_setzero_si512 (), U, B))
#define _mm512_cvt_roundps_epu32(A,B) ((__m512i)__builtin_ia32_cvtps2udq512_mask(A, (__v16si)_mm512_undefined_si512 (), -1, B))
#define _mm512_mask_cvt_roundps_epu32(W,U,A,B) ((__m512i)__builtin_ia32_cvtps2udq512_mask(A, (__v16si)(W), U, B))
#define _mm512_maskz_cvt_roundps_epu32(U,A,B) ((__m512i)__builtin_ia32_cvtps2udq512_mask(A, (__v16si)_mm512_setzero_si512 (), U, B))
extern __m128d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtu32_sd (__m128d __A, unsigned __B)
;
#define _mm_cvt_roundu64_sd(A,B,C) (__m128d)__builtin_ia32_cvtusi2sd64(A, B, C)
#define _mm_cvt_roundi64_sd(A,B,C) (__m128d)__builtin_ia32_cvtsi2sd64(A, B, C)
#define _mm_cvt_roundsi64_sd(A,B,C) (__m128d)__builtin_ia32_cvtsi2sd64(A, B, C)
#define _mm_cvt_roundu32_ss(A,B,C) (__m128)__builtin_ia32_cvtusi2ss32(A, B, C)
#define _mm_cvt_roundi32_ss(A,B,C) (__m128)__builtin_ia32_cvtsi2ss32(A, B, C)
#define _mm_cvt_roundsi32_ss(A,B,C) (__m128)__builtin_ia32_cvtsi2ss32(A, B, C)
#define _mm_cvt_roundu64_ss(A,B,C) (__m128)__builtin_ia32_cvtusi2ss64(A, B, C)
#define _mm_cvt_roundi64_ss(A,B,C) (__m128)__builtin_ia32_cvtsi2ss64(A, B, C)
#define _mm_cvt_roundsi64_ss(A,B,C) (__m128)__builtin_ia32_cvtsi2ss64(A, B, C)
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi32_epi8 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi32_storeu_epi8 (void * __P, __mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi32_epi8 (__m128i __O, __mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi32_epi8 (__mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtsepi32_epi8 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi32_storeu_epi8 (void * __P, __mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi32_epi8 (__m128i __O, __mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtsepi32_epi8 (__mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtusepi32_epi8 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi32_storeu_epi8 (void * __P, __mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi32_epi8 (__m128i __O, __mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtusepi32_epi8 (__mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi32_epi16 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi32_storeu_epi16 (void * __P, __mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi32_epi16 (__m256i __O, __mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi32_epi16 (__mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtsepi32_epi16 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi32_storeu_epi16 (void *__P, __mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi32_epi16 (__m256i __O, __mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtsepi32_epi16 (__mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtusepi32_epi16 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi32_storeu_epi16 (void *__P, __mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi32_epi16 (__m256i __O, __mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtusepi32_epi16 (__mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi64_epi32 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi64_storeu_epi32 (void* __P, __mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi64_epi32 (__m256i __O, __mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi64_epi32 (__mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtsepi64_epi32 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi64_storeu_epi32 (void *__P, __mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi64_epi32 (__m256i __O, __mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtsepi64_epi32 (__mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtusepi64_epi32 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi64_storeu_epi32 (void* __P, __mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi64_epi32 (__m256i __O, __mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtusepi64_epi32 (__mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi64_epi16 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi64_storeu_epi16 (void *__P, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi64_epi16 (__m128i __O, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi64_epi16 (__mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtsepi64_epi16 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi64_storeu_epi16 (void * __P, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi64_epi16 (__m128i __O, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtsepi64_epi16 (__mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtusepi64_epi16 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi64_storeu_epi16 (void *__P, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi64_epi16 (__m128i __O, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtusepi64_epi16 (__mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi64_epi8 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi64_storeu_epi8 (void * __P, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi64_epi8 (__m128i __O, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi64_epi8 (__mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtsepi64_epi8 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi64_storeu_epi8 (void * __P, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi64_epi8 (__m128i __O, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtsepi64_epi8 (__mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtusepi64_epi8 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi64_storeu_epi8 (void * __P, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi64_epi8 (__m128i __O, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtusepi64_epi8 (__mmask8 __M, __m512i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi32_pd (__m256i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi32_pd (__m512d __W, __mmask8 __U, __m256i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi32_pd (__mmask8 __U, __m256i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepu32_pd (__m256i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepu32_pd (__m512d __W, __mmask8 __U, __m256i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepu32_pd (__mmask8 __U, __m256i __A)
;
#define _mm512_cvt_roundepi32_ps(A,B) (__m512)__builtin_ia32_cvtdq2ps512_mask((__v16si)(A), (__v16sf)_mm512_undefined_ps(), -1, B)
#define _mm512_mask_cvt_roundepi32_ps(W,U,A,B) (__m512)__builtin_ia32_cvtdq2ps512_mask((__v16si)(A), W, U, B)
#define _mm512_maskz_cvt_roundepi32_ps(U,A,B) (__m512)__builtin_ia32_cvtdq2ps512_mask((__v16si)(A), (__v16sf)_mm512_setzero_ps(), U, B)
#define _mm512_cvt_roundepu32_ps(A,B) (__m512)__builtin_ia32_cvtudq2ps512_mask((__v16si)(A), (__v16sf)_mm512_undefined_ps(), -1, B)
#define _mm512_mask_cvt_roundepu32_ps(W,U,A,B) (__m512)__builtin_ia32_cvtudq2ps512_mask((__v16si)(A), W, U, B)
#define _mm512_maskz_cvt_roundepu32_ps(U,A,B) (__m512)__builtin_ia32_cvtudq2ps512_mask((__v16si)(A), (__v16sf)_mm512_setzero_ps(), U, B)
#define _mm512_extractf64x4_pd(X,C) ((__m256d) __builtin_ia32_extractf64x4_mask ((__v8df)(__m512d) (X), (int) (C), (__v4df)(__m256d)_mm256_undefined_pd(), (__mmask8)-1))
#define _mm512_mask_extractf64x4_pd(W,U,X,C) ((__m256d) __builtin_ia32_extractf64x4_mask ((__v8df)(__m512d) (X), (int) (C), (__v4df)(__m256d)(W), (__mmask8)(U)))
#define _mm512_maskz_extractf64x4_pd(U,X,C) ((__m256d) __builtin_ia32_extractf64x4_mask ((__v8df)(__m512d) (X), (int) (C), (__v4df)(__m256d)_mm256_setzero_pd(), (__mmask8)(U)))
#define _mm512_extractf32x4_ps(X,C) ((__m128) __builtin_ia32_extractf32x4_mask ((__v16sf)(__m512) (X), (int) (C), (__v4sf)(__m128)_mm_undefined_ps(), (__mmask8)-1))
#define _mm512_mask_extractf32x4_ps(W,U,X,C) ((__m128) __builtin_ia32_extractf32x4_mask ((__v16sf)(__m512) (X), (int) (C), (__v4sf)(__m128)(W), (__mmask8)(U)))
#define _mm512_maskz_extractf32x4_ps(U,X,C) ((__m128) __builtin_ia32_extractf32x4_mask ((__v16sf)(__m512) (X), (int) (C), (__v4sf)(__m128)_mm_setzero_ps(), (__mmask8)(U)))
#define _mm512_extracti64x4_epi64(X,C) ((__m256i) __builtin_ia32_extracti64x4_mask ((__v8di)(__m512i) (X), (int) (C), (__v4di)(__m256i)_mm256_undefined_si256 (), (__mmask8)-1))
#define _mm512_mask_extracti64x4_epi64(W,U,X,C) ((__m256i) __builtin_ia32_extracti64x4_mask ((__v8di)(__m512i) (X), (int) (C), (__v4di)(__m256i)(W), (__mmask8)(U)))
#define _mm512_maskz_extracti64x4_epi64(U,X,C) ((__m256i) __builtin_ia32_extracti64x4_mask ((__v8di)(__m512i) (X), (int) (C), (__v4di)(__m256i)_mm256_setzero_si256 (), (__mmask8)(U)))
#define _mm512_extracti32x4_epi32(X,C) ((__m128i) __builtin_ia32_extracti32x4_mask ((__v16si)(__m512i) (X), (int) (C), (__v4si)(__m128i)_mm_undefined_si128 (), (__mmask8)-1))
#define _mm512_mask_extracti32x4_epi32(W,U,X,C) ((__m128i) __builtin_ia32_extracti32x4_mask ((__v16si)(__m512i) (X), (int) (C), (__v4si)(__m128i)(W), (__mmask8)(U)))
#define _mm512_maskz_extracti32x4_epi32(U,X,C) ((__m128i) __builtin_ia32_extracti32x4_mask ((__v16si)(__m512i) (X), (int) (C), (__v4si)(__m128i)_mm_setzero_si128 (), (__mmask8)(U)))
#define _mm512_insertf32x4(X,Y,C) ((__m512) __builtin_ia32_insertf32x4_mask ((__v16sf)(__m512) (X), (__v4sf)(__m128) (Y), (int) (C), (__v16sf)(__m512) (X), (__mmask16)(-1)))
#define _mm512_inserti32x4(X,Y,C) ((__m512i) __builtin_ia32_inserti32x4_mask ((__v16si)(__m512i) (X), (__v4si)(__m128i) (Y), (int) (C), (__v16si)(__m512i) (X), (__mmask16)(-1)))
#define _mm512_insertf64x4(X,Y,C) ((__m512d) __builtin_ia32_insertf64x4_mask ((__v8df)(__m512d) (X), (__v4df)(__m256d) (Y), (int) (C), (__v8df)(__m512d)_mm512_undefined_pd(), (__mmask8)-1))
#define _mm512_mask_insertf64x4(W,U,X,Y,C) ((__m512d) __builtin_ia32_insertf64x4_mask ((__v8df)(__m512d) (X), (__v4df)(__m256d) (Y), (int) (C), (__v8df)(__m512d)(W), (__mmask8)(U)))
#define _mm512_maskz_insertf64x4(U,X,Y,C) ((__m512d) __builtin_ia32_insertf64x4_mask ((__v8df)(__m512d) (X), (__v4df)(__m256d) (Y), (int) (C), (__v8df)(__m512d)_mm512_setzero_pd(), (__mmask8)(U)))
#define _mm512_inserti64x4(X,Y,C) ((__m512i) __builtin_ia32_inserti64x4_mask ((__v8di)(__m512i) (X), (__v4di)(__m256i) (Y), (int) (C), (__v8di)(__m512i)_mm512_undefined_si512 (), (__mmask8)-1))
#define _mm512_mask_inserti64x4(W,U,X,Y,C) ((__m512i) __builtin_ia32_inserti64x4_mask ((__v8di)(__m512i) (X), (__v4di)(__m256i) (Y), (int) (C), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_inserti64x4(U,X,Y,C) ((__m512i) __builtin_ia32_inserti64x4_mask ((__v8di)(__m512i) (X), (__v4di)(__m256i) (Y), (int) (C), (__v8di)(__m512i)_mm512_setzero_si512 (), (__mmask8)(U)))
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_loadu_pd (void const *__P)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_loadu_pd (__m512d __W, __mmask8 __U, void const *__P)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_loadu_pd (__mmask8 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_storeu_pd (void *__P, __m512d __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_storeu_pd (void *__P, __mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_loadu_ps (void const *__P)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_loadu_ps (__m512 __W, __mmask16 __U, void const *__P)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_loadu_ps (__mmask16 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_storeu_ps (void *__P, __m512 __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_storeu_ps (void *__P, __mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_loadu_epi64 (__m512i __W, __mmask8 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_loadu_epi64 (__mmask8 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_storeu_epi64 (void *__P, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_loadu_si512 (void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_loadu_epi32 (__m512i __W, __mmask16 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_loadu_epi32 (__mmask16 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_storeu_si512 (void *__P, __m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_storeu_epi32 (void *__P, __mmask16 __U, __m512i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutevar_pd (__m512d __A, __m512i __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutevar_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512i __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutevar_pd (__mmask8 __U, __m512d __A, __m512i __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutevar_ps (__m512 __A, __m512i __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutevar_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512i __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutevar_ps (__mmask16 __U, __m512 __A, __m512i __C)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutex2var_epi64 (__m512i __A, __m512i __I, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutex2var_epi64 (__m512i __A, __mmask8 __U, __m512i __I,
__m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask2_permutex2var_epi64 (__m512i __A, __m512i __I,
__mmask8 __U, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutex2var_epi64 (__mmask8 __U, __m512i __A,
__m512i __I, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutex2var_epi32 (__m512i __A, __m512i __I, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutex2var_epi32 (__m512i __A, __mmask16 __U,
__m512i __I, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask2_permutex2var_epi32 (__m512i __A, __m512i __I,
__mmask16 __U, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutex2var_epi32 (__mmask16 __U, __m512i __A,
__m512i __I, __m512i __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutex2var_pd (__m512d __A, __m512i __I, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutex2var_pd (__m512d __A, __mmask8 __U, __m512i __I,
__m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask2_permutex2var_pd (__m512d __A, __m512i __I, __mmask8 __U,
__m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutex2var_pd (__mmask8 __U, __m512d __A, __m512i __I,
__m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutex2var_ps (__m512 __A, __m512i __I, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutex2var_ps (__m512 __A, __mmask16 __U, __m512i __I, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask2_permutex2var_ps (__m512 __A, __m512i __I, __mmask16 __U,
__m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutex2var_ps (__mmask16 __U, __m512 __A, __m512i __I,
__m512 __B)
;
#define _mm512_permute_pd(X,C) ((__m512d) __builtin_ia32_vpermilpd512_mask ((__v8df)(__m512d)(X), (int)(C), (__v8df)(__m512d)_mm512_undefined_pd(), (__mmask8)(-1)))
#define _mm512_mask_permute_pd(W,U,X,C) ((__m512d) __builtin_ia32_vpermilpd512_mask ((__v8df)(__m512d)(X), (int)(C), (__v8df)(__m512d)(W), (__mmask8)(U)))
#define _mm512_maskz_permute_pd(U,X,C) ((__m512d) __builtin_ia32_vpermilpd512_mask ((__v8df)(__m512d)(X), (int)(C), (__v8df)(__m512d)_mm512_setzero_pd(), (__mmask8)(U)))
#define _mm512_permute_ps(X,C) ((__m512) __builtin_ia32_vpermilps512_mask ((__v16sf)(__m512)(X), (int)(C), (__v16sf)(__m512)_mm512_undefined_ps(), (__mmask16)(-1)))
#define _mm512_mask_permute_ps(W,U,X,C) ((__m512) __builtin_ia32_vpermilps512_mask ((__v16sf)(__m512)(X), (int)(C), (__v16sf)(__m512)(W), (__mmask16)(U)))
#define _mm512_maskz_permute_ps(U,X,C) ((__m512) __builtin_ia32_vpermilps512_mask ((__v16sf)(__m512)(X), (int)(C), (__v16sf)(__m512)_mm512_setzero_ps(), (__mmask16)(U)))
#define _mm512_permutex_pd(X,M) ((__m512d) __builtin_ia32_permdf512_mask ((__v8df)(__m512d)(X), (int)(M), (__v8df)(__m512d)_mm512_undefined_pd(), (__mmask8)-1))
#define _mm512_mask_permutex_pd(W,U,X,M) ((__m512d) __builtin_ia32_permdf512_mask ((__v8df)(__m512d)(X), (int)(M), (__v8df)(__m512d)(W), (__mmask8)(U)))
#define _mm512_maskz_permutex_pd(U,X,M) ((__m512d) __builtin_ia32_permdf512_mask ((__v8df)(__m512d)(X), (int)(M), (__v8df)(__m512d)_mm512_setzero_pd(), (__mmask8)(U)))
#define _mm512_permutex_epi64(X,I) ((__m512i) __builtin_ia32_permdi512_mask ((__v8di)(__m512i)(X), (int)(I), (__v8di)(__m512i) (_mm512_undefined_si512 ()), (__mmask8)(-1)))
#define _mm512_maskz_permutex_epi64(M,X,I) ((__m512i) __builtin_ia32_permdi512_mask ((__v8di)(__m512i)(X), (int)(I), (__v8di)(__m512i) (_mm512_setzero_si512 ()), (__mmask8)(M)))
#define _mm512_mask_permutex_epi64(W,M,X,I) ((__m512i) __builtin_ia32_permdi512_mask ((__v8di)(__m512i)(X), (int)(I), (__v8di)(__m512i)(W), (__mmask8)(M)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutexvar_epi64 (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutexvar_epi64 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutexvar_epi64 (__m512i __W, __mmask8 __M, __m512i __X,
__m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutexvar_epi32 (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutexvar_epi32 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutexvar_epi32 (__m512i __W, __mmask16 __M, __m512i __X,
__m512i __Y)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutexvar_pd (__m512i __X, __m512d __Y)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutexvar_pd (__m512d __W, __mmask8 __U, __m512i __X, __m512d __Y)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutexvar_pd (__mmask8 __U, __m512i __X, __m512d __Y)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutexvar_ps (__m512i __X, __m512 __Y)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutexvar_ps (__m512 __W, __mmask16 __U, __m512i __X, __m512 __Y)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutexvar_ps (__mmask16 __U, __m512i __X, __m512 __Y)
;
#define _mm512_shuffle_pd(X,Y,C) ((__m512d)__builtin_ia32_shufpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(C), (__v8df)(__m512d)_mm512_undefined_pd(), (__mmask8)-1))
#define _mm512_mask_shuffle_pd(W,U,X,Y,C) ((__m512d)__builtin_ia32_shufpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(C), (__v8df)(__m512d)(W), (__mmask8)(U)))
#define _mm512_maskz_shuffle_pd(U,X,Y,C) ((__m512d)__builtin_ia32_shufpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(C), (__v8df)(__m512d)_mm512_setzero_pd(), (__mmask8)(U)))
#define _mm512_shuffle_ps(X,Y,C) ((__m512)__builtin_ia32_shufps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(C), (__v16sf)(__m512)_mm512_undefined_ps(), (__mmask16)-1))
#define _mm512_mask_shuffle_ps(W,U,X,Y,C) ((__m512)__builtin_ia32_shufps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(C), (__v16sf)(__m512)(W), (__mmask16)(U)))
#define _mm512_maskz_shuffle_ps(U,X,Y,C) ((__m512)__builtin_ia32_shufps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(C), (__v16sf)(__m512)_mm512_setzero_ps(), (__mmask16)(U)))
#define _mm512_fixupimm_round_pd(X,Y,Z,C,R) ((__m512d)__builtin_ia32_fixupimmpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (__v8di)(__m512i)(Z), (int)(C), (__mmask8)(-1), (R)))
#define _mm512_mask_fixupimm_round_pd(X,U,Y,Z,C,R) ((__m512d)__builtin_ia32_fixupimmpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (__v8di)(__m512i)(Z), (int)(C), (__mmask8)(U), (R)))
#define _mm512_maskz_fixupimm_round_pd(U,X,Y,Z,C,R) ((__m512d)__builtin_ia32_fixupimmpd512_maskz ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (__v8di)(__m512i)(Z), (int)(C), (__mmask8)(U), (R)))
#define _mm512_fixupimm_round_ps(X,Y,Z,C,R) ((__m512)__builtin_ia32_fixupimmps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(-1), (R)))
#define _mm512_mask_fixupimm_round_ps(X,U,Y,Z,C,R) ((__m512)__builtin_ia32_fixupimmps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(U), (R)))
#define _mm512_maskz_fixupimm_round_ps(U,X,Y,Z,C,R) ((__m512)__builtin_ia32_fixupimmps512_maskz ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(U), (R)))
#define _mm_fixupimm_round_sd(X,Y,Z,C,R) ((__m128d)__builtin_ia32_fixupimmsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(-1), (R)))
#define _mm_mask_fixupimm_round_sd(X,U,Y,Z,C,R) ((__m128d)__builtin_ia32_fixupimmsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(U), (R)))
#define _mm_maskz_fixupimm_round_sd(U,X,Y,Z,C,R) ((__m128d)__builtin_ia32_fixupimmsd_maskz ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(U), (R)))
#define _mm_fixupimm_round_ss(X,Y,Z,C,R) ((__m128)__builtin_ia32_fixupimmss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(-1), (R)))
#define _mm_mask_fixupimm_round_ss(X,U,Y,Z,C,R) ((__m128)__builtin_ia32_fixupimmss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(U), (R)))
#define _mm_maskz_fixupimm_round_ss(U,X,Y,Z,C,R) ((__m128)__builtin_ia32_fixupimmss_maskz ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(U), (R)))
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_movehdup_ps (__m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_movehdup_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_movehdup_ps (__mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_moveldup_ps (__m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_moveldup_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_moveldup_ps (__mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_or_si512 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_or_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_or_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_or_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_or_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_or_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_or_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_xor_si512 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_xor_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_xor_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_xor_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_xor_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_xor_epi64 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_xor_epi64 (__mmask16 __U, __m512i __A, __m512i __B)
;
#define _mm512_rol_epi32(A,B) ((__m512i)__builtin_ia32_prold512_mask ((__v16si)(__m512i)(A), (int)(B), (__v16si)_mm512_undefined_si512 (), (__mmask16)(-1)))
#define _mm512_mask_rol_epi32(W,U,A,B) ((__m512i)__builtin_ia32_prold512_mask ((__v16si)(__m512i)(A), (int)(B), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_rol_epi32(U,A,B) ((__m512i)__builtin_ia32_prold512_mask ((__v16si)(__m512i)(A), (int)(B), (__v16si)_mm512_setzero_si512 (), (__mmask16)(U)))
#define _mm512_ror_epi32(A,B) ((__m512i)__builtin_ia32_prord512_mask ((__v16si)(__m512i)(A), (int)(B), (__v16si)_mm512_undefined_si512 (), (__mmask16)(-1)))
#define _mm512_mask_ror_epi32(W,U,A,B) ((__m512i)__builtin_ia32_prord512_mask ((__v16si)(__m512i)(A), (int)(B), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_ror_epi32(U,A,B) ((__m512i)__builtin_ia32_prord512_mask ((__v16si)(__m512i)(A), (int)(B), (__v16si)_mm512_setzero_si512 (), (__mmask16)(U)))
#define _mm512_rol_epi64(A,B) ((__m512i)__builtin_ia32_prolq512_mask ((__v8di)(__m512i)(A), (int)(B), (__v8di)_mm512_undefined_si512 (), (__mmask8)(-1)))
#define _mm512_mask_rol_epi64(W,U,A,B) ((__m512i)__builtin_ia32_prolq512_mask ((__v8di)(__m512i)(A), (int)(B), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_rol_epi64(U,A,B) ((__m512i)__builtin_ia32_prolq512_mask ((__v8di)(__m512i)(A), (int)(B), (__v8di)_mm512_setzero_si512 (), (__mmask8)(U)))
#define _mm512_ror_epi64(A,B) ((__m512i)__builtin_ia32_prorq512_mask ((__v8di)(__m512i)(A), (int)(B), (__v8di)_mm512_undefined_si512 (), (__mmask8)(-1)))
#define _mm512_mask_ror_epi64(W,U,A,B) ((__m512i)__builtin_ia32_prorq512_mask ((__v8di)(__m512i)(A), (int)(B), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_ror_epi64(U,A,B) ((__m512i)__builtin_ia32_prorq512_mask ((__v8di)(__m512i)(A), (int)(B), (__v8di)_mm512_setzero_si512 (), (__mmask8)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_and_si512 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_and_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_and_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_and_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_and_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_and_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_and_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_andnot_si512 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_andnot_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_andnot_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_andnot_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_andnot_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_andnot_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_andnot_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_test_epi32_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_test_epi32_mask (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_test_epi64_mask (__m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_test_epi64_mask (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_testn_epi32_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_testn_epi32_mask (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_testn_epi64_mask (__m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_testn_epi64_mask (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpackhi_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpackhi_epi32 (__m512i __W, __mmask16 __U, __m512i __A,
__m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpackhi_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpackhi_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpackhi_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpackhi_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpacklo_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpacklo_epi32 (__m512i __W, __mmask16 __U, __m512i __A,
__m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpacklo_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpacklo_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpacklo_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpacklo_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
#define _mm_cvt_roundss_u64(A,B) ((unsigned long long)__builtin_ia32_vcvtss2usi64(A, B))
#define _mm_cvt_roundss_si64(A,B) ((long long)__builtin_ia32_vcvtss2si64(A, B))
#define _mm_cvt_roundss_i64(A,B) ((long long)__builtin_ia32_vcvtss2si64(A, B))
#define _mm_cvtt_roundss_u64(A,B) ((unsigned long long)__builtin_ia32_vcvttss2usi64(A, B))
#define _mm_cvtt_roundss_i64(A,B) ((long long)__builtin_ia32_vcvttss2si64(A, B))
#define _mm_cvtt_roundss_si64(A,B) ((long long)__builtin_ia32_vcvttss2si64(A, B))
#define _mm_cvt_roundss_u32(A,B) ((unsigned)__builtin_ia32_vcvtss2usi32(A, B))
#define _mm_cvt_roundss_si32(A,B) ((int)__builtin_ia32_vcvtss2si32(A, B))
#define _mm_cvt_roundss_i32(A,B) ((int)__builtin_ia32_vcvtss2si32(A, B))
#define _mm_cvtt_roundss_u32(A,B) ((unsigned)__builtin_ia32_vcvttss2usi32(A, B))
#define _mm_cvtt_roundss_si32(A,B) ((int)__builtin_ia32_vcvttss2si32(A, B))
#define _mm_cvtt_roundss_i32(A,B) ((int)__builtin_ia32_vcvttss2si32(A, B))
#define _mm_cvt_roundsd_u64(A,B) ((unsigned long long)__builtin_ia32_vcvtsd2usi64(A, B))
#define _mm_cvt_roundsd_si64(A,B) ((long long)__builtin_ia32_vcvtsd2si64(A, B))
#define _mm_cvt_roundsd_i64(A,B) ((long long)__builtin_ia32_vcvtsd2si64(A, B))
#define _mm_cvtt_roundsd_u64(A,B) ((unsigned long long)__builtin_ia32_vcvttsd2usi64(A, B))
#define _mm_cvtt_roundsd_si64(A,B) ((long long)__builtin_ia32_vcvttsd2si64(A, B))
#define _mm_cvtt_roundsd_i64(A,B) ((long long)__builtin_ia32_vcvttsd2si64(A, B))
#define _mm_cvt_roundsd_u32(A,B) ((unsigned)__builtin_ia32_vcvtsd2usi32(A, B))
#define _mm_cvt_roundsd_si32(A,B) ((int)__builtin_ia32_vcvtsd2si32(A, B))
#define _mm_cvt_roundsd_i32(A,B) ((int)__builtin_ia32_vcvtsd2si32(A, B))
#define _mm_cvtt_roundsd_u32(A,B) ((unsigned)__builtin_ia32_vcvttsd2usi32(A, B))
#define _mm_cvtt_roundsd_si32(A,B) ((int)__builtin_ia32_vcvttsd2si32(A, B))
#define _mm_cvtt_roundsd_i32(A,B) ((int)__builtin_ia32_vcvttsd2si32(A, B))
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_movedup_pd (__m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_movedup_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_movedup_pd (__mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpacklo_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpacklo_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpacklo_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpackhi_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpackhi_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpackhi_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpackhi_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpackhi_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpackhi_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
#define _mm512_cvt_roundps_pd(A,B) (__m512d)__builtin_ia32_cvtps2pd512_mask(A, (__v8df)_mm512_undefined_pd(), -1, B)
#define _mm512_mask_cvt_roundps_pd(W,U,A,B) (__m512d)__builtin_ia32_cvtps2pd512_mask(A, (__v8df)(W), U, B)
#define _mm512_maskz_cvt_roundps_pd(U,A,B) (__m512d)__builtin_ia32_cvtps2pd512_mask(A, (__v8df)_mm512_setzero_pd(), U, B)
#define _mm512_cvt_roundph_ps(A,B) (__m512)__builtin_ia32_vcvtph2ps512_mask((__v16hi)(A), (__v16sf)_mm512_undefined_ps(), -1, B)
#define _mm512_mask_cvt_roundph_ps(W,U,A,B) (__m512)__builtin_ia32_vcvtph2ps512_mask((__v16hi)(A), (__v16sf)(W), U, B)
#define _mm512_maskz_cvt_roundph_ps(U,A,B) (__m512)__builtin_ia32_vcvtph2ps512_mask((__v16hi)(A), (__v16sf)_mm512_setzero_ps(), U, B)
#define _mm512_cvt_roundps_ph(A,I) ((__m256i) __builtin_ia32_vcvtps2ph512_mask ((__v16sf)(__m512) A, (int) (I), (__v16hi)_mm256_undefined_si256 (), -1))
#define _mm512_cvtps_ph(A,I) ((__m256i) __builtin_ia32_vcvtps2ph512_mask ((__v16sf)(__m512) A, (int) (I), (__v16hi)_mm256_undefined_si256 (), -1))
#define _mm512_mask_cvt_roundps_ph(U,W,A,I) ((__m256i) __builtin_ia32_vcvtps2ph512_mask ((__v16sf)(__m512) A, (int) (I), (__v16hi)(__m256i)(U), (__mmask16) (W)))
#define _mm512_mask_cvtps_ph(U,W,A,I) ((__m256i) __builtin_ia32_vcvtps2ph512_mask ((__v16sf)(__m512) A, (int) (I), (__v16hi)(__m256i)(U), (__mmask16) (W)))
#define _mm512_maskz_cvt_roundps_ph(W,A,I) ((__m256i) __builtin_ia32_vcvtps2ph512_mask ((__v16sf)(__m512) A, (int) (I), (__v16hi)_mm256_setzero_si256 (), (__mmask16) (W)))
#define _mm512_maskz_cvtps_ph(W,A,I) ((__m256i) __builtin_ia32_vcvtps2ph512_mask ((__v16sf)(__m512) A, (int) (I), (__v16hi)_mm256_setzero_si256 (), (__mmask16) (W)))
#define _mm512_cvt_roundpd_ps(A,B) (__m256)__builtin_ia32_cvtpd2ps512_mask(A, (__v8sf)_mm256_undefined_ps(), -1, B)
#define _mm512_mask_cvt_roundpd_ps(W,U,A,B) (__m256)__builtin_ia32_cvtpd2ps512_mask(A, (__v8sf)(W), U, B)
#define _mm512_maskz_cvt_roundpd_ps(U,A,B) (__m256)__builtin_ia32_cvtpd2ps512_mask(A, (__v8sf)_mm256_setzero_ps(), U, B)
#define _mm_cvt_roundsd_ss(A,B,C) (__m128)__builtin_ia32_cvtsd2ss_round(A, B, C)
#define _mm_cvt_roundss_sd(A,B,C) (__m128d)__builtin_ia32_cvtss2sd_round(A, B, C)
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_stream_si512 (__m512i * __P, __m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_stream_ps (float *__P, __m512 __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_stream_pd (double *__P, __m512d __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_stream_load_si512 (void *__P)
;
typedef enum
{
_MM_MANT_NORM_1_2,
_MM_MANT_NORM_p5_2,
_MM_MANT_NORM_p5_1,
_MM_MANT_NORM_p75_1p5
} _MM_MANTISSA_NORM_ENUM;
typedef enum
{
_MM_MANT_SIGN_src,
_MM_MANT_SIGN_zero,
_MM_MANT_SIGN_nan
} _MM_MANTISSA_SIGN_ENUM;
#define _mm512_getmant_round_pd(X,B,C,R) ((__m512d)__builtin_ia32_getmantpd512_mask ((__v8df)(__m512d)(X), (int)(((C)<<2) | (B)), (__v8df)(__m512d)_mm512_undefined_pd(), (__mmask8)-1, (R)))
#define _mm512_mask_getmant_round_pd(W,U,X,B,C,R) ((__m512d)__builtin_ia32_getmantpd512_mask ((__v8df)(__m512d)(X), (int)(((C)<<2) | (B)), (__v8df)(__m512d)(W), (__mmask8)(U), (R)))
#define _mm512_maskz_getmant_round_pd(U,X,B,C,R) ((__m512d)__builtin_ia32_getmantpd512_mask ((__v8df)(__m512d)(X), (int)(((C)<<2) | (B)), (__v8df)(__m512d)_mm512_setzero_pd(), (__mmask8)(U), (R)))
#define _mm512_getmant_round_ps(X,B,C,R) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)(__m512)_mm512_undefined_ps(), (__mmask16)-1, (R)))
#define _mm512_mask_getmant_round_ps(W,U,X,B,C,R) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)(__m512)(W), (__mmask16)(U), (R)))
#define _mm512_maskz_getmant_round_ps(U,X,B,C,R) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)(__m512)_mm512_setzero_ps(), (__mmask16)(U), (R)))
#define _mm_getmant_round_sd(X,Y,C,D,R) ((__m128d)__builtin_ia32_getmantsd_round ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(((D)<<2) | (C)), (R)))
#define _mm_getmant_round_ss(X,Y,C,D,R) ((__m128)__builtin_ia32_getmantss_round ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(((D)<<2) | (C)), (R)))
#define _mm_getexp_round_ss(A,B,R) ((__m128)__builtin_ia32_getexpss128_round((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), R))
#define _mm_getexp_round_sd(A,B,R) ((__m128d)__builtin_ia32_getexpsd128_round((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), R))
#define _mm512_getexp_round_ps(A,R) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)_mm512_undefined_ps(), (__mmask16)-1, R))
#define _mm512_mask_getexp_round_ps(W,U,A,R) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)(__m512)(W), (__mmask16)(U), R))
#define _mm512_maskz_getexp_round_ps(U,A,R) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)_mm512_setzero_ps(), (__mmask16)(U), R))
#define _mm512_getexp_round_pd(A,R) ((__m512d)__builtin_ia32_getexppd512_mask((__v8df)(__m512d)(A), (__v8df)_mm512_undefined_pd(), (__mmask8)-1, R))
#define _mm512_mask_getexp_round_pd(W,U,A,R) ((__m512d)__builtin_ia32_getexppd512_mask((__v8df)(__m512d)(A), (__v8df)(__m512d)(W), (__mmask8)(U), R))
#define _mm512_maskz_getexp_round_pd(U,A,R) ((__m512d)__builtin_ia32_getexppd512_mask((__v8df)(__m512d)(A), (__v8df)_mm512_setzero_pd(), (__mmask8)(U), R))
#define _mm512_roundscale_round_ps(A,B,R) ((__m512) __builtin_ia32_rndscaleps_mask ((__v16sf)(__m512)(A), (int)(B), (__v16sf)_mm512_undefined_ps(), (__mmask16)(-1), R))
#define _mm512_mask_roundscale_round_ps(A,B,C,D,R) ((__m512) __builtin_ia32_rndscaleps_mask ((__v16sf)(__m512)(C), (int)(D), (__v16sf)(__m512)(A), (__mmask16)(B), R))
#define _mm512_maskz_roundscale_round_ps(A,B,C,R) ((__m512) __builtin_ia32_rndscaleps_mask ((__v16sf)(__m512)(B), (int)(C), (__v16sf)_mm512_setzero_ps(), (__mmask16)(A), R))
#define _mm512_roundscale_round_pd(A,B,R) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(A), (int)(B), (__v8df)_mm512_undefined_pd(), (__mmask8)(-1), R))
#define _mm512_mask_roundscale_round_pd(A,B,C,D,R) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(C), (int)(D), (__v8df)(__m512d)(A), (__mmask8)(B), R))
#define _mm512_maskz_roundscale_round_pd(A,B,C,R) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(B), (int)(C), (__v8df)_mm512_setzero_pd(), (__mmask8)(A), R))
#define _mm_roundscale_round_ss(A,B,C,R) ((__m128) __builtin_ia32_rndscaless_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), R))
#define _mm_roundscale_round_sd(A,B,C,R) ((__m128d) __builtin_ia32_rndscalesd_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), R))
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_floor_ps (__m512 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_floor_pd (__m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_ceil_ps (__m512 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_ceil_pd (__m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_floor_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_floor_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_ceil_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_ceil_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
#define _mm512_alignr_epi32(X,Y,C) ((__m512i)__builtin_ia32_alignd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(C), (__v16si)_mm512_undefined_si512 (), (__mmask16)-1))
#define _mm512_mask_alignr_epi32(W,U,X,Y,C) ((__m512i)__builtin_ia32_alignd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_alignr_epi32(U,X,Y,C) ((__m512i)__builtin_ia32_alignd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(C), (__v16si)_mm512_setzero_si512 (), (__mmask16)(U)))
#define _mm512_alignr_epi64(X,Y,C) ((__m512i)__builtin_ia32_alignq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(C), (__v8di)_mm512_undefined_si512 (), (__mmask8)-1))
#define _mm512_mask_alignr_epi64(W,U,X,Y,C) ((__m512i)__builtin_ia32_alignq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(C), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_alignr_epi64(U,X,Y,C) ((__m512i)__builtin_ia32_alignq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(C), (__v8di)_mm512_setzero_si512 (), (__mmask8)(U)))
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpeq_epi32_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpeq_epi32_mask (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpeq_epi64_mask (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpeq_epi64_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpgt_epi32_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpgt_epi32_mask (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpgt_epi64_mask (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpgt_epi64_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpge_epi32_mask (__m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpge_epi32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpge_epu32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpge_epu32_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpge_epi64_mask (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpge_epi64_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpge_epu64_mask (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpge_epu64_mask (__m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmple_epi32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmple_epi32_mask (__m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmple_epu32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmple_epu32_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmple_epi64_mask (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmple_epi64_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmple_epu64_mask (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmple_epu64_mask (__m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmplt_epi32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmplt_epi32_mask (__m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmplt_epu32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmplt_epu32_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmplt_epi64_mask (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmplt_epi64_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmplt_epu64_mask (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmplt_epu64_mask (__m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpneq_epi32_mask (__m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpneq_epi32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpneq_epu32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpneq_epu32_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpneq_epi64_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpneq_epi64_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpneq_epu64_mask (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpneq_epu64_mask (__m512i __X, __m512i __Y)
;
#define _MM_CMPINT_EQ 0x0
#define _MM_CMPINT_LT 0x1
#define _MM_CMPINT_LE 0x2
#define _MM_CMPINT_UNUSED 0x3
#define _MM_CMPINT_NE 0x4
#define _MM_CMPINT_NLT 0x5
#define _MM_CMPINT_GE 0x5
#define _MM_CMPINT_NLE 0x6
#define _MM_CMPINT_GT 0x6
#define _mm512_cmp_epi64_mask(X,Y,P) ((__mmask8) __builtin_ia32_cmpq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(P), (__mmask8)-1))
#define _mm512_cmp_epi32_mask(X,Y,P) ((__mmask8) __builtin_ia32_cmpd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(P), (__mmask16)-1))
#define _mm512_cmp_epu64_mask(X,Y,P) ((__mmask8) __builtin_ia32_ucmpq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(P), (__mmask8)-1))
#define _mm512_cmp_epu32_mask(X,Y,P) ((__mmask8) __builtin_ia32_ucmpd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(P), (__mmask16)-1))
#define _mm512_cmp_round_pd_mask(X,Y,P,R) ((__mmask8) __builtin_ia32_cmppd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(P), (__mmask8)-1, R))
#define _mm512_cmp_round_ps_mask(X,Y,P,R) ((__mmask16) __builtin_ia32_cmpps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(P), (__mmask16)-1, R))
#define _mm512_mask_cmp_epi64_mask(M,X,Y,P) ((__mmask8) __builtin_ia32_cmpq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(P), (__mmask8)M))
#define _mm512_mask_cmp_epi32_mask(M,X,Y,P) ((__mmask8) __builtin_ia32_cmpd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(P), (__mmask16)M))
#define _mm512_mask_cmp_epu64_mask(M,X,Y,P) ((__mmask8) __builtin_ia32_ucmpq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(P), (__mmask8)M))
#define _mm512_mask_cmp_epu32_mask(M,X,Y,P) ((__mmask8) __builtin_ia32_ucmpd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(P), (__mmask16)M))
#define _mm512_mask_cmp_round_pd_mask(M,X,Y,P,R) ((__mmask8) __builtin_ia32_cmppd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(P), (__mmask8)M, R))
#define _mm512_mask_cmp_round_ps_mask(M,X,Y,P,R) ((__mmask16) __builtin_ia32_cmpps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(P), (__mmask16)M, R))
#define _mm_cmp_round_sd_mask(X,Y,P,R) ((__mmask8) __builtin_ia32_cmpsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P), (__mmask8)-1, R))
#define _mm_mask_cmp_round_sd_mask(M,X,Y,P,R) ((__mmask8) __builtin_ia32_cmpsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P), (M), R))
#define _mm_cmp_round_ss_mask(X,Y,P,R) ((__mmask8) __builtin_ia32_cmpss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P), (__mmask8)-1, R))
#define _mm_mask_cmp_round_ss_mask(M,X,Y,P,R) ((__mmask8) __builtin_ia32_cmpss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P), (M), R))
#define _mm512_i32gather_ps(INDEX,ADDR,SCALE) (__m512) __builtin_ia32_gathersiv16sf ((__v16sf)_mm512_undefined_ps(), (float const *)ADDR, (__v16si)(__m512i)INDEX, (__mmask16)0xFFFF, (int)SCALE)
#define _mm512_mask_i32gather_ps(V1OLD,MASK,INDEX,ADDR,SCALE) (__m512) __builtin_ia32_gathersiv16sf ((__v16sf)(__m512)V1OLD, (float const *)ADDR, (__v16si)(__m512i)INDEX, (__mmask16)MASK, (int)SCALE)
#define _mm512_i32gather_pd(INDEX,ADDR,SCALE) (__m512d) __builtin_ia32_gathersiv8df ((__v8df)_mm512_undefined_pd(), (double const *)ADDR, (__v8si)(__m256i)INDEX, (__mmask8)0xFF, (int)SCALE)
#define _mm512_mask_i32gather_pd(V1OLD,MASK,INDEX,ADDR,SCALE) (__m512d) __builtin_ia32_gathersiv8df ((__v8df)(__m512d)V1OLD, (double const *)ADDR, (__v8si)(__m256i)INDEX, (__mmask8)MASK, (int)SCALE)
#define _mm512_i64gather_ps(INDEX,ADDR,SCALE) (__m256) __builtin_ia32_gatherdiv16sf ((__v8sf)_mm256_undefined_ps(), (float const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)0xFF, (int)SCALE)
#define _mm512_mask_i64gather_ps(V1OLD,MASK,INDEX,ADDR,SCALE) (__m256) __builtin_ia32_gatherdiv16sf ((__v8sf)(__m256)V1OLD, (float const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)MASK, (int)SCALE)
#define _mm512_i64gather_pd(INDEX,ADDR,SCALE) (__m512d) __builtin_ia32_gatherdiv8df ((__v8df)_mm512_undefined_pd(), (double const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)0xFF, (int)SCALE)
#define _mm512_mask_i64gather_pd(V1OLD,MASK,INDEX,ADDR,SCALE) (__m512d) __builtin_ia32_gatherdiv8df ((__v8df)(__m512d)V1OLD, (double const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)MASK, (int)SCALE)
#define _mm512_i32gather_epi32(INDEX,ADDR,SCALE) (__m512i) __builtin_ia32_gathersiv16si ((__v16si)_mm512_undefined_si512 (), (int const *)ADDR, (__v16si)(__m512i)INDEX, (__mmask16)0xFFFF, (int)SCALE)
#define _mm512_mask_i32gather_epi32(V1OLD,MASK,INDEX,ADDR,SCALE) (__m512i) __builtin_ia32_gathersiv16si ((__v16si)(__m512i)V1OLD, (int const *)ADDR, (__v16si)(__m512i)INDEX, (__mmask16)MASK, (int)SCALE)
#define _mm512_i32gather_epi64(INDEX,ADDR,SCALE) (__m512i) __builtin_ia32_gathersiv8di ((__v8di)_mm512_undefined_si512 (), (long long const *)ADDR, (__v8si)(__m256i)INDEX, (__mmask8)0xFF, (int)SCALE)
#define _mm512_mask_i32gather_epi64(V1OLD,MASK,INDEX,ADDR,SCALE) (__m512i) __builtin_ia32_gathersiv8di ((__v8di)(__m512i)V1OLD, (long long const *)ADDR, (__v8si)(__m256i)INDEX, (__mmask8)MASK, (int)SCALE)
#define _mm512_i64gather_epi32(INDEX,ADDR,SCALE) (__m256i) __builtin_ia32_gatherdiv16si ((__v8si)_mm256_undefined_si256(), (int const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)0xFF, (int)SCALE)
#define _mm512_mask_i64gather_epi32(V1OLD,MASK,INDEX,ADDR,SCALE) (__m256i) __builtin_ia32_gatherdiv16si ((__v8si)(__m256i)V1OLD, (int const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)MASK, (int)SCALE)
#define _mm512_i64gather_epi64(INDEX,ADDR,SCALE) (__m512i) __builtin_ia32_gatherdiv8di ((__v8di)_mm512_undefined_si512 (), (long long const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)0xFF, (int)SCALE)
#define _mm512_mask_i64gather_epi64(V1OLD,MASK,INDEX,ADDR,SCALE) (__m512i) __builtin_ia32_gatherdiv8di ((__v8di)(__m512i)V1OLD, (long long const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)MASK, (int)SCALE)
#define _mm512_i32scatter_ps(ADDR,INDEX,V1,SCALE) __builtin_ia32_scattersiv16sf ((float *)ADDR, (__mmask16)0xFFFF, (__v16si)(__m512i)INDEX, (__v16sf)(__m512)V1, (int)SCALE)
#define _mm512_mask_i32scatter_ps(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scattersiv16sf ((float *)ADDR, (__mmask16)MASK, (__v16si)(__m512i)INDEX, (__v16sf)(__m512)V1, (int)SCALE)
#define _mm512_i32scatter_pd(ADDR,INDEX,V1,SCALE) __builtin_ia32_scattersiv8df ((double *)ADDR, (__mmask8)0xFF, (__v8si)(__m256i)INDEX, (__v8df)(__m512d)V1, (int)SCALE)
#define _mm512_mask_i32scatter_pd(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scattersiv8df ((double *)ADDR, (__mmask8)MASK, (__v8si)(__m256i)INDEX, (__v8df)(__m512d)V1, (int)SCALE)
#define _mm512_i64scatter_ps(ADDR,INDEX,V1,SCALE) __builtin_ia32_scatterdiv16sf ((float *)ADDR, (__mmask8)0xFF, (__v8di)(__m512i)INDEX, (__v8sf)(__m256)V1, (int)SCALE)
#define _mm512_mask_i64scatter_ps(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scatterdiv16sf ((float *)ADDR, (__mmask16)MASK, (__v8di)(__m512i)INDEX, (__v8sf)(__m256)V1, (int)SCALE)
#define _mm512_i64scatter_pd(ADDR,INDEX,V1,SCALE) __builtin_ia32_scatterdiv8df ((double *)ADDR, (__mmask8)0xFF, (__v8di)(__m512i)INDEX, (__v8df)(__m512d)V1, (int)SCALE)
#define _mm512_mask_i64scatter_pd(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scatterdiv8df ((double *)ADDR, (__mmask8)MASK, (__v8di)(__m512i)INDEX, (__v8df)(__m512d)V1, (int)SCALE)
#define _mm512_i32scatter_epi32(ADDR,INDEX,V1,SCALE) __builtin_ia32_scattersiv16si ((int *)ADDR, (__mmask16)0xFFFF, (__v16si)(__m512i)INDEX, (__v16si)(__m512i)V1, (int)SCALE)
#define _mm512_mask_i32scatter_epi32(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scattersiv16si ((int *)ADDR, (__mmask16)MASK, (__v16si)(__m512i)INDEX, (__v16si)(__m512i)V1, (int)SCALE)
#define _mm512_i32scatter_epi64(ADDR,INDEX,V1,SCALE) __builtin_ia32_scattersiv8di ((long long *)ADDR, (__mmask8)0xFF, (__v8si)(__m256i)INDEX, (__v8di)(__m512i)V1, (int)SCALE)
#define _mm512_mask_i32scatter_epi64(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scattersiv8di ((long long *)ADDR, (__mmask8)MASK, (__v8si)(__m256i)INDEX, (__v8di)(__m512i)V1, (int)SCALE)
#define _mm512_i64scatter_epi32(ADDR,INDEX,V1,SCALE) __builtin_ia32_scatterdiv16si ((int *)ADDR, (__mmask8)0xFF, (__v8di)(__m512i)INDEX, (__v8si)(__m256i)V1, (int)SCALE)
#define _mm512_mask_i64scatter_epi32(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scatterdiv16si ((int *)ADDR, (__mmask8)MASK, (__v8di)(__m512i)INDEX, (__v8si)(__m256i)V1, (int)SCALE)
#define _mm512_i64scatter_epi64(ADDR,INDEX,V1,SCALE) __builtin_ia32_scatterdiv8di ((long long *)ADDR, (__mmask8)0xFF, (__v8di)(__m512i)INDEX, (__v8di)(__m512i)V1, (int)SCALE)
#define _mm512_mask_i64scatter_epi64(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scatterdiv8di ((long long *)ADDR, (__mmask8)MASK, (__v8di)(__m512i)INDEX, (__v8di)(__m512i)V1, (int)SCALE)
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compress_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_compress_pd (__mmask8 __U, __m512d __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compressstoreu_pd (void *__P, __mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compress_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_compress_ps (__mmask16 __U, __m512 __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compressstoreu_ps (void *__P, __mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compress_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_compress_epi64 (__mmask8 __U, __m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compressstoreu_epi64 (void *__P, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compress_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_compress_epi32 (__mmask16 __U, __m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compressstoreu_epi32 (void *__P, __mmask16 __U, __m512i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expand_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expand_pd (__mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expandloadu_pd (__m512d __W, __mmask8 __U, void const *__P)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expandloadu_pd (__mmask8 __U, void const *__P)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expand_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expand_ps (__mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expandloadu_ps (__m512 __W, __mmask16 __U, void const *__P)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expandloadu_ps (__mmask16 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expand_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expand_epi64 (__mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expandloadu_epi64 (__m512i __W, __mmask8 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expandloadu_epi64 (__mmask8 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expand_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expand_epi32 (__mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expandloadu_epi32 (__m512i __W, __mmask16 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expandloadu_epi32 (__mmask16 __U, void const *__P)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kand (__mmask16 __A, __mmask16 __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kandn (__mmask16 __A, __mmask16 __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kor (__mmask16 __A, __mmask16 __B)
;
extern int
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kortestz (__mmask16 __A, __mmask16 __B)
;
extern int
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kortestc (__mmask16 __A, __mmask16 __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kxnor (__mmask16 __A, __mmask16 __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kxor (__mmask16 __A, __mmask16 __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_knot (__mmask16 __A)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kunpackb (__mmask16 __A, __mmask16 __B)
;
#define _mm512_maskz_insertf32x4(A,X,Y,C) ((__m512) __builtin_ia32_insertf32x4_mask ((__v16sf)(__m512) (X), (__v4sf)(__m128) (Y), (int) (C), (__v16sf)_mm512_setzero_ps(), (__mmask8)(A)))
#define _mm512_maskz_inserti32x4(A,X,Y,C) ((__m512i) __builtin_ia32_inserti32x4_mask ((__v16si)(__m512i) (X), (__v4si)(__m128i) (Y), (int) (C), (__v16si)_mm512_setzero_si512 (), (__mmask8)(A)))
#define _mm512_mask_insertf32x4(A,B,X,Y,C) ((__m512) __builtin_ia32_insertf32x4_mask ((__v16sf)(__m512) (X), (__v4sf)(__m128) (Y), (int) (C), (__v16sf)(__m512) (A), (__mmask8)(B)))
#define _mm512_mask_inserti32x4(A,B,X,Y,C) ((__m512i) __builtin_ia32_inserti32x4_mask ((__v16si)(__m512i) (X), (__v4si)(__m128i) (Y), (int) (C), (__v16si)(__m512i) (A), (__mmask8)(B)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_max_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_max_epi64 (__mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_max_epi64 (__m512i __W, __mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_min_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_min_epi64 (__m512i __W, __mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_min_epi64 (__mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_max_epu64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_max_epu64 (__mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_max_epu64 (__m512i __W, __mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_min_epu64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_min_epu64 (__m512i __W, __mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_min_epu64 (__mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_max_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_max_epi32 (__mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_max_epi32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_min_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_min_epi32 (__mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_min_epi32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_max_epu32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_max_epu32 (__mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_max_epu32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_min_epu32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_min_epu32 (__mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_min_epu32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpacklo_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpacklo_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpacklo_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
#define _mm_max_round_sd(A,B,C) (__m128d)__builtin_ia32_addsd_round(A, B, C)
#define _mm_max_round_ss(A,B,C) (__m128)__builtin_ia32_addss_round(A, B, C)
#define _mm_min_round_sd(A,B,C) (__m128d)__builtin_ia32_subsd_round(A, B, C)
#define _mm_min_round_ss(A,B,C) (__m128)__builtin_ia32_subss_round(A, B, C)
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_blend_pd (__mmask8 __U, __m512d __A, __m512d __W)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_blend_ps (__mmask16 __U, __m512 __A, __m512 __W)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_blend_epi64 (__mmask8 __U, __m512i __A, __m512i __W)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_blend_epi32 (__mmask16 __U, __m512i __A, __m512i __W)
;
#define _mm_fmadd_round_sd(A,B,C,R) (__m128d)__builtin_ia32_vfmaddsd3_round(A, B, C, R)
#define _mm_fmadd_round_ss(A,B,C,R) (__m128)__builtin_ia32_vfmaddss3_round(A, B, C, R)
#define _mm_fmsub_round_sd(A,B,C,R) (__m128d)__builtin_ia32_vfmaddsd3_round(A, B, -(C), R)
#define _mm_fmsub_round_ss(A,B,C,R) (__m128)__builtin_ia32_vfmaddss3_round(A, B, -(C), R)
#define _mm_fnmadd_round_sd(A,B,C,R) (__m128d)__builtin_ia32_vfmaddsd3_round(A, -(B), C, R)
#define _mm_fnmadd_round_ss(A,B,C,R) (__m128)__builtin_ia32_vfmaddss3_round(A, -(B), C, R)
#define _mm_fnmsub_round_sd(A,B,C,R) (__m128d)__builtin_ia32_vfmaddsd3_round(A, -(B), -(C), R)
#define _mm_fnmsub_round_ss(A,B,C,R) (__m128)__builtin_ia32_vfmaddss3_round(A, -(B), -(C), R)
#define _mm_comi_round_ss(A,B,C,D) __builtin_ia32_vcomiss(A, B, C, D)
#define _mm_comi_round_sd(A,B,C,D) __builtin_ia32_vcomisd(A, B, C, D)
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sqrt_pd (__m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sqrt_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sqrt_pd (__mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sqrt_ps (__m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sqrt_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sqrt_ps (__mmask16 __U, __m512 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_add_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_add_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_add_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_add_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_add_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_add_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sub_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sub_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sub_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sub_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sub_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sub_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mul_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mul_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mul_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mul_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mul_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mul_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_div_pd (__m512d __M, __m512d __V)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_div_pd (__m512d __W, __mmask8 __U, __m512d __M, __m512d __V)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_div_pd (__mmask8 __U, __m512d __M, __m512d __V)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_div_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_div_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_div_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_max_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_max_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_max_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_max_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_max_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_max_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_min_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_min_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_min_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_min_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_min_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_min_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_scalef_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_scalef_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_scalef_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_scalef_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_scalef_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_scalef_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
extern __m128d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_scalef_sd (__m128d __A, __m128d __B)
;
extern __m128
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_scalef_ss (__m128 __A, __m128 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmadd_pd (__m512d __A, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmadd_pd (__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmadd_pd (__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmadd_pd (__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmadd_ps (__m512 __A, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmadd_ps (__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmadd_ps (__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmadd_ps (__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmsub_pd (__m512d __A, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmsub_pd (__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmsub_pd (__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmsub_pd (__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmsub_ps (__m512 __A, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmsub_ps (__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmsub_ps (__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmsub_ps (__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmaddsub_pd (__m512d __A, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmaddsub_pd (__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmaddsub_pd (__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmaddsub_pd (__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmaddsub_ps (__m512 __A, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmaddsub_ps (__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmaddsub_ps (__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmaddsub_ps (__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmsubadd_pd (__m512d __A, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmsubadd_pd (__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmsubadd_pd (__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmsubadd_pd (__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmsubadd_ps (__m512 __A, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmsubadd_ps (__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmsubadd_ps (__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmsubadd_ps (__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fnmadd_pd (__m512d __A, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fnmadd_pd (__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fnmadd_pd (__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fnmadd_pd (__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fnmadd_ps (__m512 __A, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fnmadd_ps (__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fnmadd_ps (__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fnmadd_ps (__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fnmsub_pd (__m512d __A, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fnmsub_pd (__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fnmsub_pd (__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fnmsub_pd (__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fnmsub_ps (__m512 __A, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fnmsub_ps (__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fnmsub_ps (__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fnmsub_ps (__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvttpd_epi32 (__m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvttpd_epi32 (__m256i __W, __mmask8 __U, __m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvttpd_epi32 (__mmask8 __U, __m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvttpd_epu32 (__m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvttpd_epu32 (__m256i __W, __mmask8 __U, __m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvttpd_epu32 (__mmask8 __U, __m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtpd_epi32 (__m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtpd_epi32 (__m256i __W, __mmask8 __U, __m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtpd_epi32 (__mmask8 __U, __m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtpd_epu32 (__m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtpd_epu32 (__m256i __W, __mmask8 __U, __m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtpd_epu32 (__mmask8 __U, __m512d __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvttps_epi32 (__m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvttps_epi32 (__m512i __W, __mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvttps_epi32 (__mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvttps_epu32 (__m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvttps_epu32 (__m512i __W, __mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvttps_epu32 (__mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtps_epi32 (__m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtps_epi32 (__m512i __W, __mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtps_epi32 (__mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtps_epu32 (__m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtps_epu32 (__m512i __W, __mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtps_epu32 (__mmask16 __U, __m512 __A)
;
extern __m128
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtu64_ss (__m128 __A, unsigned long long __B)
;
extern __m128d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtu64_sd (__m128d __A, unsigned long long __B)
;
extern __m128
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtu32_ss (__m128 __A, unsigned __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi32_ps (__m512i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi32_ps (__m512 __W, __mmask16 __U, __m512i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi32_ps (__mmask16 __U, __m512i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepu32_ps (__m512i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepu32_ps (__m512 __W, __mmask16 __U, __m512i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepu32_ps (__mmask16 __U, __m512i __A)
;
#define _mm512_fixupimm_pd(X,Y,Z,C) ((__m512d)__builtin_ia32_fixupimmpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (__v8di)(__m512i)(Z), (int)(C), (__mmask8)(-1), _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_fixupimm_pd(X,U,Y,Z,C) ((__m512d)__builtin_ia32_fixupimmpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (__v8di)(__m512i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_fixupimm_pd(U,X,Y,Z,C) ((__m512d)__builtin_ia32_fixupimmpd512_maskz ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (__v8di)(__m512i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_fixupimm_ps(X,Y,Z,C) ((__m512)__builtin_ia32_fixupimmps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(-1), _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_fixupimm_ps(X,U,Y,Z,C) ((__m512)__builtin_ia32_fixupimmps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_fixupimm_ps(U,X,Y,Z,C) ((__m512)__builtin_ia32_fixupimmps512_maskz ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm_fixupimm_sd(X,Y,Z,C) ((__m128d)__builtin_ia32_fixupimmsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(-1), _MM_FROUND_CUR_DIRECTION))
#define _mm_mask_fixupimm_sd(X,U,Y,Z,C) ((__m128d)__builtin_ia32_fixupimmsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm_maskz_fixupimm_sd(U,X,Y,Z,C) ((__m128d)__builtin_ia32_fixupimmsd_maskz ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm_fixupimm_ss(X,Y,Z,C) ((__m128)__builtin_ia32_fixupimmss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(-1), _MM_FROUND_CUR_DIRECTION))
#define _mm_mask_fixupimm_ss(X,U,Y,Z,C) ((__m128)__builtin_ia32_fixupimmss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm_maskz_fixupimm_ss(U,X,Y,Z,C) ((__m128)__builtin_ia32_fixupimmss_maskz ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
extern unsigned long long
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_u64 (__m128 __A)
;
extern unsigned long long
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_u64 (__m128 __A)
;
extern long long
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_i64 (__m128 __A)
;
extern unsigned
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_u32 (__m128 __A)
;
extern unsigned
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_u32 (__m128 __A)
;
extern int
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_i32 (__m128 __A)
;
extern unsigned long long
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_u64 (__m128d __A)
;
extern unsigned long long
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_u64 (__m128d __A)
;
extern long long
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_i64 (__m128d __A)
;
extern unsigned
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_u32 (__m128d __A)
;
extern unsigned
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_u32 (__m128d __A)
;
extern int
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_i32 (__m128d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtps_pd (__m256 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtps_pd (__m512d __W, __mmask8 __U, __m256 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtps_pd (__mmask8 __U, __m256 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtph_ps (__m256i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtph_ps (__m512 __W, __mmask16 __U, __m256i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtph_ps (__mmask16 __U, __m256i __A)
;
extern __m256
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtpd_ps (__m512d __A)
;
extern __m256
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtpd_ps (__m256 __W, __mmask8 __U, __m512d __A)
;
extern __m256
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtpd_ps (__mmask8 __U, __m512d __A)
;
#define _mm512_getmant_pd(X,B,C) ((__m512d)__builtin_ia32_getmantpd512_mask ((__v8df)(__m512d)(X), (int)(((C)<<2) | (B)), (__v8df)_mm512_undefined_pd(), (__mmask8)-1, _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_getmant_pd(W,U,X,B,C) ((__m512d)__builtin_ia32_getmantpd512_mask ((__v8df)(__m512d)(X), (int)(((C)<<2) | (B)), (__v8df)(__m512d)(W), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_getmant_pd(U,X,B,C) ((__m512d)__builtin_ia32_getmantpd512_mask ((__v8df)(__m512d)(X), (int)(((C)<<2) | (B)), (__v8df)_mm512_setzero_pd(), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_getmant_ps(X,B,C) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)_mm512_undefined_ps(), (__mmask16)-1, _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_getmant_ps(W,U,X,B,C) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)(__m512)(W), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_getmant_ps(U,X,B,C) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)_mm512_setzero_ps(), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm_getmant_sd(X,Y,C,D) ((__m128d)__builtin_ia32_getmantsd_round ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(((D)<<2) | (C)), _MM_FROUND_CUR_DIRECTION))
#define _mm_getmant_ss(X,Y,C,D) ((__m128)__builtin_ia32_getmantss_round ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(((D)<<2) | (C)), _MM_FROUND_CUR_DIRECTION))
#define _mm_getexp_ss(A,B) ((__m128)__builtin_ia32_getexpss128_mask((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), _MM_FROUND_CUR_DIRECTION))
#define _mm_getexp_sd(A,B) ((__m128d)__builtin_ia32_getexpsd128_mask((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), _MM_FROUND_CUR_DIRECTION))
#define _mm512_getexp_ps(A) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)_mm512_undefined_ps(), (__mmask16)-1, _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_getexp_ps(W,U,A) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)(__m512)(W), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_getexp_ps(U,A) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)_mm512_setzero_ps(), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_getexp_pd(A) ((__m512d)__builtin_ia32_getexppd512_mask((__v8df)(__m512d)(A), (__v8df)_mm512_undefined_pd(), (__mmask8)-1, _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_getexp_pd(W,U,A) ((__m512d)__builtin_ia32_getexppd512_mask((__v8df)(__m512d)(A), (__v8df)(__m512d)(W), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_getexp_pd(U,A) ((__m512d)__builtin_ia32_getexppd512_mask((__v8df)(__m512d)(A), (__v8df)_mm512_setzero_pd(), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_roundscale_ps(A,B) ((__m512) __builtin_ia32_rndscaleps_mask ((__v16sf)(__m512)(A), (int)(B), (__v16sf)_mm512_undefined_ps(), (__mmask16)(-1), _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_roundscale_ps(A,B,C,D) ((__m512) __builtin_ia32_rndscaleps_mask ((__v16sf)(__m512)(C), (int)(D), (__v16sf)(__m512)(A), (__mmask16)(B), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_roundscale_ps(A,B,C) ((__m512) __builtin_ia32_rndscaleps_mask ((__v16sf)(__m512)(B), (int)(C), (__v16sf)_mm512_setzero_ps(), (__mmask16)(A), _MM_FROUND_CUR_DIRECTION))
#define _mm512_roundscale_pd(A,B) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(A), (int)(B), (__v8df)_mm512_undefined_pd(), (__mmask8)(-1), _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_roundscale_pd(A,B,C,D) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(C), (int)(D), (__v8df)(__m512d)(A), (__mmask8)(B), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_roundscale_pd(A,B,C) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(B), (int)(C), (__v8df)_mm512_setzero_pd(), (__mmask8)(A), _MM_FROUND_CUR_DIRECTION))
#define _mm_roundscale_ss(A,B,C) ((__m128) __builtin_ia32_rndscaless_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), _MM_FROUND_CUR_DIRECTION))
#define _mm_roundscale_sd(A,B,C) ((__m128d) __builtin_ia32_rndscalesd_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), _MM_FROUND_CUR_DIRECTION))
#define _mm512_cmp_pd_mask(X,Y,P) ((__mmask8) __builtin_ia32_cmppd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(P), (__mmask8)-1,_MM_FROUND_CUR_DIRECTION))
#define _mm512_cmp_ps_mask(X,Y,P) ((__mmask16) __builtin_ia32_cmpps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(P), (__mmask16)-1,_MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_cmp_pd_mask(M,X,Y,P) ((__mmask8) __builtin_ia32_cmppd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(P), (__mmask8)M, _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_cmp_ps_mask(M,X,Y,P) ((__mmask16) __builtin_ia32_cmpps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(P), (__mmask16)M,_MM_FROUND_CUR_DIRECTION))
#define _mm_cmp_sd_mask(X,Y,P) ((__mmask8) __builtin_ia32_cmpsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P), (__mmask8)-1,_MM_FROUND_CUR_DIRECTION))
#define _mm_mask_cmp_sd_mask(M,X,Y,P) ((__mmask8) __builtin_ia32_cmpsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P), M,_MM_FROUND_CUR_DIRECTION))
#define _mm_cmp_ss_mask(X,Y,P) ((__mmask8) __builtin_ia32_cmpss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P), (__mmask8)-1,_MM_FROUND_CUR_DIRECTION))
#define _mm_mask_cmp_ss_mask(M,X,Y,P) ((__mmask8) __builtin_ia32_cmpss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P), M,_MM_FROUND_CUR_DIRECTION))
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kmov (__mmask16 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castpd_ps (__m512d __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castpd_si512 (__m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castps_pd (__m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castps_si512 (__m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castsi512_ps (__m512i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castsi512_pd (__m512i __A)
;
extern __m128d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castpd512_pd128 (__m512d __A)
;
extern __m128
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castps512_ps128 (__m512 __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castsi512_si128 (__m512i __A)
;
extern __m256d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castpd512_pd256 (__m512d __A)
;
extern __m256
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castps512_ps256 (__m512 __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castsi512_si256 (__m512i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castpd128_pd512 (__m128d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castps128_ps512 (__m128 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castsi128_si512 (__m128i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castpd256_pd512 (__m256d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castps256_ps512 (__m256 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castsi256_si512 (__m256i __A)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpeq_epu32_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpeq_epu32_mask (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpeq_epu64_mask (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpeq_epu64_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpgt_epu32_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpgt_epu32_mask (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpgt_epu64_mask (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpgt_epu64_mask (__m512i __A, __m512i __B)
;
#undef __DISABLE_AVX512F__
#pragma GCC pop_options
#define _AVX512ERINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("avx512er")
#define __DISABLE_AVX512ER__
typedef double __v8df __attribute__ ((__vector_size__ (64)));
typedef float __v16sf __attribute__ ((__vector_size__ (64)));
typedef float __m512 __attribute__ ((__vector_size__ (64), __may_alias__));
typedef double __m512d __attribute__ ((__vector_size__ (64), __may_alias__));
typedef unsigned char __mmask8;
typedef unsigned short __mmask16;
#define _mm512_exp2a23_round_pd(A,C) __builtin_ia32_exp2pd_mask(A, (__v8df)_mm512_setzero_pd(), -1, C)
#define _mm512_mask_exp2a23_round_pd(W,U,A,C) __builtin_ia32_exp2pd_mask(A, W, U, C)
#define _mm512_maskz_exp2a23_round_pd(U,A,C) __builtin_ia32_exp2pd_mask(A, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_exp2a23_round_ps(A,C) __builtin_ia32_exp2ps_mask(A, (__v16sf)_mm512_setzero_ps(), -1, C)
#define _mm512_mask_exp2a23_round_ps(W,U,A,C) __builtin_ia32_exp2ps_mask(A, W, U, C)
#define _mm512_maskz_exp2a23_round_ps(U,A,C) __builtin_ia32_exp2ps_mask(A, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm512_rcp28_round_pd(A,C) __builtin_ia32_rcp28pd_mask(A, (__v8df)_mm512_setzero_pd(), -1, C)
#define _mm512_mask_rcp28_round_pd(W,U,A,C) __builtin_ia32_rcp28pd_mask(A, W, U, C)
#define _mm512_maskz_rcp28_round_pd(U,A,C) __builtin_ia32_rcp28pd_mask(A, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_rcp28_round_ps(A,C) __builtin_ia32_rcp28ps_mask(A, (__v16sf)_mm512_setzero_ps(), -1, C)
#define _mm512_mask_rcp28_round_ps(W,U,A,C) __builtin_ia32_rcp28ps_mask(A, W, U, C)
#define _mm512_maskz_rcp28_round_ps(U,A,C) __builtin_ia32_rcp28ps_mask(A, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm512_rsqrt28_round_pd(A,C) __builtin_ia32_rsqrt28pd_mask(A, (__v8df)_mm512_setzero_pd(), -1, C)
#define _mm512_mask_rsqrt28_round_pd(W,U,A,C) __builtin_ia32_rsqrt28pd_mask(A, W, U, C)
#define _mm512_maskz_rsqrt28_round_pd(U,A,C) __builtin_ia32_rsqrt28pd_mask(A, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_rsqrt28_round_ps(A,C) __builtin_ia32_rsqrt28ps_mask(A, (__v16sf)_mm512_setzero_ps(), -1, C)
#define _mm512_mask_rsqrt28_round_ps(W,U,A,C) __builtin_ia32_rsqrt28ps_mask(A, W, U, C)
#define _mm512_maskz_rsqrt28_round_ps(U,A,C) __builtin_ia32_rsqrt28ps_mask(A, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm_rcp28_round_sd(A,B,R) __builtin_ia32_rcp28sd_round(A, B, R)
#define _mm_rcp28_round_ss(A,B,R) __builtin_ia32_rcp28ss_round(A, B, R)
#define _mm_rsqrt28_round_sd(A,B,R) __builtin_ia32_rsqrt28sd_round(A, B, R)
#define _mm_rsqrt28_round_ss(A,B,R) __builtin_ia32_rsqrt28ss_round(A, B, R)
#define _mm512_exp2a23_pd(A) _mm512_exp2a23_round_pd(A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_mask_exp2a23_pd(W,U,A) _mm512_mask_exp2a23_round_pd(W, U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_maskz_exp2a23_pd(U,A) _mm512_maskz_exp2a23_round_pd(U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_exp2a23_ps(A) _mm512_exp2a23_round_ps(A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_mask_exp2a23_ps(W,U,A) _mm512_mask_exp2a23_round_ps(W, U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_maskz_exp2a23_ps(U,A) _mm512_maskz_exp2a23_round_ps(U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_rcp28_pd(A) _mm512_rcp28_round_pd(A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_mask_rcp28_pd(W,U,A) _mm512_mask_rcp28_round_pd(W, U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_maskz_rcp28_pd(U,A) _mm512_maskz_rcp28_round_pd(U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_rcp28_ps(A) _mm512_rcp28_round_ps(A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_mask_rcp28_ps(W,U,A) _mm512_mask_rcp28_round_ps(W, U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_maskz_rcp28_ps(U,A) _mm512_maskz_rcp28_round_ps(U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_rsqrt28_pd(A) _mm512_rsqrt28_round_pd(A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_mask_rsqrt28_pd(W,U,A) _mm512_mask_rsqrt28_round_pd(W, U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_maskz_rsqrt28_pd(U,A) _mm512_maskz_rsqrt28_round_pd(U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_rsqrt28_ps(A) _mm512_rsqrt28_round_ps(A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_mask_rsqrt28_ps(W,U,A) _mm512_mask_rsqrt28_round_ps(W, U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_maskz_rsqrt28_ps(U,A) _mm512_maskz_rsqrt28_round_ps(U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm_rcp28_sd(A,B) __builtin_ia32_rcp28sd_round(B, A, _MM_FROUND_CUR_DIRECTION)
#define _mm_rcp28_ss(A,B) __builtin_ia32_rcp28ss_round(B, A, _MM_FROUND_CUR_DIRECTION)
#define _mm_rsqrt28_sd(A,B) __builtin_ia32_rsqrt28sd_round(B, A, _MM_FROUND_CUR_DIRECTION)
#define _mm_rsqrt28_ss(A,B) __builtin_ia32_rsqrt28ss_round(B, A, _MM_FROUND_CUR_DIRECTION)
#undef __DISABLE_AVX512ER__
#pragma GCC pop_options
#define _AVX512PFINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("avx512pf")
#define __DISABLE_AVX512PF__
typedef long long __v8di __attribute__ ((__vector_size__ (64)));
typedef int __v16si __attribute__ ((__vector_size__ (64)));
typedef long long __m512i __attribute__ ((__vector_size__ (64), __may_alias__));
typedef unsigned char __mmask8;
typedef unsigned short __mmask16;
#define _mm512_mask_prefetch_i32gather_pd(INDEX,MASK,ADDR,SCALE,HINT) __builtin_ia32_gatherpfdpd ((__mmask8)MASK, (__v8si)(__m256i)INDEX, (long long const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_mask_prefetch_i32gather_ps(INDEX,MASK,ADDR,SCALE,HINT) __builtin_ia32_gatherpfdps ((__mmask16)MASK, (__v16si)(__m512i)INDEX, (int const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_mask_prefetch_i64gather_pd(INDEX,MASK,ADDR,SCALE,HINT) __builtin_ia32_gatherpfqpd ((__mmask8)MASK, (__v8di)(__m512i)INDEX, (long long const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_mask_prefetch_i64gather_ps(INDEX,MASK,ADDR,SCALE,HINT) __builtin_ia32_gatherpfqps ((__mmask8)MASK, (__v8di)(__m512i)INDEX, (int const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_prefetch_i32scatter_pd(ADDR,INDEX,SCALE,HINT) __builtin_ia32_scatterpfdpd ((__mmask8)0xFF, (__v8si)(__m256i)INDEX, (long long const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_prefetch_i32scatter_ps(ADDR,INDEX,SCALE,HINT) __builtin_ia32_scatterpfdps ((__mmask16)0xFFFF, (__v16si)(__m512i)INDEX, (int const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_mask_prefetch_i32scatter_pd(ADDR,MASK,INDEX,SCALE,HINT) __builtin_ia32_scatterpfdpd ((__mmask8)MASK, (__v8si)(__m256i)INDEX, (long long const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_mask_prefetch_i32scatter_ps(ADDR,MASK,INDEX,SCALE,HINT) __builtin_ia32_scatterpfdps ((__mmask16)MASK, (__v16si)(__m512i)INDEX, (int const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_prefetch_i64scatter_pd(ADDR,INDEX,SCALE,HINT) __builtin_ia32_scatterpfqpd ((__mmask8)0xFF, (__v8di)(__m512i)INDEX, (long long const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_prefetch_i64scatter_ps(ADDR,INDEX,SCALE,HINT) __builtin_ia32_scatterpfqps ((__mmask8)0xFF, (__v8di)(__m512i)INDEX, (int const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_mask_prefetch_i64scatter_pd(ADDR,MASK,INDEX,SCALE,HINT) __builtin_ia32_scatterpfqpd ((__mmask8)MASK, (__v8di)(__m512i)INDEX, (long long const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_mask_prefetch_i64scatter_ps(ADDR,MASK,INDEX,SCALE,HINT) __builtin_ia32_scatterpfqps ((__mmask8)MASK, (__v8di)(__m512i)INDEX, (int const *)ADDR, (int)SCALE, (int)HINT)
#undef __DISABLE_AVX512PF__
#pragma GCC pop_options
#define _AVX512CDINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("avx512cd")
#define __DISABLE_AVX512CD__
typedef long long __v8di __attribute__ ((__vector_size__ (64)));
typedef int __v16si __attribute__ ((__vector_size__ (64)));
typedef long long __m512i __attribute__ ((__vector_size__ (64), __may_alias__));
typedef double __m512d __attribute__ ((__vector_size__ (64), __may_alias__));
typedef unsigned char __mmask8;
typedef unsigned short __mmask16;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_conflict_epi32 (__m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_conflict_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_conflict_epi32 (__mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_conflict_epi64 (__m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_conflict_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_conflict_epi64 (__mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_lzcnt_epi64 (__m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_lzcnt_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_lzcnt_epi64 (__mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_lzcnt_epi32 (__m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_lzcnt_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_lzcnt_epi32 (__mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcastmb_epi64 (__mmask8 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcastmw_epi32 (__mmask16 __A)
;
#undef __DISABLE_AVX512CD__
#pragma GCC pop_options
#define _SHAINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("sha")
#define __DISABLE_SHA__
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha1msg1_epu32 (__m128i __A, __m128i __B)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha1msg2_epu32 (__m128i __A, __m128i __B)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha1nexte_epu32 (__m128i __A, __m128i __B)
;
#define _mm_sha1rnds4_epu32(A,B,I) ((__m128i) __builtin_ia32_sha1rnds4 ((__v4si)(__m128i)A, (__v4si)(__m128i)B, (int)I))
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha256msg1_epu32 (__m128i __A, __m128i __B)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha256msg2_epu32 (__m128i __A, __m128i __B)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha256rnds2_epu32 (__m128i __A, __m128i __B, __m128i __C)
;
#undef __DISABLE_SHA__
#pragma GCC pop_options
#define _LZCNTINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("lzcnt")
#define __DISABLE_LZCNT__
extern unsigned short __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__lzcnt16 (unsigned short __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__lzcnt32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_lzcnt_u32 (unsigned int __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__lzcnt64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_lzcnt_u64 (unsigned long long __X)
;
#undef __DISABLE_LZCNT__
#pragma GCC pop_options
#define _BMIINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("bmi")
#define __DISABLE_BMI__
extern unsigned short __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__tzcnt_u16 (unsigned short __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__andn_u32 (unsigned int __X, unsigned int __Y)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bextr_u32 (unsigned int __X, unsigned int __Y)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_bextr_u32 (unsigned int __X, unsigned int __Y, unsigned __Z)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsi_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_blsi_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsmsk_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_blsmsk_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsr_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_blsr_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__tzcnt_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_tzcnt_u32 (unsigned int __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__andn_u64 (unsigned long long __X, unsigned long long __Y)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bextr_u64 (unsigned long long __X, unsigned long long __Y)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_bextr_u64 (unsigned long long __X, unsigned int __Y, unsigned int __Z)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsi_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_blsi_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsmsk_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_blsmsk_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsr_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_blsr_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__tzcnt_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_tzcnt_u64 (unsigned long long __X)
;
#undef __DISABLE_BMI__
#pragma GCC pop_options
#define _BMI2INTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("bmi2")
#define __DISABLE_BMI2__
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_bzhi_u32 (unsigned int __X, unsigned int __Y)
;
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_pdep_u32 (unsigned int __X, unsigned int __Y)
;
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_pext_u32 (unsigned int __X, unsigned int __Y)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_bzhi_u64 (unsigned long long __X, unsigned long long __Y)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_pdep_u64 (unsigned long long __X, unsigned long long __Y)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_pext_u64 (unsigned long long __X, unsigned long long __Y)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mulx_u64 (unsigned long long __X, unsigned long long __Y,
unsigned long long *__P)
;
#undef __DISABLE_BMI2__
#pragma GCC pop_options
#define _FMAINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("fma")
#define __DISABLE_FMA__
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmadd_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m256d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmadd_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmadd_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m256
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmadd_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmadd_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmadd_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmsub_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m256d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmsub_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmsub_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m256
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmsub_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmsub_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmsub_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmadd_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m256d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fnmadd_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmadd_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m256
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fnmadd_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmadd_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmadd_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmsub_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m256d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fnmsub_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmsub_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m256
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fnmsub_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmsub_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmsub_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmaddsub_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m256d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmaddsub_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmaddsub_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m256
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmaddsub_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmsubadd_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m256d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmsubadd_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmsubadd_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m256
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmsubadd_ps (__m256 __A, __m256 __B, __m256 __C)
;
#undef __DISABLE_FMA__
#pragma GCC pop_options
#define _F16CINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("f16c")
#define __DISABLE_F16C__
extern float __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_cvtsh_ss (unsigned short __S)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtph_ps (__m128i __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtph_ps (__m128i __A)
;
#define _cvtss_sh(__F,__I) (__extension__ ({ __v4sf __A = __extension__ (__v4sf){ __F, 0, 0, 0 }; __v8hi __H = __builtin_ia32_vcvtps2ph (__A, __I); (unsigned short) __builtin_ia32_vec_ext_v8hi (__H, 0); }))
#define _mm_cvtps_ph(A,I) ((__m128i) __builtin_ia32_vcvtps2ph ((__v4sf)(__m128) A, (int) (I)))
#define _mm256_cvtps_ph(A,I) ((__m128i) __builtin_ia32_vcvtps2ph256 ((__v8sf)(__m256) A, (int) (I)))
#undef __DISABLE_F16C__
#pragma GCC pop_options
#define _RTMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("rtm")
#define __DISABLE_RTM__
#define _XBEGIN_STARTED (~0u)
#define _XABORT_EXPLICIT (1 << 0)
#define _XABORT_RETRY (1 << 1)
#define _XABORT_CONFLICT (1 << 2)
#define _XABORT_CAPACITY (1 << 3)
#define _XABORT_DEBUG (1 << 4)
#define _XABORT_NESTED (1 << 5)
#define _XABORT_CODE(x) (((x) >> 24) & 0xFF)
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xbegin (void)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xend (void)
;
#define _xabort(N) __builtin_ia32_xabort (N)
#undef __DISABLE_RTM__
#pragma GCC pop_options
#define _XTESTINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("rtm")
#define __DISABLE_RTM__
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xtest (void)
;
#undef __DISABLE_RTM__
#pragma GCC pop_options
#pragma GCC push_options
#pragma GCC target("rdrnd")
#define __DISABLE_RDRND__
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_rdrand16_step (unsigned short *__P)
;
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_rdrand32_step (unsigned int *__P)
;
#undef __DISABLE_RDRND__
#pragma GCC pop_options
#pragma GCC push_options
#pragma GCC target("fsgsbase")
#define __DISABLE_FSGSBASE__
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_readfsbase_u32 (void)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_readfsbase_u64 (void)
;
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_readgsbase_u32 (void)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_readgsbase_u64 (void)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_writefsbase_u32 (unsigned int __B)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_writefsbase_u64 (unsigned long long __B)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_writegsbase_u32 (unsigned int __B)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_writegsbase_u64 (unsigned long long __B)
;
#undef __DISABLE_FSGSBASE__
#pragma GCC pop_options
#pragma GCC push_options
#pragma GCC target("rdrnd")
#define __DISABLE_RDRND__
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_rdrand64_step (unsigned long long *__P)
;
#undef __DISABLE_RDRND__
#pragma GCC pop_options
#define _MM3DNOW_H_INCLUDED
#define _PRFCHWINTRIN_H_INCLUDED
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_prefetchw (void *__P)
;
#pragma GCC push_options
#pragma GCC target("3dnow")
#define __DISABLE_3dNOW__
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_femms (void)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pavgusb (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pf2id (__m64 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfacc (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfadd (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfcmpeq (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfcmpge (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfcmpgt (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfmax (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfmin (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfmul (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfrcp (__m64 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfrcpit1 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfrcpit2 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfrsqrt (__m64 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfrsqit1 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfsub (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfsubr (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pi2fd (__m64 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmulhrw (__m64 __A, __m64 __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_prefetch (void *__P)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_from_float (float __A)
;
extern float __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_to_float (__m64 __A)
;
#undef __DISABLE_3dNOW__
#pragma GCC pop_options
#define _FMA4INTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("fma4")
#define __DISABLE_FMA4__
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macc_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macc_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macc_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macc_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_msub_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_msub_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_msub_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_msub_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmacc_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmacc_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmacc_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmacc_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmsub_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmsub_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmsub_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmsub_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maddsub_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maddsub_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_msubadd_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_msubadd_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_macc_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_macc_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_msub_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_msub_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_nmacc_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_nmacc_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_nmsub_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_nmsub_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maddsub_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maddsub_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_msubadd_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_msubadd_pd (__m256d __A, __m256d __B, __m256d __C)
;
#undef __DISABLE_FMA4__
#pragma GCC pop_options
#define _XOPMMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("xop")
#define __DISABLE_XOP__
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maccs_epi16(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macc_epi16(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maccsd_epi16(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maccd_epi16(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maccs_epi32(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macc_epi32(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maccslo_epi32(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macclo_epi32(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maccshi_epi32(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macchi_epi32(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maddsd_epi16(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maddd_epi16(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddw_epi8(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddd_epi8(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddq_epi8(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddd_epi16(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddq_epi16(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddq_epi32(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddw_epu8(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddd_epu8(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddq_epu8(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddd_epu16(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddq_epu16(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddq_epu32(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsubw_epi8(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsubd_epi16(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsubq_epi32(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmov_si128(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_perm_epi8(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rot_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rot_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rot_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rot_epi64(__m128i __A, __m128i __B)
;
#define _mm_roti_epi8(A,N) ((__m128i) __builtin_ia32_vprotbi ((__v16qi)(__m128i)(A), (int)(N)))
#define _mm_roti_epi16(A,N) ((__m128i) __builtin_ia32_vprotwi ((__v8hi)(__m128i)(A), (int)(N)))
#define _mm_roti_epi32(A,N) ((__m128i) __builtin_ia32_vprotdi ((__v4si)(__m128i)(A), (int)(N)))
#define _mm_roti_epi64(A,N) ((__m128i) __builtin_ia32_vprotqi ((__v2di)(__m128i)(A), (int)(N)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shl_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shl_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shl_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shl_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epi64(__m128i __A, __m128i __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_frcz_ps (__m128 __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_frcz_pd (__m128d __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_frcz_ss (__m128 __A, __m128 __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_frcz_sd (__m128d __A, __m128d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_frcz_ps (__m256 __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_frcz_pd (__m256d __A)
;
#define _mm_permute2_pd(X,Y,C,I) ((__m128d) __builtin_ia32_vpermil2pd ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128d)(C), (int)(I)))
#define _mm256_permute2_pd(X,Y,C,I) ((__m256d) __builtin_ia32_vpermil2pd256 ((__v4df)(__m256d)(X), (__v4df)(__m256d)(Y), (__v4di)(__m256d)(C), (int)(I)))
#define _mm_permute2_ps(X,Y,C,I) ((__m128) __builtin_ia32_vpermil2ps ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128)(C), (int)(I)))
#define _mm256_permute2_ps(X,Y,C,I) ((__m256) __builtin_ia32_vpermil2ps256 ((__v8sf)(__m256)(X), (__v8sf)(__m256)(Y), (__v8si)(__m256)(C), (int)(I)))
#undef __DISABLE_XOP__
#pragma GCC pop_options
#define _LWPINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("lwp")
#define __DISABLE_LWP__
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__llwpcb (void *pcbAddress)
;
extern void * __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__slwpcb (void)
;
#define __lwpval32(D2,D1,F) (__builtin_ia32_lwpval32 ((unsigned int) (D2), (unsigned int) (D1), (unsigned int) (F)))
#define __lwpval64(D2,D1,F) (__builtin_ia32_lwpval64 ((unsigned long long) (D2), (unsigned int) (D1), (unsigned int) (F)))
#define __lwpins32(D2,D1,F) (__builtin_ia32_lwpins32 ((unsigned int) (D2), (unsigned int) (D1), (unsigned int) (F)))
#define __lwpins64(D2,D1,F) (__builtin_ia32_lwpins64 ((unsigned long long) (D2), (unsigned int) (D1), (unsigned int) (F)))
#undef __DISABLE_LWP__
#pragma GCC pop_options
#define _TBMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("tbm")
#define __DISABLE_TBM__
#define __bextri_u32(X,I) ((unsigned int)__builtin_ia32_bextri_u32 ((unsigned int)(X), (unsigned int)(I)))
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcfill_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blci_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcic_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcmsk_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcs_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsfill_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsic_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__t1mskc_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__tzmsk_u32 (unsigned int __X)
;
#define __bextri_u64(X,I) ((unsigned long long)__builtin_ia32_bextri_u64 ((unsigned long long)(X), (unsigned long long)(I)))
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcfill_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blci_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcic_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcmsk_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcs_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsfill_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsic_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__t1mskc_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__tzmsk_u64 (unsigned long long __X)
;
#undef __DISABLE_TBM__
#pragma GCC pop_options
#define _RDSEEDINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("rdseed")
#define __DISABLE_RDSEED__
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_rdseed16_step (unsigned short *p)
;
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_rdseed32_step (unsigned int *p)
;
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_rdseed64_step (unsigned long long *p)
;
#undef __DISABLE_RDSEED__
#pragma GCC pop_options
#define _FXSRINTRIN_H_INCLUDED
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_fxsave (void *__P)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_fxrstor (void *__P)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_fxsave64 (void *__P)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_fxrstor64 (void *__P)
;
#define _XSAVEINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("xsave")
#define __DISABLE_XSAVE__
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsave (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xrstor (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsave64 (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xrstor64 (void *__P, long long __M)
;
#undef __DISABLE_XSAVE__
#pragma GCC pop_options
#define _XSAVEOPTINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("xsaveopt")
#define __DISABLE_XSAVEOPT__
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsaveopt (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsaveopt64 (void *__P, long long __M)
;
#undef __DISABLE_XSAVEOPT__
#pragma GCC pop_options
#define _ADXINTRIN_H_INCLUDED
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_subborrow_u32 (unsigned char __CF, unsigned int __X,
unsigned int __Y, unsigned int *__P)
;
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_addcarry_u32 (unsigned char __CF, unsigned int __X,
unsigned int __Y, unsigned int *__P)
;
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_addcarryx_u32 (unsigned char __CF, unsigned int __X,
unsigned int __Y, unsigned int *__P)
;
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_subborrow_u64 (unsigned char __CF, unsigned long __X,
unsigned long __Y, unsigned long long *__P)
;
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_addcarry_u64 (unsigned char __CF, unsigned long __X,
unsigned long __Y, unsigned long long *__P)
;
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_addcarryx_u64 (unsigned char __CF, unsigned long __X,
unsigned long __Y, unsigned long long *__P)
;
#define _CLFLUSHOPTINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("clflushopt")
#define __DISABLE_CLFLUSHOPT__
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_clflushopt (void *__A)
;
#undef __DISABLE_CLFLUSHOPT__
#pragma GCC pop_options
#define _XSAVESINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("xsaves")
#define __DISABLE_XSAVES__
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsaves (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xrstors (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xrstors64 (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsaves64 (void *__P, long long __M)
;
#undef __DISABLE_XSAVES__
#pragma GCC pop_options
#define _XSAVECINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("xsavec")
#define __DISABLE_XSAVEC__
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsavec (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsavec64 (void *__P, long long __M)
;
#undef __DISABLE_XSAVEC__
#pragma GCC pop_options
namespace std __attribute__ ((__visibility__ ("default")))
{
}
#define _RANDOM_TCC 1
#define _GLIBCXX_NUMERIC 1
#define _STL_NUMERIC_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _ForwardIterator, typename _Tp>
void
iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _InputIterator, typename _Tp>
_Tp
accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
;
template<typename _InputIterator, typename _Tp, typename _BinaryOperation>
_Tp
accumulate(_InputIterator __first, _InputIterator __last, _Tp __init,
_BinaryOperation __binary_op)
;
template<typename _InputIterator1, typename _InputIterator2, typename _Tp>
_Tp
inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _Tp __init)
;
template<typename _InputIterator1, typename _InputIterator2, typename _Tp,
typename _BinaryOperation1, typename _BinaryOperation2>
_Tp
inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _Tp __init,
_BinaryOperation1 __binary_op1,
_BinaryOperation2 __binary_op2)
;
template<typename _InputIterator, typename _OutputIterator>
_OutputIterator
partial_sum(_InputIterator __first, _InputIterator __last,
_OutputIterator __result)
;
template<typename _InputIterator, typename _OutputIterator,
typename _BinaryOperation>
_OutputIterator
partial_sum(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _BinaryOperation __binary_op)
;
template<typename _InputIterator, typename _OutputIterator>
_OutputIterator
adjacent_difference(_InputIterator __first,
_InputIterator __last, _OutputIterator __result)
;
template<typename _InputIterator, typename _OutputIterator,
typename _BinaryOperation>
_OutputIterator
adjacent_difference(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _BinaryOperation __binary_op)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
namespace __detail
{
template<typename _InputIterator, typename _OutputIterator,
typename _Tp>
_OutputIterator
__normalize(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, const _Tp& __factor)
;
}
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
constexpr _UIntType
linear_congruential_engine<_UIntType, __a, __c, __m>::multiplier;
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
constexpr _UIntType
linear_congruential_engine<_UIntType, __a, __c, __m>::increment;
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
constexpr _UIntType
linear_congruential_engine<_UIntType, __a, __c, __m>::modulus;
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
constexpr _UIntType
linear_congruential_engine<_UIntType, __a, __c, __m>::default_seed;
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const linear_congruential_engine<_UIntType,
__a, __c, __m>& __lcr)
;
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
linear_congruential_engine<_UIntType, __a, __c, __m>& __lcr)
;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::word_size;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::state_size;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::shift_size;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::mask_bits;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr _UIntType
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::xor_mask;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::tempering_u;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr _UIntType
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::tempering_d;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::tempering_s;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr _UIntType
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::tempering_b;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::tempering_t;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr _UIntType
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::tempering_c;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::tempering_l;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr _UIntType
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::
initialization_multiplier;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr _UIntType
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::default_seed;
template<typename _UIntType, size_t __w,
size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const mersenne_twister_engine<_UIntType, __w, __n, __m,
__r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __x)
;
template<typename _UIntType, size_t __w,
size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
mersenne_twister_engine<_UIntType, __w, __n, __m,
__r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __x)
;
template<typename _UIntType, size_t __w, size_t __s, size_t __r>
constexpr size_t
subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size;
template<typename _UIntType, size_t __w, size_t __s, size_t __r>
constexpr size_t
subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag;
template<typename _UIntType, size_t __w, size_t __s, size_t __r>
constexpr size_t
subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag;
template<typename _UIntType, size_t __w, size_t __s, size_t __r>
constexpr _UIntType
subtract_with_carry_engine<_UIntType, __w, __s, __r>::default_seed;
template<typename _UIntType, size_t __w, size_t __s, size_t __r,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const subtract_with_carry_engine<_UIntType,
__w, __s, __r>& __x)
;
template<typename _UIntType, size_t __w, size_t __s, size_t __r,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
subtract_with_carry_engine<_UIntType, __w, __s, __r>& __x)
;
template<typename _RandomNumberEngine, size_t __p, size_t __r>
constexpr size_t
discard_block_engine<_RandomNumberEngine, __p, __r>::block_size;
template<typename _RandomNumberEngine, size_t __p, size_t __r>
constexpr size_t
discard_block_engine<_RandomNumberEngine, __p, __r>::used_block;
template<typename _RandomNumberEngine, size_t __p, size_t __r,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const discard_block_engine<_RandomNumberEngine,
__p, __r>& __x)
;
template<typename _RandomNumberEngine, size_t __p, size_t __r,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
discard_block_engine<_RandomNumberEngine, __p, __r>& __x)
;
template<typename _RandomNumberEngine, size_t __k>
constexpr size_t
shuffle_order_engine<_RandomNumberEngine, __k>::table_size;
template<typename _RandomNumberEngine, size_t __k,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const shuffle_order_engine<_RandomNumberEngine, __k>& __x)
;
template<typename _RandomNumberEngine, size_t __k,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
shuffle_order_engine<_RandomNumberEngine, __k>& __x)
;
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const uniform_int_distribution<_IntType>& __x)
;
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
uniform_int_distribution<_IntType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const uniform_real_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
uniform_real_distribution<_RealType>& __x)
;
template<typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const bernoulli_distribution& __x)
;
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const geometric_distribution<_IntType>& __x)
;
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
geometric_distribution<_IntType>& __x)
;
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const negative_binomial_distribution<_IntType>& __x)
;
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
negative_binomial_distribution<_IntType>& __x)
;
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const poisson_distribution<_IntType>& __x)
;
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
poisson_distribution<_IntType>& __x)
;
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const binomial_distribution<_IntType>& __x)
;
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
binomial_distribution<_IntType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const exponential_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
exponential_distribution<_RealType>& __x)
;
template<typename _RealType>
bool
operator==(const std::normal_distribution<_RealType>& __d1,
const std::normal_distribution<_RealType>& __d2)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const normal_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
normal_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const lognormal_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
lognormal_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const chi_squared_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
chi_squared_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const cauchy_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
cauchy_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const fisher_f_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
fisher_f_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const student_t_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
student_t_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const gamma_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
gamma_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const weibull_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
weibull_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const extreme_value_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
extreme_value_distribution<_RealType>& __x)
;
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const discrete_distribution<_IntType>& __x)
;
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
discrete_distribution<_IntType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const piecewise_constant_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
piecewise_constant_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const piecewise_linear_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
piecewise_linear_distribution<_RealType>& __x)
;
template<typename _RealType, size_t __bits,
typename _UniformRandomNumberGenerator>
_RealType
generate_canonical(_UniformRandomNumberGenerator& __urng)
;
}
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)
;
template<typename _InputIterator, typename _Predicate>
_InputIterator
__find_if(_InputIterator __first, _InputIterator __last,
_Predicate __pred, input_iterator_tag)
;
template<typename _RandomAccessIterator, typename _Predicate>
_RandomAccessIterator
__find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Predicate __pred, random_access_iterator_tag)
;
template<typename _Iterator, typename _Predicate>
_Iterator
__find_if(_Iterator __first, _Iterator __last, _Predicate __pred)
;
template<typename _InputIterator, typename _Predicate>
_InputIterator
__find_if_not(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
;
template<typename _InputIterator, typename _Predicate, typename _Distance>
_InputIterator
__find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
;
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
_ForwardIterator1
__search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2,
_BinaryPredicate __predicate)
;
template<typename _ForwardIterator, typename _Integer,
typename _UnaryPredicate>
_ForwardIterator
__search_n_aux(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count, _UnaryPredicate __unary_pred,
std::forward_iterator_tag)
;
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)
;
template<typename _ForwardIterator, typename _Integer,
typename _UnaryPredicate>
_ForwardIterator
__search_n(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count,
_UnaryPredicate __unary_pred)
;
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)
;
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)
;
template<typename _ForwardIterator1, typename _ForwardIterator2>
_ForwardIterator1
find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2)
;
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
_ForwardIterator1
find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2,
_BinaryPredicate __comp)
;
template<typename _InputIterator, typename _Predicate>
bool
all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
;
template<typename _InputIterator, typename _Predicate>
bool
none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
;
template<typename _InputIterator, typename _Predicate>
bool
any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
;
template<typename _InputIterator, typename _Predicate>
_InputIterator
find_if_not(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
;
template<typename _InputIterator, typename _Predicate>
bool
is_partitioned(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
partition_point(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _InputIterator, typename _OutputIterator,
typename _Predicate>
_OutputIterator
__remove_copy_if(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _Predicate __pred)
;
template<typename _InputIterator, typename _OutputIterator, typename _Tp>
_OutputIterator
remove_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, const _Tp& __value)
;
template<typename _InputIterator, typename _OutputIterator,
typename _Predicate>
_OutputIterator
remove_copy_if(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _Predicate __pred)
;
template<typename _InputIterator, typename _OutputIterator,
typename _Predicate>
_OutputIterator
copy_if(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _Predicate __pred)
;
template<typename _InputIterator, typename _Size, typename _OutputIterator>
_OutputIterator
__copy_n(_InputIterator __first, _Size __n,
_OutputIterator __result, input_iterator_tag)
;
template<typename _RandomAccessIterator, typename _Size,
typename _OutputIterator>
_OutputIterator
__copy_n(_RandomAccessIterator __first, _Size __n,
_OutputIterator __result, random_access_iterator_tag)
;
template<typename _InputIterator, typename _Size, typename _OutputIterator>
_OutputIterator
copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
;
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)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
__remove_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _ForwardIterator, typename _Tp>
_ForwardIterator
remove(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __value)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
remove_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _ForwardIterator, typename _BinaryPredicate>
_ForwardIterator
__adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __binary_pred)
;
template<typename _ForwardIterator, typename _BinaryPredicate>
_ForwardIterator
__unique(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __binary_pred)
;
template<typename _ForwardIterator>
_ForwardIterator
unique(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _BinaryPredicate>
_ForwardIterator
unique(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __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)
;
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)
;
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)
;
template<typename _BidirectionalIterator>
void
__reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
bidirectional_iterator_tag)
;
template<typename _RandomAccessIterator>
void
__reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
random_access_iterator_tag)
;
template<typename _BidirectionalIterator>
void
reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
;
template<typename _BidirectionalIterator, typename _OutputIterator>
_OutputIterator
reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
_OutputIterator __result)
;
template<typename _EuclideanRingElement>
_EuclideanRingElement
__gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
;
template<typename _ForwardIterator>
void
__rotate(_ForwardIterator __first,
_ForwardIterator __middle,
_ForwardIterator __last,
forward_iterator_tag)
;
template<typename _BidirectionalIterator>
void
__rotate(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
bidirectional_iterator_tag)
;
template<typename _RandomAccessIterator>
void
__rotate(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last,
random_access_iterator_tag)
;
template<typename _ForwardIterator>
void
rotate(_ForwardIterator __first, _ForwardIterator __middle,
_ForwardIterator __last)
;
template<typename _ForwardIterator, typename _OutputIterator>
_OutputIterator
rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
_ForwardIterator __last, _OutputIterator __result)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
__partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred, forward_iterator_tag)
;
template<typename _BidirectionalIterator, typename _Predicate>
_BidirectionalIterator
__partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
_Predicate __pred, bidirectional_iterator_tag)
;
template<typename _ForwardIterator, typename _Predicate, typename _Distance>
_ForwardIterator
__inplace_stable_partition(_ForwardIterator __first,
_Predicate __pred, _Distance __len)
;
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)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
__stable_partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
stable_partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__heap_select(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _InputIterator, typename _RandomAccessIterator,
typename _Compare>
_RandomAccessIterator
__partial_sort_copy(_InputIterator __first, _InputIterator __last,
_RandomAccessIterator __result_first,
_RandomAccessIterator __result_last,
_Compare __comp)
;
template<typename _InputIterator, typename _RandomAccessIterator>
_RandomAccessIterator
partial_sort_copy(_InputIterator __first, _InputIterator __last,
_RandomAccessIterator __result_first,
_RandomAccessIterator __result_last)
;
template<typename _InputIterator, typename _RandomAccessIterator,
typename _Compare>
_RandomAccessIterator
partial_sort_copy(_InputIterator __first, _InputIterator __last,
_RandomAccessIterator __result_first,
_RandomAccessIterator __result_last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__unguarded_linear_insert(_RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__unguarded_insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
enum { _S_threshold = 16 };
template<typename _RandomAccessIterator, typename _Compare>
void
__final_insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
_RandomAccessIterator
__unguarded_partition(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_RandomAccessIterator __pivot, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
_RandomAccessIterator
__unguarded_partition_pivot(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__partial_sort(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Size, typename _Compare>
void
__introsort_loop(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Size __depth_limit, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Size, typename _Compare>
void
__introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last, _Size __depth_limit,
_Compare __comp)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
_ForwardIterator
lower_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
_ForwardIterator
__upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
;
template<typename _ForwardIterator, typename _Tp>
_ForwardIterator
upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
_ForwardIterator
upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __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)
;
template<typename _ForwardIterator, typename _Tp>
pair<_ForwardIterator, _ForwardIterator>
equal_range(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
pair<_ForwardIterator, _ForwardIterator>
equal_range(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
;
template<typename _ForwardIterator, typename _Tp>
bool
binary_search(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
bool
binary_search(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
;
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)
;
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)
;
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)
;
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)
;
template<typename _BidirectionalIterator, typename _Distance,
typename _Compare>
void
__merge_without_buffer(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Distance __len1, _Distance __len2,
_Compare __comp)
;
template<typename _BidirectionalIterator, typename _Compare>
void
__inplace_merge(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Compare __comp)
;
template<typename _BidirectionalIterator>
void
inplace_merge(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last)
;
template<typename _BidirectionalIterator, typename _Compare>
void
inplace_merge(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Compare __comp)
;
template<typename _InputIterator, typename _OutputIterator,
typename _Compare>
_OutputIterator
__move_merge(_InputIterator __first1, _InputIterator __last1,
_InputIterator __first2, _InputIterator __last2,
_OutputIterator __result, _Compare __comp)
;
template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
typename _Distance, typename _Compare>
void
__merge_sort_loop(_RandomAccessIterator1 __first,
_RandomAccessIterator1 __last,
_RandomAccessIterator2 __result, _Distance __step_size,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Distance,
typename _Compare>
void
__chunk_insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Distance __chunk_size, _Compare __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)
;
template<typename _RandomAccessIterator, typename _Pointer,
typename _Distance, typename _Compare>
void
__stable_sort_adaptive(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Pointer __buffer, _Distance __buffer_size,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__inplace_stable_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _Compare>
bool
__includes(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2>
bool
includes(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _Compare>
bool
includes(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_Compare __comp)
;
template<typename _BidirectionalIterator, typename _Compare>
bool
__next_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last, _Compare __comp)
;
template<typename _BidirectionalIterator>
bool
next_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last)
;
template<typename _BidirectionalIterator, typename _Compare>
bool
next_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last, _Compare __comp)
;
template<typename _BidirectionalIterator, typename _Compare>
bool
__prev_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last, _Compare __comp)
;
template<typename _BidirectionalIterator>
bool
prev_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last)
;
template<typename _BidirectionalIterator, typename _Compare>
bool
prev_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last, _Compare __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)
;
template<typename _InputIterator, typename _OutputIterator, typename _Tp>
_OutputIterator
replace_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result,
const _Tp& __old_value, const _Tp& __new_value)
;
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)
;
template<typename _InputIterator, typename _Predicate>
typename iterator_traits<_InputIterator>::difference_type
__count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
;
template<typename _ForwardIterator>
bool
is_sorted(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Compare>
bool
is_sorted(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
__is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _ForwardIterator>
_ForwardIterator
is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _Tp>
pair<const _Tp&, const _Tp&>
minmax(const _Tp& __a, const _Tp& __b)
;
template<typename _Tp, typename _Compare>
pair<const _Tp&, const _Tp&>
minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
;
template<typename _ForwardIterator, typename _Compare>
pair<_ForwardIterator, _ForwardIterator>
__minmax_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _ForwardIterator>
pair<_ForwardIterator, _ForwardIterator>
minmax_element(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Compare>
pair<_ForwardIterator, _ForwardIterator>
minmax_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _Tp>
_Tp
min(initializer_list<_Tp> __l)
;
template<typename _Tp, typename _Compare>
_Tp
min(initializer_list<_Tp> __l, _Compare __comp)
;
template<typename _Tp>
_Tp
max(initializer_list<_Tp> __l)
;
template<typename _Tp, typename _Compare>
_Tp
max(initializer_list<_Tp> __l, _Compare __comp)
;
template<typename _Tp>
pair<_Tp, _Tp>
minmax(initializer_list<_Tp> __l)
;
template<typename _Tp, typename _Compare>
pair<_Tp, _Tp>
minmax(initializer_list<_Tp> __l, _Compare __comp)
;
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
bool
__is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _BinaryPredicate __pred)
;
template<typename _ForwardIterator1, typename _ForwardIterator2>
bool
is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2)
;
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
bool
is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _BinaryPredicate __pred)
;
template<typename _RandomAccessIterator,
typename _UniformRandomNumberGenerator>
void
shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
_UniformRandomNumberGenerator&& __g)
;
template<typename _InputIterator, typename _Function>
_Function
for_each(_InputIterator __first, _InputIterator __last, _Function __f)
;
template<typename _InputIterator, typename _Tp>
_InputIterator
find(_InputIterator __first, _InputIterator __last,
const _Tp& __val)
;
template<typename _InputIterator, typename _Predicate>
_InputIterator
find_if(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
;
template<typename _InputIterator, typename _ForwardIterator>
_InputIterator
find_first_of(_InputIterator __first1, _InputIterator __last1,
_ForwardIterator __first2, _ForwardIterator __last2)
;
template<typename _InputIterator, typename _ForwardIterator,
typename _BinaryPredicate>
_InputIterator
find_first_of(_InputIterator __first1, _InputIterator __last1,
_ForwardIterator __first2, _ForwardIterator __last2,
_BinaryPredicate __comp)
;
template<typename _ForwardIterator>
_ForwardIterator
adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _BinaryPredicate>
_ForwardIterator
adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __binary_pred)
;
template<typename _InputIterator, typename _Tp>
typename iterator_traits<_InputIterator>::difference_type
count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
;
template<typename _InputIterator, typename _Predicate>
typename iterator_traits<_InputIterator>::difference_type
count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
;
template<typename _ForwardIterator1, typename _ForwardIterator2>
_ForwardIterator1
search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2)
;
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
_ForwardIterator1
search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2,
_BinaryPredicate __predicate)
;
template<typename _ForwardIterator, typename _Integer, typename _Tp>
_ForwardIterator
search_n(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count, const _Tp& __val)
;
template<typename _ForwardIterator, typename _Integer, typename _Tp,
typename _BinaryPredicate>
_ForwardIterator
search_n(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count, const _Tp& __val,
_BinaryPredicate __binary_pred)
;
template<typename _InputIterator, typename _OutputIterator,
typename _UnaryOperation>
_OutputIterator
transform(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _UnaryOperation __unary_op)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _BinaryOperation>
_OutputIterator
transform(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _OutputIterator __result,
_BinaryOperation __binary_op)
;
template<typename _ForwardIterator, typename _Tp>
void
replace(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __old_value, const _Tp& __new_value)
;
template<typename _ForwardIterator, typename _Predicate, typename _Tp>
void
replace_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred, const _Tp& __new_value)
;
template<typename _ForwardIterator, typename _Generator>
void
generate(_ForwardIterator __first, _ForwardIterator __last,
_Generator __gen)
;
template<typename _OutputIterator, typename _Size, typename _Generator>
_OutputIterator
generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
;
template<typename _InputIterator, typename _OutputIterator>
_OutputIterator
unique_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result)
;
template<typename _InputIterator, typename _OutputIterator,
typename _BinaryPredicate>
_OutputIterator
unique_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result,
_BinaryPredicate __binary_pred)
;
template<typename _RandomAccessIterator>
void
random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
void
random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
_RandomNumberGenerator&& __rand)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _RandomAccessIterator>
void
partial_sort(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
partial_sort(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator>
void
nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _RandomAccessIterator>
void
sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
_OutputIterator
__merge(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
_OutputIterator
merge(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
_OutputIterator
merge(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator>
void
stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __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)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
_OutputIterator
set_union(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
_OutputIterator
set_union(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __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)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
_OutputIterator
set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
_OutputIterator
set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __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)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
_OutputIterator
set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
_OutputIterator
set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __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)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
_OutputIterator
set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
;
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)
;
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
__min_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _ForwardIterator>
_ForwardIterator
min_element(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
min_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
__max_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _ForwardIterator>
_ForwardIterator
max_element(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
max_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
}
namespace boost
{
template<class T> class shared_ptr;
template<class T> class weak_ptr;
template<class T> class enable_shared_from_this;
class enable_shared_from_raw;
namespace detail
{
template< class T > struct sp_element
{
typedef T type;
};
template< class T > struct sp_element< T[] >
{
typedef T type;
};
template< class T, std::size_t N > struct sp_element< T[N] >
{
typedef T type;
};
template< class T > struct sp_dereference
{
typedef T & type;
};
template<> struct sp_dereference< void >
{
typedef void type;
};
template<> struct sp_dereference< void const >
{
typedef void type;
};
template<> struct sp_dereference< void volatile >
{
typedef void type;
};
template<> struct sp_dereference< void const volatile >
{
typedef void type;
};
template< class T > struct sp_dereference< T[] >
{
typedef void type;
};
template< class T, std::size_t N > struct sp_dereference< T[N] >
{
typedef void type;
};
template< class T > struct sp_member_access
{
typedef T * type;
};
template< class T > struct sp_member_access< T[] >
{
typedef void type;
};
template< class T, std::size_t N > struct sp_member_access< T[N] >
{
typedef void type;
};
template< class T > struct sp_array_access
{
typedef void type;
};
template< class T > struct sp_array_access< T[] >
{
typedef T & type;
};
template< class T, std::size_t N > struct sp_array_access< T[N] >
{
typedef T & type;
};
template< class T > struct sp_extent
{
enum _vt { value = 0 };
};
template< class T, std::size_t N > struct sp_extent< T[N] >
{
enum _vt { value = N };
};
template< class X, class Y, class T > void sp_enable_shared_from_this( boost::shared_ptr<X> const * ppx, Y const * py, boost::enable_shared_from_this< T > const * pe )
;
template< class X, class Y > inline void sp_enable_shared_from_this( boost::shared_ptr<X> * ppx, Y const * py, boost::enable_shared_from_raw const * pe );
void sp_enable_shared_from_this( ... )
;
template< class T, class R > struct sp_enable_if_auto_ptr
{
};
template< class T, class R > struct sp_enable_if_auto_ptr< std::auto_ptr< T >, R >
{
typedef R type;
};
template< class Y, class T > void sp_assert_convertible()
;
template< class T, class Y > void sp_pointer_construct( boost::shared_ptr< T > * ppx, Y * p, boost::detail::shared_count & pn )
;
template< class T, class Y > void sp_pointer_construct( boost::shared_ptr< T[] > * , Y * p, boost::detail::shared_count & pn )
;
template< class T, std::size_t N, class Y > void sp_pointer_construct( boost::shared_ptr< T[N] > * , Y * p, boost::detail::shared_count & pn )
;
template< class T, class Y > void sp_deleter_construct( boost::shared_ptr< T > * ppx, Y * p )
;
template< class T, class Y > void sp_deleter_construct( boost::shared_ptr< T[] > * , Y * )
;
template< class T, std::size_t N, class Y > void sp_deleter_construct( boost::shared_ptr< T[N] > * , Y * )
;
}
template<class T> class shared_ptr
{
private:
typedef shared_ptr<T> this_type;
public:
typedef typename boost::detail::sp_element< T >::type element_type;
shared_ptr() noexcept : px( 0 ), pn()
{
}
shared_ptr( boost::detail::sp_nullptr_t ) noexcept : px( 0 ), pn()
{
}
template<class Y>
explicit shared_ptr( Y * p ): px( p ), pn()
{
boost::detail::sp_pointer_construct( this, p, pn );
}
template<class Y, class D> shared_ptr( Y * p, D d ): px( p ), pn( p, d )
{
boost::detail::sp_deleter_construct( this, p );
}
template<class D> shared_ptr( boost::detail::sp_nullptr_t p, D d ): px( p ), pn( p, d )
{
}
template<class Y, class D, class A> shared_ptr( Y * p, D d, A a ): px( p ), pn( p, d, a )
{
boost::detail::sp_deleter_construct( this, p );
}
template<class D, class A> shared_ptr( boost::detail::sp_nullptr_t p, D d, A a ): px( p ), pn( p, d, a )
{
}
shared_ptr( shared_ptr const & r ) noexcept : px( r.px ), pn( r.pn )
{
}
template<class Y>
explicit shared_ptr( weak_ptr<Y> const & r ): pn( r.pn )
{
boost::detail::sp_assert_convertible< Y, T >();
px = r.px;
}
template<class Y>
shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag )
noexcept : px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() )
{
if( !pn.empty() )
{
px = r.px;
}
}
template<class Y>
shared_ptr( shared_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
noexcept : px( r.px ), pn( r.pn )
{
boost::detail::sp_assert_convertible< Y, T >();
}
template< class Y >
shared_ptr( shared_ptr<Y> const & r, element_type * p ) noexcept : px( p ), pn( r.pn )
{
}
template<class Y>
explicit shared_ptr( std::auto_ptr<Y> & r ): px(r.get()), pn()
{
boost::detail::sp_assert_convertible< Y, T >();
Y * tmp = r.get();
pn = boost::detail::shared_count( r );
boost::detail::sp_deleter_construct( this, tmp );
}
template<class Y>
shared_ptr( std::auto_ptr<Y> && r ): px(r.get()), pn()
{
boost::detail::sp_assert_convertible< Y, T >();
Y * tmp = r.get();
pn = boost::detail::shared_count( r );
boost::detail::sp_deleter_construct( this, tmp );
}
template< class Y, class D >
shared_ptr( std::unique_ptr< Y, D > && r ): px( r.get() ), pn()
{
boost::detail::sp_assert_convertible< Y, T >();
typename std::unique_ptr< Y, D >::pointer tmp = r.get();
pn = boost::detail::shared_count( r );
boost::detail::sp_deleter_construct( this, tmp );
}
shared_ptr & operator=( shared_ptr const & r ) noexcept
{
this_type(r).swap(*this);
return *this;
}
template<class Y>
shared_ptr & operator=(shared_ptr<Y> const & r) noexcept
{
this_type(r).swap(*this);
return *this;
}
template<class Y>
shared_ptr & operator=( std::auto_ptr<Y> & r )
{
this_type( r ).swap( *this );
return *this;
}
template<class Y>
shared_ptr & operator=( std::auto_ptr<Y> && r )
{
this_type( static_cast< std::auto_ptr<Y> && >( r ) ).swap( *this );
return *this;
}
template<class Y, class D>
shared_ptr & operator=( std::unique_ptr<Y, D> && r )
{
this_type( static_cast< std::unique_ptr<Y, D> && >( r ) ).swap(*this);
return *this;
}
shared_ptr( shared_ptr && r ) noexcept : px( r.px ), pn()
{
pn.swap( r.pn );
r.px = 0;
}
template<class Y>
shared_ptr( shared_ptr<Y> && r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
noexcept : px( r.px ), pn()
{
boost::detail::sp_assert_convertible< Y, T >();
pn.swap( r.pn );
r.px = 0;
}
shared_ptr & operator=( shared_ptr && r ) noexcept
{
this_type( static_cast< shared_ptr && >( r ) ).swap( *this );
return *this;
}
template<class Y>
shared_ptr & operator=( shared_ptr<Y> && r ) noexcept
{
this_type( static_cast< shared_ptr<Y> && >( r ) ).swap( *this );
return *this;
}
shared_ptr & operator=( boost::detail::sp_nullptr_t ) noexcept
{
this_type().swap(*this);
return *this;
}
void reset() noexcept
{
this_type().swap(*this);
}
template<class Y> void reset( Y * p )
{
(static_cast<void> (0));
this_type( p ).swap( *this );
}
template<class Y, class D> void reset( Y * p, D d )
{
this_type( p, d ).swap( *this );
}
template<class Y, class D, class A> void reset( Y * p, D d, A a )
{
this_type( p, d, a ).swap( *this );
}
template<class Y> void reset( shared_ptr<Y> const & r, element_type * p )
{
this_type( r, p ).swap( *this );
}
typename boost::detail::sp_dereference< T >::type operator* () const
{
(static_cast<void> (0));
return *px;
}
typename boost::detail::sp_member_access< T >::type operator-> () const
{
(static_cast<void> (0));
return px;
}
typename boost::detail::sp_array_access< T >::type operator[] ( std::ptrdiff_t i ) const
{
(static_cast<void> (0));
(static_cast<void> (0));
return px[ i ];
}
element_type * get() const noexcept
{
return px;
}
explicit operator bool () const noexcept
{
return px != 0;
}
bool operator! () const noexcept
{
return px == 0;
}
bool unique() const noexcept
{
return pn.unique();
}
long use_count() const noexcept
{
return pn.use_count();
}
void swap( shared_ptr & other ) noexcept
{
std::swap(px, other.px);
pn.swap(other.pn);
}
template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const noexcept
{
return pn < rhs.pn;
}
template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const noexcept
{
return pn < rhs.pn;
}
void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const noexcept
{
return pn.get_deleter( ti );
}
void * _internal_get_untyped_deleter() const noexcept
{
return pn.get_untyped_deleter();
}
bool _internal_equiv( shared_ptr const & r ) const noexcept
{
return px == r.px && pn == r.pn;
}
private:
template<class Y> friend class shared_ptr;
template<class Y> friend class weak_ptr;
element_type * px;
boost::detail::shared_count pn;
};
template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept
{
return a.get() == b.get();
}
template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept
{
return a.get() != b.get();
}
template<class T> inline bool operator==( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) noexcept
{
return p.get() == 0;
}
template<class T> inline bool operator==( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) noexcept
{
return p.get() == 0;
}
template<class T> inline bool operator!=( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) noexcept
{
return p.get() != 0;
}
template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) noexcept
{
return p.get() != 0;
}
template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept
{
return a.owner_before( b );
}
template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b) noexcept
{
a.swap(b);
}
template<class T, class U> shared_ptr<T> static_pointer_cast( shared_ptr<U> const & r ) noexcept
{
(void) static_cast< T* >( static_cast< U* >( 0 ) );
typedef typename shared_ptr<T>::element_type E;
E * p = static_cast< E* >( r.get() );
return shared_ptr<T>( r, p );
}
template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> const & r ) noexcept
{
(void) const_cast< T* >( static_cast< U* >( 0 ) );
typedef typename shared_ptr<T>::element_type E;
E * p = const_cast< E* >( r.get() );
return shared_ptr<T>( r, p );
}
template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> const & r ) noexcept
{
(void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
typedef typename shared_ptr<T>::element_type E;
E * p = dynamic_cast< E* >( r.get() );
return p? shared_ptr<T>( r, p ): shared_ptr<T>();
}
template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U> const & r ) noexcept
{
(void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
typedef typename shared_ptr<T>::element_type E;
E * p = reinterpret_cast< E* >( r.get() );
return shared_ptr<T>( r, p );
}
template<class T> inline typename shared_ptr<T>::element_type * get_pointer(shared_ptr<T> const & p) noexcept
{
return p.get();
}
template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)
{
os << p.get();
return os;
}
namespace detail
{
template<class D, class T> D * basic_get_deleter( shared_ptr<T> const & p ) noexcept
{
return static_cast<D *>( p._internal_get_deleter(typeid(D)) );
}
class esft2_deleter_wrapper
{
private:
shared_ptr<void> deleter_;
public:
esft2_deleter_wrapper()
{
}
template< class T > void set_deleter( shared_ptr<T> const & deleter )
{
deleter_ = deleter;
}
template<typename D> D* get_deleter() const noexcept
{
return boost::detail::basic_get_deleter<D>( deleter_ );
}
template< class T> void operator()( T* )
{
(static_cast<void> (0));
deleter_.reset();
}
};
}
template<class D, class T> D * get_deleter( shared_ptr<T> const & p ) noexcept
{
D *del = boost::detail::basic_get_deleter<D>(p);
if(del == 0)
{
boost::detail::esft2_deleter_wrapper *del_wrapper = boost::detail::basic_get_deleter<boost::detail::esft2_deleter_wrapper>(p);
if(del_wrapper) del = del_wrapper->::boost::detail::esft2_deleter_wrapper::get_deleter<D>();
}
return del;
}
template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * ) noexcept
{
return false;
}
template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p )
{
boost::detail::spinlock_pool<2>::scoped_lock lock( p );
return *p;
}
template<class T> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, memory_order )
{
return atomic_load( p );
}
template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r )
{
boost::detail::spinlock_pool<2>::scoped_lock lock( p );
p->swap( r );
}
template<class T> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order )
{
atomic_store( p, r );
}
template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r )
{
boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
sp.lock();
p->swap( r );
sp.unlock();
return r;
}
template<class T> shared_ptr<T> atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order )
{
return atomic_exchange( p, r );
}
template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w )
{
boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
sp.lock();
if( p->_internal_equiv( *v ) )
{
p->swap( w );
sp.unlock();
return true;
}
else
{
shared_ptr<T> tmp( *p );
sp.unlock();
tmp.swap( *v );
return false;
}
}
template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, memory_order , memory_order )
{
return atomic_compare_exchange( p, v, w );
}
template< class T > struct hash;
template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p ) noexcept
{
return boost::hash< T* >()( p.get() );
}
}
namespace boost {
namespace date_time {
template<class time_type>
class second_clock
{
public:
typedef typename time_type::date_type date_type;
typedef typename time_type::time_duration_type time_duration_type;
static time_type local_time()
;
static time_type universal_time()
;
template<class time_zone_type>
static time_type local_time(boost::shared_ptr<time_zone_type> tz_ptr)
;
private:
static time_type create_time(::std::tm* current)
;
};
} }
#define DATE_TIME_HIGHRES_TIME_CLOCK_HPP___
#define DATE_TIME_FILETIME_FUNCTIONS_HPP__
namespace boost {
namespace date_time {
template<class time_type>
class microsec_clock
{
private:
typedef std::tm* (*time_converter)(const std::time_t*, std::tm*);
public:
typedef typename time_type::date_type date_type;
typedef typename time_type::time_duration_type time_duration_type;
typedef typename time_duration_type::rep_type resolution_traits_type;
template<class time_zone_type>
static time_type local_time(shared_ptr<time_zone_type> tz_ptr)
;
static time_type local_time()
;
static time_type universal_time()
;
private:
static time_type create_time(time_converter converter)
;
};
} }
#define POSIX_PTIME_HPP___
#define POSIX_TIME_SYSTEM_HPP___
#define POSIX_TIME_CONFIG_HPP___
#define BOOST_CONFIG_CMATH
#define BOOST_TR1_NO_RECURSION
#define BOOST_CONFIG_NO_CMATH_RECURSION
#undef BOOST_TR1_NO_RECURSION
#undef BOOST_CONFIG_NO_CMATH_RECURSION
#define DATE_TIME_TIME_DURATION_HPP___
#define BOOST_STATIC_ASSERT_HPP
#define BOOST_STATIC_ASSERT_MSG(...) static_assert(__VA_ARGS__)
#define BOOST_STATIC_ASSERT_BOOL_CAST(...) ((__VA_ARGS__) == 0 ? false : true)
#define BOOST_STATIC_ASSERT_UNUSED_ATTRIBUTE __attribute__((unused))
#define BOOST_STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
#define DATE_TIME_TIME_PRECISION_LIMITS_HPP
namespace boost {
namespace date_time {
enum time_resolutions {
sec,
tenth,
hundreth,
hundredth = hundreth,
milli,
ten_thousandth,
micro,
nano,
NumResolutions
};
enum dst_flags {not_dst, is_dst, calculate};
} }
#define DATE_TIME_SPECIAL_DEFS_HPP__
namespace boost {
namespace date_time {
enum special_values {not_a_date_time,
neg_infin, pos_infin,
min_date_time, max_date_time,
not_special, NumSpecialValues};
} }
namespace boost {
namespace date_time {
template<class T, typename rep_type>
class time_duration : private
boost::less_than_comparable<T
, boost::equality_comparable<T
> >
{
public:
typedef T duration_type;
typedef rep_type traits_type;
typedef typename rep_type::day_type day_type;
typedef typename rep_type::hour_type hour_type;
typedef typename rep_type::min_type min_type;
typedef typename rep_type::sec_type sec_type;
typedef typename rep_type::fractional_seconds_type fractional_seconds_type;
typedef typename rep_type::tick_type tick_type;
typedef typename rep_type::impl_type impl_type;
time_duration() ;
time_duration(hour_type hours_in,
min_type minutes_in,
sec_type seconds_in=0,
fractional_seconds_type frac_sec_in = 0)
;
time_duration(const time_duration<T, rep_type>& other)
;
time_duration(special_values sv)
;
static duration_type unit()
;
static tick_type ticks_per_second()
;
static time_resolutions resolution()
;
hour_type hours() const
;
min_type minutes() const
;
sec_type seconds() const
;
sec_type total_seconds() const
;
tick_type total_milliseconds() const
;
tick_type total_nanoseconds() const
;
tick_type total_microseconds() const
;
fractional_seconds_type fractional_seconds() const
;
static unsigned short num_fractional_digits()
;
duration_type invert_sign() const
;
bool is_negative() const
;
bool operator<(const time_duration& rhs) const
;
bool operator==(const time_duration& rhs) const
;
duration_type operator-()const
;
duration_type operator-(const duration_type& d) const
;
duration_type operator+(const duration_type& d) const
;
duration_type operator/(int divisor) const
;
duration_type operator-=(const duration_type& d)
;
duration_type operator+=(const duration_type& d)
;
duration_type operator/=(int divisor)
;
duration_type operator*(int rhs) const
;
duration_type operator*=(int divisor)
;
tick_type ticks() const
;
bool is_special()const
;
bool is_pos_infinity()const
;
bool is_neg_infinity()const
;
bool is_not_a_date_time()const
;
impl_type get_rep()const
;
protected:
explicit time_duration(impl_type in) ;
impl_type ticks_;
};
template<class base_duration, boost::int64_t frac_of_second>
class subsecond_duration : public base_duration
{
public:
typedef typename base_duration::impl_type impl_type;
typedef typename base_duration::traits_type traits_type;
private:
static_assert((traits_type::ticks_per_second >= frac_of_second ? traits_type::ticks_per_second % frac_of_second : frac_of_second % traits_type::ticks_per_second) == 0, "The base duration resolution must be a multiple of the subsecond duration resolution");
static const boost::int64_t adjustment_ratio = (traits_type::ticks_per_second >= frac_of_second ? traits_type::ticks_per_second / frac_of_second : frac_of_second / traits_type::ticks_per_second);
public:
explicit subsecond_duration(boost::int64_t ss)
;
};
} }
#define DATE_TIME_TIME_RESOLUTION_TRAITS_HPP
#define _DATE_TIME_INT_ADAPTER_HPP__
namespace boost {
namespace date_time {
template<typename int_type_>
class int_adapter {
public:
typedef int_type_ int_type;
int_adapter(int_type v)
;
static bool has_infinity()
;
static const int_adapter pos_infinity()
;
static const int_adapter neg_infinity()
;
static const int_adapter not_a_number()
;
static int_adapter max ()
;
static int_adapter min ()
;
static int_adapter from_special(special_values sv)
;
static bool is_inf(int_type v)
;
static bool is_neg_inf(int_type v)
;
static bool is_pos_inf(int_type v)
;
static bool is_not_a_number(int_type v)
;
static special_values to_special(int_type v)
;
static int_type maxcount()
;
bool is_infinity() const
;
bool is_pos_infinity()const
;
bool is_neg_infinity()const
;
bool is_nan() const
;
bool is_special() const
;
bool operator==(const int_adapter& rhs) const
;
bool operator==(const int& rhs) const
;
bool operator!=(const int_adapter& rhs) const
;
bool operator!=(const int& rhs) const
;
bool operator<(const int_adapter& rhs) const
;
bool operator<(const int& rhs) const
;
bool operator>(const int_adapter& rhs) const
;
int_type as_number() const
;
special_values as_special() const
;
template<class rhs_type>
int_adapter operator+(const int_adapter<rhs_type>& rhs) const
;
int_adapter operator+(const int_type rhs) const
;
template<class rhs_type>
int_adapter operator-(const int_adapter<rhs_type>& rhs)const
;
int_adapter operator-(const int_type rhs) const
;
int_adapter operator*(const int_adapter& rhs)const
;
int_adapter operator*(const int rhs) const
;
int_adapter operator/(const int_adapter& rhs)const
;
int_adapter operator/(const int rhs) const
;
int_adapter operator%(const int_adapter& rhs)const
;
int_adapter operator%(const int rhs) const
;
private:
int_type value_;
int compare(const int_adapter& rhs)const
;
int_adapter mult_div_specials(const int_adapter& rhs)const
;
int_adapter mult_div_specials(const int& rhs) const
;
};
template<class charT, class traits, typename int_type>
std::basic_ostream<charT, traits>&
operator<<(std::basic_ostream<charT, traits>& os, const int_adapter<int_type>& ia)
;
} }
namespace boost {
namespace date_time {
template <typename T>
T absolute_value(T x)
;
struct time_resolution_traits_bi32_impl {
typedef boost::int32_t int_type;
typedef boost::int32_t impl_type;
static int_type as_number(impl_type i);
static bool is_adapted() ;
};
struct time_resolution_traits_adapted32_impl {
typedef boost::int32_t int_type;
typedef boost::date_time::int_adapter<boost::int32_t> impl_type;
static int_type as_number(impl_type i);
static bool is_adapted() ;
};
struct time_resolution_traits_bi64_impl {
typedef boost::int64_t int_type;
typedef boost::int64_t impl_type;
static int_type as_number(impl_type i);
static bool is_adapted() ;
};
struct time_resolution_traits_adapted64_impl {
typedef boost::int64_t int_type;
typedef boost::date_time::int_adapter<boost::int64_t> impl_type;
static int_type as_number(impl_type i);
static bool is_adapted() ;
};
template<typename frac_sec_type,
time_resolutions res,
typename frac_sec_type::int_type resolution_adjust,
unsigned short frac_digits,
typename v_type = boost::int32_t >
class time_resolution_traits {
public:
typedef typename frac_sec_type::int_type fractional_seconds_type;
typedef typename frac_sec_type::int_type tick_type;
typedef typename frac_sec_type::impl_type impl_type;
typedef v_type day_type;
typedef v_type hour_type;
typedef v_type min_type;
typedef v_type sec_type;
static fractional_seconds_type as_number(impl_type i)
;
static bool is_adapted()
;
static const fractional_seconds_type ticks_per_second = resolution_adjust;
static time_resolutions resolution()
;
static unsigned short num_fractional_digits()
;
static fractional_seconds_type res_adjust()
;
static tick_type to_tick_count(hour_type hours,
min_type minutes,
sec_type seconds,
fractional_seconds_type fs)
;
};
typedef time_resolution_traits<time_resolution_traits_adapted32_impl, milli, 1000, 3 > milli_res;
typedef time_resolution_traits<time_resolution_traits_adapted64_impl, micro, 1000000, 6 > micro_res;
typedef time_resolution_traits<time_resolution_traits_adapted64_impl, nano, 1000000000, 9 > nano_res;
} }
#define _GREGORIAN_TYPES_HPP__
#define DATE_TIME_DATE_HPP___
#define YearMonthDayBase_HPP__
namespace boost {
namespace date_time {
template<typename YearType, typename MonthType, typename DayType>
struct year_month_day_base {
year_month_day_base(YearType year,
MonthType month,
DayType day);
YearType year;
MonthType month;
DayType day;
typedef YearType year_type;
typedef MonthType month_type;
typedef DayType day_type;
};
} }
namespace boost {
namespace date_time {
template<class T, class calendar, class duration_type_>
class date : private
boost::less_than_comparable<T
, boost::equality_comparable<T
> >
{
public:
typedef T date_type;
typedef calendar calendar_type;
typedef typename calendar::date_traits_type traits_type;
typedef duration_type_ duration_type;
typedef typename calendar::year_type year_type;
typedef typename calendar::month_type month_type;
typedef typename calendar::day_type day_type;
typedef typename calendar::ymd_type ymd_type;
typedef typename calendar::date_rep_type date_rep_type;
typedef typename calendar::date_int_type date_int_type;
typedef typename calendar::day_of_week_type day_of_week_type;
date(year_type y, month_type m, day_type d)
;
date(const ymd_type& ymd)
;
year_type year() const
;
month_type month() const
;
day_type day() const
;
day_of_week_type day_of_week() const
;
ymd_type year_month_day() const
;
bool operator<(const date_type& rhs) const
;
bool operator==(const date_type& rhs) const
;
bool is_special()const
;
bool is_not_a_date() const
;
bool is_infinity() const
;
bool is_pos_infinity() const
;
bool is_neg_infinity() const
;
special_values as_special() const
;
duration_type operator-(const date_type& d) const
;
date_type operator-(const duration_type& dd) const
;
date_type operator-=(const duration_type& dd)
;
date_rep_type day_count() const
;
date_type operator+(const duration_type& dd) const
;
date_type operator+=(const duration_type& dd)
;
protected:
explicit date(date_int_type days) ;
explicit date(date_rep_type days) ;
date_int_type days_;
};
} }
#define DATE_TIME_PERIOD_HPP___
namespace boost {
namespace date_time {
template<class point_rep, class duration_rep>
class period : private
boost::less_than_comparable<period<point_rep, duration_rep>
, boost::equality_comparable< period<point_rep, duration_rep>
> >
{
public:
typedef point_rep point_type;
typedef duration_rep duration_type;
period(point_rep first_point, point_rep end_point);
period(point_rep first_point, duration_rep len);
point_rep begin() const;
point_rep end() const;
point_rep last() const;
duration_rep length() const;
bool is_null() const;
bool operator==(const period& rhs) const;
bool operator<(const period& rhs) const;
void shift(const duration_rep& d);
void expand(const duration_rep& d);
bool contains(const point_rep& point) const;
bool contains(const period& other) const;
bool intersects(const period& other) const;
bool is_adjacent(const period& other) const;
bool is_before(const point_rep& point) const;
bool is_after(const point_rep& point) const;
period intersection(const period& other) const;
period merge(const period& other) const;
period span(const period& other) const;
private:
point_rep begin_;
point_rep last_;
};
} }
#define GREGORIAN_GREGORIAN_CALENDAR_HPP__
#define GREG_WEEKDAY_HPP___
#define CONSTRAINED_VALUE_HPP___
#define BOOST_MPL_IF_HPP_INCLUDED
#define BOOST_MPL_AUX_VALUE_WKND_HPP_INCLUDED
#define BOOST_MPL_AUX_STATIC_CAST_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED
#define BOOST_MPL_AUX_STATIC_CAST(T,expr) static_cast<T>(expr)
#define BOOST_MPL_AUX_CONFIG_INTEGRAL_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_ETI_HPP_INCLUDED
#define BOOST_MPL_AUX_VALUE_WKND(C) C
#define BOOST_MPL_AUX_MSVC_VALUE_WKND(C) C
#define BOOST_MPL_AUX_NESTED_VALUE_WKND(T,C) BOOST_MPL_AUX_VALUE_WKND(C)::value
namespace boost { namespace mpl { namespace aux {
template< typename T > struct value_type_wknd
{
typedef typename T::value_type type;
};
}}}
#define BOOST_MPL_AUX_NA_SPEC_HPP_INCLUDED
#define BOOST_MPL_LAMBDA_FWD_HPP_INCLUDED
#define BOOST_MPL_VOID_FWD_HPP_INCLUDED
#define BOOST_MPL_AUX_ADL_BARRIER_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_ADL_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_INTEL_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_GCC_HPP_INCLUDED
#define BOOST_MPL_CFG_GCC ((__GNUC__ << 8) | __GNUC_MINOR__)
#define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE mpl_
#define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN namespace mpl_ {
#define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE }
#define BOOST_MPL_AUX_ADL_BARRIER_DECL(type) namespace boost { namespace mpl { using ::BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::type; } }
namespace mpl_ { namespace aux {} }
namespace boost { namespace mpl { using namespace mpl_;
namespace aux { using namespace mpl_::aux; }
}}
namespace mpl_ {
struct void_;
}
namespace boost { namespace mpl { using ::mpl_::void_; } }
#define BOOST_MPL_AUX_NA_HPP_INCLUDED
#define BOOST_MPL_BOOL_HPP_INCLUDED
#define BOOST_MPL_BOOL_FWD_HPP_INCLUDED
namespace mpl_ {
template< bool C_ > struct bool_;
typedef bool_<true> true_;
typedef bool_<false> false_;
}
namespace boost { namespace mpl { using ::mpl_::bool_; } }
namespace boost { namespace mpl { using ::mpl_::true_; } }
namespace boost { namespace mpl { using ::mpl_::false_; } }
#define BOOST_MPL_INTEGRAL_C_TAG_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED
namespace mpl_ {
struct integral_c_tag { static const int value = 0; };
}
namespace boost { namespace mpl { using ::mpl_::integral_c_tag; } }
namespace mpl_ {
template< bool C_ > struct bool_
{
static const bool value = C_;
typedef integral_c_tag tag;
typedef bool_ type;
typedef bool value_type;
operator bool() const ;
};
template< bool C_ >
bool const bool_<C_>::value;
}
#define BOOST_MPL_AUX_NA_FWD_HPP_INCLUDED
namespace mpl_ {
struct na
{
typedef na type;
enum { value = 0 };
};
}
namespace boost { namespace mpl { using ::mpl_::na; } }
#define BOOST_MPL_AUX_CONFIG_CTPS_HPP_INCLUDED
namespace boost { namespace mpl {
template< typename T >
struct is_na
: false_
{
};
template<>
struct is_na<na>
: true_
{
};
template< typename T >
struct is_not_na
: true_
{
};
template<>
struct is_not_na<na>
: false_
{
};
template< typename T, typename U > struct if_na
{
typedef T type;
};
template< typename U > struct if_na<na,U>
{
typedef U type;
};
}}
#define BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_TTP_HPP_INCLUDED
#define BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING
#define BOOST_MPL_INT_HPP_INCLUDED
#define BOOST_MPL_INT_FWD_HPP_INCLUDED
#define BOOST_MPL_AUX_NTTP_DECL_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_NTTP_HPP_INCLUDED
#define BOOST_MPL_AUX_NTTP_DECL(T,x) T x
namespace mpl_ {
template< int N > struct int_;
}
namespace boost { namespace mpl { using ::mpl_::int_; } }
#define AUX_WRAPPER_VALUE_TYPE int
#define BOOST_PREPROCESSOR_CAT_HPP
#define BOOST_PREPROCESSOR_CONFIG_CONFIG_HPP
#define BOOST_PP_CONFIG_STRICT() 0x0001
#define BOOST_PP_CONFIG_IDEAL() 0x0002
#define BOOST_PP_CONFIG_MSVC() 0x0004
#define BOOST_PP_CONFIG_MWCC() 0x0008
#define BOOST_PP_CONFIG_BCC() 0x0010
#define BOOST_PP_CONFIG_EDG() 0x0020
#define BOOST_PP_CONFIG_DMC() 0x0040
#define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT())
#define BOOST_PP_CONFIG_EXTENDED_LINE_INFO 0
#define BOOST_PP_CONFIG_ERRORS 0
#define BOOST_PP_VARIADICS 1
#define BOOST_PP_CAT(a,b) BOOST_PP_CAT_I(a, b)
#define BOOST_PP_CAT_I(a,b) a ## b
#define AUX_WRAPPER_NAME BOOST_PP_CAT(AUX_WRAPPER_VALUE_TYPE,_)
#define AUX_WRAPPER_PARAMS(N) BOOST_MPL_AUX_NTTP_DECL(AUX_WRAPPER_VALUE_TYPE, N)
#define AUX_WRAPPER_INST(value) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::AUX_WRAPPER_NAME< value >
namespace mpl_ {
template< int N >
struct int_
{
static const int value = N;
typedef int_ type;
typedef int value_type;
typedef integral_c_tag tag;
typedef mpl_::int_< static_cast<int>((value + 1)) > next;
typedef mpl_::int_< static_cast<int>((value - 1)) > prior;
operator int() const ;
};
template< int N >
int const mpl_::int_< N >::value;
}
#undef AUX_WRAPPER_NAME
#undef AUX_WRAPPER_PARAMS
#undef AUX_WRAPPER_INST
#undef AUX_WRAPPER_VALUE_TYPE
#define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED
#define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(param) , param
#define BOOST_MPL_AUX_TEMPLATE_ARITY_FWD_HPP_INCLUDED
namespace boost { namespace mpl { namespace aux {
template< typename F > struct template_arity;
}}}
namespace boost { namespace mpl {
template<
typename T = na
, typename Tag = void_
, typename Arity = int_< aux::template_arity<T>::value >
>
struct lambda;
}}
#define BOOST_MPL_AUX_ARITY_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_DTP_HPP_INCLUDED
#define BOOST_MPL_AUX_PREPROCESSOR_PARAMS_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_PREPROCESSOR_HPP_INCLUDED
#define BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES
#define BOOST_PREPROCESSOR_COMMA_IF_HPP
#define BOOST_PREPROCESSOR_PUNCTUATION_COMMA_IF_HPP
#define BOOST_PREPROCESSOR_CONTROL_IF_HPP
#define BOOST_PREPROCESSOR_CONTROL_IIF_HPP
#define BOOST_PP_IIF(bit,t,f) BOOST_PP_IIF_I(bit, t, f)
#define BOOST_PP_IIF_I(bit,t,f) BOOST_PP_IIF_ ## bit(t, f)
#define BOOST_PP_IIF_0(t,f) f
#define BOOST_PP_IIF_1(t,f) t
#define BOOST_PREPROCESSOR_LOGICAL_BOOL_HPP
#define BOOST_PP_BOOL(x) BOOST_PP_BOOL_I(x)
#define BOOST_PP_BOOL_I(x) BOOST_PP_BOOL_ ## x
#define BOOST_PP_BOOL_0 0
#define BOOST_PP_BOOL_1 1
#define BOOST_PP_BOOL_2 1
#define BOOST_PP_BOOL_3 1
#define BOOST_PP_BOOL_4 1
#define BOOST_PP_BOOL_5 1
#define BOOST_PP_BOOL_6 1
#define BOOST_PP_BOOL_7 1
#define BOOST_PP_BOOL_8 1
#define BOOST_PP_BOOL_9 1
#define BOOST_PP_BOOL_10 1
#define BOOST_PP_BOOL_11 1
#define BOOST_PP_BOOL_12 1
#define BOOST_PP_BOOL_13 1
#define BOOST_PP_BOOL_14 1
#define BOOST_PP_BOOL_15 1
#define BOOST_PP_BOOL_16 1
#define BOOST_PP_BOOL_17 1
#define BOOST_PP_BOOL_18 1
#define BOOST_PP_BOOL_19 1
#define BOOST_PP_BOOL_20 1
#define BOOST_PP_BOOL_21 1
#define BOOST_PP_BOOL_22 1
#define BOOST_PP_BOOL_23 1
#define BOOST_PP_BOOL_24 1
#define BOOST_PP_BOOL_25 1
#define BOOST_PP_BOOL_26 1
#define BOOST_PP_BOOL_27 1
#define BOOST_PP_BOOL_28 1
#define BOOST_PP_BOOL_29 1
#define BOOST_PP_BOOL_30 1
#define BOOST_PP_BOOL_31 1
#define BOOST_PP_BOOL_32 1
#define BOOST_PP_BOOL_33 1
#define BOOST_PP_BOOL_34 1
#define BOOST_PP_BOOL_35 1
#define BOOST_PP_BOOL_36 1
#define BOOST_PP_BOOL_37 1
#define BOOST_PP_BOOL_38 1
#define BOOST_PP_BOOL_39 1
#define BOOST_PP_BOOL_40 1
#define BOOST_PP_BOOL_41 1
#define BOOST_PP_BOOL_42 1
#define BOOST_PP_BOOL_43 1
#define BOOST_PP_BOOL_44 1
#define BOOST_PP_BOOL_45 1
#define BOOST_PP_BOOL_46 1
#define BOOST_PP_BOOL_47 1
#define BOOST_PP_BOOL_48 1
#define BOOST_PP_BOOL_49 1
#define BOOST_PP_BOOL_50 1
#define BOOST_PP_BOOL_51 1
#define BOOST_PP_BOOL_52 1
#define BOOST_PP_BOOL_53 1
#define BOOST_PP_BOOL_54 1
#define BOOST_PP_BOOL_55 1
#define BOOST_PP_BOOL_56 1
#define BOOST_PP_BOOL_57 1
#define BOOST_PP_BOOL_58 1
#define BOOST_PP_BOOL_59 1
#define BOOST_PP_BOOL_60 1
#define BOOST_PP_BOOL_61 1
#define BOOST_PP_BOOL_62 1
#define BOOST_PP_BOOL_63 1
#define BOOST_PP_BOOL_64 1
#define BOOST_PP_BOOL_65 1
#define BOOST_PP_BOOL_66 1
#define BOOST_PP_BOOL_67 1
#define BOOST_PP_BOOL_68 1
#define BOOST_PP_BOOL_69 1
#define BOOST_PP_BOOL_70 1
#define BOOST_PP_BOOL_71 1
#define BOOST_PP_BOOL_72 1
#define BOOST_PP_BOOL_73 1
#define BOOST_PP_BOOL_74 1
#define BOOST_PP_BOOL_75 1
#define BOOST_PP_BOOL_76 1
#define BOOST_PP_BOOL_77 1
#define BOOST_PP_BOOL_78 1
#define BOOST_PP_BOOL_79 1
#define BOOST_PP_BOOL_80 1
#define BOOST_PP_BOOL_81 1
#define BOOST_PP_BOOL_82 1
#define BOOST_PP_BOOL_83 1
#define BOOST_PP_BOOL_84 1
#define BOOST_PP_BOOL_85 1
#define BOOST_PP_BOOL_86 1
#define BOOST_PP_BOOL_87 1
#define BOOST_PP_BOOL_88 1
#define BOOST_PP_BOOL_89 1
#define BOOST_PP_BOOL_90 1
#define BOOST_PP_BOOL_91 1
#define BOOST_PP_BOOL_92 1
#define BOOST_PP_BOOL_93 1
#define BOOST_PP_BOOL_94 1
#define BOOST_PP_BOOL_95 1
#define BOOST_PP_BOOL_96 1
#define BOOST_PP_BOOL_97 1
#define BOOST_PP_BOOL_98 1
#define BOOST_PP_BOOL_99 1
#define BOOST_PP_BOOL_100 1
#define BOOST_PP_BOOL_101 1
#define BOOST_PP_BOOL_102 1
#define BOOST_PP_BOOL_103 1
#define BOOST_PP_BOOL_104 1
#define BOOST_PP_BOOL_105 1
#define BOOST_PP_BOOL_106 1
#define BOOST_PP_BOOL_107 1
#define BOOST_PP_BOOL_108 1
#define BOOST_PP_BOOL_109 1
#define BOOST_PP_BOOL_110 1
#define BOOST_PP_BOOL_111 1
#define BOOST_PP_BOOL_112 1
#define BOOST_PP_BOOL_113 1
#define BOOST_PP_BOOL_114 1
#define BOOST_PP_BOOL_115 1
#define BOOST_PP_BOOL_116 1
#define BOOST_PP_BOOL_117 1
#define BOOST_PP_BOOL_118 1
#define BOOST_PP_BOOL_119 1
#define BOOST_PP_BOOL_120 1
#define BOOST_PP_BOOL_121 1
#define BOOST_PP_BOOL_122 1
#define BOOST_PP_BOOL_123 1
#define BOOST_PP_BOOL_124 1
#define BOOST_PP_BOOL_125 1
#define BOOST_PP_BOOL_126 1
#define BOOST_PP_BOOL_127 1
#define BOOST_PP_BOOL_128 1
#define BOOST_PP_BOOL_129 1
#define BOOST_PP_BOOL_130 1
#define BOOST_PP_BOOL_131 1
#define BOOST_PP_BOOL_132 1
#define BOOST_PP_BOOL_133 1
#define BOOST_PP_BOOL_134 1
#define BOOST_PP_BOOL_135 1
#define BOOST_PP_BOOL_136 1
#define BOOST_PP_BOOL_137 1
#define BOOST_PP_BOOL_138 1
#define BOOST_PP_BOOL_139 1
#define BOOST_PP_BOOL_140 1
#define BOOST_PP_BOOL_141 1
#define BOOST_PP_BOOL_142 1
#define BOOST_PP_BOOL_143 1
#define BOOST_PP_BOOL_144 1
#define BOOST_PP_BOOL_145 1
#define BOOST_PP_BOOL_146 1
#define BOOST_PP_BOOL_147 1
#define BOOST_PP_BOOL_148 1
#define BOOST_PP_BOOL_149 1
#define BOOST_PP_BOOL_150 1
#define BOOST_PP_BOOL_151 1
#define BOOST_PP_BOOL_152 1
#define BOOST_PP_BOOL_153 1
#define BOOST_PP_BOOL_154 1
#define BOOST_PP_BOOL_155 1
#define BOOST_PP_BOOL_156 1
#define BOOST_PP_BOOL_157 1
#define BOOST_PP_BOOL_158 1
#define BOOST_PP_BOOL_159 1
#define BOOST_PP_BOOL_160 1
#define BOOST_PP_BOOL_161 1
#define BOOST_PP_BOOL_162 1
#define BOOST_PP_BOOL_163 1
#define BOOST_PP_BOOL_164 1
#define BOOST_PP_BOOL_165 1
#define BOOST_PP_BOOL_166 1
#define BOOST_PP_BOOL_167 1
#define BOOST_PP_BOOL_168 1
#define BOOST_PP_BOOL_169 1
#define BOOST_PP_BOOL_170 1
#define BOOST_PP_BOOL_171 1
#define BOOST_PP_BOOL_172 1
#define BOOST_PP_BOOL_173 1
#define BOOST_PP_BOOL_174 1
#define BOOST_PP_BOOL_175 1
#define BOOST_PP_BOOL_176 1
#define BOOST_PP_BOOL_177 1
#define BOOST_PP_BOOL_178 1
#define BOOST_PP_BOOL_179 1
#define BOOST_PP_BOOL_180 1
#define BOOST_PP_BOOL_181 1
#define BOOST_PP_BOOL_182 1
#define BOOST_PP_BOOL_183 1
#define BOOST_PP_BOOL_184 1
#define BOOST_PP_BOOL_185 1
#define BOOST_PP_BOOL_186 1
#define BOOST_PP_BOOL_187 1
#define BOOST_PP_BOOL_188 1
#define BOOST_PP_BOOL_189 1
#define BOOST_PP_BOOL_190 1
#define BOOST_PP_BOOL_191 1
#define BOOST_PP_BOOL_192 1
#define BOOST_PP_BOOL_193 1
#define BOOST_PP_BOOL_194 1
#define BOOST_PP_BOOL_195 1
#define BOOST_PP_BOOL_196 1
#define BOOST_PP_BOOL_197 1
#define BOOST_PP_BOOL_198 1
#define BOOST_PP_BOOL_199 1
#define BOOST_PP_BOOL_200 1
#define BOOST_PP_BOOL_201 1
#define BOOST_PP_BOOL_202 1
#define BOOST_PP_BOOL_203 1
#define BOOST_PP_BOOL_204 1
#define BOOST_PP_BOOL_205 1
#define BOOST_PP_BOOL_206 1
#define BOOST_PP_BOOL_207 1
#define BOOST_PP_BOOL_208 1
#define BOOST_PP_BOOL_209 1
#define BOOST_PP_BOOL_210 1
#define BOOST_PP_BOOL_211 1
#define BOOST_PP_BOOL_212 1
#define BOOST_PP_BOOL_213 1
#define BOOST_PP_BOOL_214 1
#define BOOST_PP_BOOL_215 1
#define BOOST_PP_BOOL_216 1
#define BOOST_PP_BOOL_217 1
#define BOOST_PP_BOOL_218 1
#define BOOST_PP_BOOL_219 1
#define BOOST_PP_BOOL_220 1
#define BOOST_PP_BOOL_221 1
#define BOOST_PP_BOOL_222 1
#define BOOST_PP_BOOL_223 1
#define BOOST_PP_BOOL_224 1
#define BOOST_PP_BOOL_225 1
#define BOOST_PP_BOOL_226 1
#define BOOST_PP_BOOL_227 1
#define BOOST_PP_BOOL_228 1
#define BOOST_PP_BOOL_229 1
#define BOOST_PP_BOOL_230 1
#define BOOST_PP_BOOL_231 1
#define BOOST_PP_BOOL_232 1
#define BOOST_PP_BOOL_233 1
#define BOOST_PP_BOOL_234 1
#define BOOST_PP_BOOL_235 1
#define BOOST_PP_BOOL_236 1
#define BOOST_PP_BOOL_237 1
#define BOOST_PP_BOOL_238 1
#define BOOST_PP_BOOL_239 1
#define BOOST_PP_BOOL_240 1
#define BOOST_PP_BOOL_241 1
#define BOOST_PP_BOOL_242 1
#define BOOST_PP_BOOL_243 1
#define BOOST_PP_BOOL_244 1
#define BOOST_PP_BOOL_245 1
#define BOOST_PP_BOOL_246 1
#define BOOST_PP_BOOL_247 1
#define BOOST_PP_BOOL_248 1
#define BOOST_PP_BOOL_249 1
#define BOOST_PP_BOOL_250 1
#define BOOST_PP_BOOL_251 1
#define BOOST_PP_BOOL_252 1
#define BOOST_PP_BOOL_253 1
#define BOOST_PP_BOOL_254 1
#define BOOST_PP_BOOL_255 1
#define BOOST_PP_BOOL_256 1
#define BOOST_PP_IF(cond,t,f) BOOST_PP_IIF(BOOST_PP_BOOL(cond), t, f)
#define BOOST_PREPROCESSOR_FACILITIES_EMPTY_HPP
#define BOOST_PP_EMPTY()
#define BOOST_PREPROCESSOR_PUNCTUATION_COMMA_HPP
#define BOOST_PP_COMMA() ,
#define BOOST_PP_COMMA_IF(cond) BOOST_PP_IF(cond, BOOST_PP_COMMA, BOOST_PP_EMPTY)()
#define BOOST_PREPROCESSOR_REPEAT_HPP
#define BOOST_PREPROCESSOR_REPETITION_REPEAT_HPP
#define BOOST_PREPROCESSOR_DEBUG_ERROR_HPP
#define BOOST_PP_ERROR_0x0000 BOOST_PP_ERROR(0x0000, BOOST_PP_INDEX_OUT_OF_BOUNDS)
#define BOOST_PP_ERROR_0x0001 BOOST_PP_ERROR(0x0001, BOOST_PP_WHILE_OVERFLOW)
#define BOOST_PP_ERROR_0x0002 BOOST_PP_ERROR(0x0002, BOOST_PP_FOR_OVERFLOW)
#define BOOST_PP_ERROR_0x0003 BOOST_PP_ERROR(0x0003, BOOST_PP_REPEAT_OVERFLOW)
#define BOOST_PP_ERROR_0x0004 BOOST_PP_ERROR(0x0004, BOOST_PP_LIST_FOLD_OVERFLOW)
#define BOOST_PP_ERROR_0x0005 BOOST_PP_ERROR(0x0005, BOOST_PP_SEQ_FOLD_OVERFLOW)
#define BOOST_PP_ERROR_0x0006 BOOST_PP_ERROR(0x0006, BOOST_PP_ARITHMETIC_OVERFLOW)
#define BOOST_PP_ERROR_0x0007 BOOST_PP_ERROR(0x0007, BOOST_PP_DIVISION_BY_ZERO)
#define BOOST_PREPROCESSOR_DETAIL_AUTO_REC_HPP
#define BOOST_PP_AUTO_REC(pred,n) BOOST_PP_NODE_ENTRY_ ## n(pred)
#define BOOST_PP_NODE_ENTRY_256(p) BOOST_PP_NODE_128(p)(p)(p)(p)(p)(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_128(p) BOOST_PP_NODE_64(p)(p)(p)(p)(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_64(p) BOOST_PP_NODE_32(p)(p)(p)(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_32(p) BOOST_PP_NODE_16(p)(p)(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_16(p) BOOST_PP_NODE_8(p)(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_8(p) BOOST_PP_NODE_4(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_4(p) BOOST_PP_NODE_2(p)(p)
#define BOOST_PP_NODE_ENTRY_2(p) BOOST_PP_NODE_1(p)
#define BOOST_PP_NODE_128(p) BOOST_PP_IIF(p(128), BOOST_PP_NODE_64, BOOST_PP_NODE_192)
#define BOOST_PP_NODE_64(p) BOOST_PP_IIF(p(64), BOOST_PP_NODE_32, BOOST_PP_NODE_96)
#define BOOST_PP_NODE_32(p) BOOST_PP_IIF(p(32), BOOST_PP_NODE_16, BOOST_PP_NODE_48)
#define BOOST_PP_NODE_16(p) BOOST_PP_IIF(p(16), BOOST_PP_NODE_8, BOOST_PP_NODE_24)
#define BOOST_PP_NODE_8(p) BOOST_PP_IIF(p(8), BOOST_PP_NODE_4, BOOST_PP_NODE_12)
#define BOOST_PP_NODE_4(p) BOOST_PP_IIF(p(4), BOOST_PP_NODE_2, BOOST_PP_NODE_6)
#define BOOST_PP_NODE_2(p) BOOST_PP_IIF(p(2), BOOST_PP_NODE_1, BOOST_PP_NODE_3)
#define BOOST_PP_NODE_1(p) BOOST_PP_IIF(p(1), 1, 2)
#define BOOST_PP_NODE_3(p) BOOST_PP_IIF(p(3), 3, 4)
#define BOOST_PP_NODE_6(p) BOOST_PP_IIF(p(6), BOOST_PP_NODE_5, BOOST_PP_NODE_7)
#define BOOST_PP_NODE_5(p) BOOST_PP_IIF(p(5), 5, 6)
#define BOOST_PP_NODE_7(p) BOOST_PP_IIF(p(7), 7, 8)
#define BOOST_PP_NODE_12(p) BOOST_PP_IIF(p(12), BOOST_PP_NODE_10, BOOST_PP_NODE_14)
#define BOOST_PP_NODE_10(p) BOOST_PP_IIF(p(10), BOOST_PP_NODE_9, BOOST_PP_NODE_11)
#define BOOST_PP_NODE_9(p) BOOST_PP_IIF(p(9), 9, 10)
#define BOOST_PP_NODE_11(p) BOOST_PP_IIF(p(11), 11, 12)
#define BOOST_PP_NODE_14(p) BOOST_PP_IIF(p(14), BOOST_PP_NODE_13, BOOST_PP_NODE_15)
#define BOOST_PP_NODE_13(p) BOOST_PP_IIF(p(13), 13, 14)
#define BOOST_PP_NODE_15(p) BOOST_PP_IIF(p(15), 15, 16)
#define BOOST_PP_NODE_24(p) BOOST_PP_IIF(p(24), BOOST_PP_NODE_20, BOOST_PP_NODE_28)
#define BOOST_PP_NODE_20(p) BOOST_PP_IIF(p(20), BOOST_PP_NODE_18, BOOST_PP_NODE_22)
#define BOOST_PP_NODE_18(p) BOOST_PP_IIF(p(18), BOOST_PP_NODE_17, BOOST_PP_NODE_19)
#define BOOST_PP_NODE_17(p) BOOST_PP_IIF(p(17), 17, 18)
#define BOOST_PP_NODE_19(p) BOOST_PP_IIF(p(19), 19, 20)
#define BOOST_PP_NODE_22(p) BOOST_PP_IIF(p(22), BOOST_PP_NODE_21, BOOST_PP_NODE_23)
#define BOOST_PP_NODE_21(p) BOOST_PP_IIF(p(21), 21, 22)
#define BOOST_PP_NODE_23(p) BOOST_PP_IIF(p(23), 23, 24)
#define BOOST_PP_NODE_28(p) BOOST_PP_IIF(p(28), BOOST_PP_NODE_26, BOOST_PP_NODE_30)
#define BOOST_PP_NODE_26(p) BOOST_PP_IIF(p(26), BOOST_PP_NODE_25, BOOST_PP_NODE_27)
#define BOOST_PP_NODE_25(p) BOOST_PP_IIF(p(25), 25, 26)
#define BOOST_PP_NODE_27(p) BOOST_PP_IIF(p(27), 27, 28)
#define BOOST_PP_NODE_30(p) BOOST_PP_IIF(p(30), BOOST_PP_NODE_29, BOOST_PP_NODE_31)
#define BOOST_PP_NODE_29(p) BOOST_PP_IIF(p(29), 29, 30)
#define BOOST_PP_NODE_31(p) BOOST_PP_IIF(p(31), 31, 32)
#define BOOST_PP_NODE_48(p) BOOST_PP_IIF(p(48), BOOST_PP_NODE_40, BOOST_PP_NODE_56)
#define BOOST_PP_NODE_40(p) BOOST_PP_IIF(p(40), BOOST_PP_NODE_36, BOOST_PP_NODE_44)
#define BOOST_PP_NODE_36(p) BOOST_PP_IIF(p(36), BOOST_PP_NODE_34, BOOST_PP_NODE_38)
#define BOOST_PP_NODE_34(p) BOOST_PP_IIF(p(34), BOOST_PP_NODE_33, BOOST_PP_NODE_35)
#define BOOST_PP_NODE_33(p) BOOST_PP_IIF(p(33), 33, 34)
#define BOOST_PP_NODE_35(p) BOOST_PP_IIF(p(35), 35, 36)
#define BOOST_PP_NODE_38(p) BOOST_PP_IIF(p(38), BOOST_PP_NODE_37, BOOST_PP_NODE_39)
#define BOOST_PP_NODE_37(p) BOOST_PP_IIF(p(37), 37, 38)
#define BOOST_PP_NODE_39(p) BOOST_PP_IIF(p(39), 39, 40)
#define BOOST_PP_NODE_44(p) BOOST_PP_IIF(p(44), BOOST_PP_NODE_42, BOOST_PP_NODE_46)
#define BOOST_PP_NODE_42(p) BOOST_PP_IIF(p(42), BOOST_PP_NODE_41, BOOST_PP_NODE_43)
#define BOOST_PP_NODE_41(p) BOOST_PP_IIF(p(41), 41, 42)
#define BOOST_PP_NODE_43(p) BOOST_PP_IIF(p(43), 43, 44)
#define BOOST_PP_NODE_46(p) BOOST_PP_IIF(p(46), BOOST_PP_NODE_45, BOOST_PP_NODE_47)
#define BOOST_PP_NODE_45(p) BOOST_PP_IIF(p(45), 45, 46)
#define BOOST_PP_NODE_47(p) BOOST_PP_IIF(p(47), 47, 48)
#define BOOST_PP_NODE_56(p) BOOST_PP_IIF(p(56), BOOST_PP_NODE_52, BOOST_PP_NODE_60)
#define BOOST_PP_NODE_52(p) BOOST_PP_IIF(p(52), BOOST_PP_NODE_50, BOOST_PP_NODE_54)
#define BOOST_PP_NODE_50(p) BOOST_PP_IIF(p(50), BOOST_PP_NODE_49, BOOST_PP_NODE_51)
#define BOOST_PP_NODE_49(p) BOOST_PP_IIF(p(49), 49, 50)
#define BOOST_PP_NODE_51(p) BOOST_PP_IIF(p(51), 51, 52)
#define BOOST_PP_NODE_54(p) BOOST_PP_IIF(p(54), BOOST_PP_NODE_53, BOOST_PP_NODE_55)
#define BOOST_PP_NODE_53(p) BOOST_PP_IIF(p(53), 53, 54)
#define BOOST_PP_NODE_55(p) BOOST_PP_IIF(p(55), 55, 56)
#define BOOST_PP_NODE_60(p) BOOST_PP_IIF(p(60), BOOST_PP_NODE_58, BOOST_PP_NODE_62)
#define BOOST_PP_NODE_58(p) BOOST_PP_IIF(p(58), BOOST_PP_NODE_57, BOOST_PP_NODE_59)
#define BOOST_PP_NODE_57(p) BOOST_PP_IIF(p(57), 57, 58)
#define BOOST_PP_NODE_59(p) BOOST_PP_IIF(p(59), 59, 60)
#define BOOST_PP_NODE_62(p) BOOST_PP_IIF(p(62), BOOST_PP_NODE_61, BOOST_PP_NODE_63)
#define BOOST_PP_NODE_61(p) BOOST_PP_IIF(p(61), 61, 62)
#define BOOST_PP_NODE_63(p) BOOST_PP_IIF(p(63), 63, 64)
#define BOOST_PP_NODE_96(p) BOOST_PP_IIF(p(96), BOOST_PP_NODE_80, BOOST_PP_NODE_112)
#define BOOST_PP_NODE_80(p) BOOST_PP_IIF(p(80), BOOST_PP_NODE_72, BOOST_PP_NODE_88)
#define BOOST_PP_NODE_72(p) BOOST_PP_IIF(p(72), BOOST_PP_NODE_68, BOOST_PP_NODE_76)
#define BOOST_PP_NODE_68(p) BOOST_PP_IIF(p(68), BOOST_PP_NODE_66, BOOST_PP_NODE_70)
#define BOOST_PP_NODE_66(p) BOOST_PP_IIF(p(66), BOOST_PP_NODE_65, BOOST_PP_NODE_67)
#define BOOST_PP_NODE_65(p) BOOST_PP_IIF(p(65), 65, 66)
#define BOOST_PP_NODE_67(p) BOOST_PP_IIF(p(67), 67, 68)
#define BOOST_PP_NODE_70(p) BOOST_PP_IIF(p(70), BOOST_PP_NODE_69, BOOST_PP_NODE_71)
#define BOOST_PP_NODE_69(p) BOOST_PP_IIF(p(69), 69, 70)
#define BOOST_PP_NODE_71(p) BOOST_PP_IIF(p(71), 71, 72)
#define BOOST_PP_NODE_76(p) BOOST_PP_IIF(p(76), BOOST_PP_NODE_74, BOOST_PP_NODE_78)
#define BOOST_PP_NODE_74(p) BOOST_PP_IIF(p(74), BOOST_PP_NODE_73, BOOST_PP_NODE_75)
#define BOOST_PP_NODE_73(p) BOOST_PP_IIF(p(73), 73, 74)
#define BOOST_PP_NODE_75(p) BOOST_PP_IIF(p(75), 75, 76)
#define BOOST_PP_NODE_78(p) BOOST_PP_IIF(p(78), BOOST_PP_NODE_77, BOOST_PP_NODE_79)
#define BOOST_PP_NODE_77(p) BOOST_PP_IIF(p(77), 77, 78)
#define BOOST_PP_NODE_79(p) BOOST_PP_IIF(p(79), 79, 80)
#define BOOST_PP_NODE_88(p) BOOST_PP_IIF(p(88), BOOST_PP_NODE_84, BOOST_PP_NODE_92)
#define BOOST_PP_NODE_84(p) BOOST_PP_IIF(p(84), BOOST_PP_NODE_82, BOOST_PP_NODE_86)
#define BOOST_PP_NODE_82(p) BOOST_PP_IIF(p(82), BOOST_PP_NODE_81, BOOST_PP_NODE_83)
#define BOOST_PP_NODE_81(p) BOOST_PP_IIF(p(81), 81, 82)
#define BOOST_PP_NODE_83(p) BOOST_PP_IIF(p(83), 83, 84)
#define BOOST_PP_NODE_86(p) BOOST_PP_IIF(p(86), BOOST_PP_NODE_85, BOOST_PP_NODE_87)
#define BOOST_PP_NODE_85(p) BOOST_PP_IIF(p(85), 85, 86)
#define BOOST_PP_NODE_87(p) BOOST_PP_IIF(p(87), 87, 88)
#define BOOST_PP_NODE_92(p) BOOST_PP_IIF(p(92), BOOST_PP_NODE_90, BOOST_PP_NODE_94)
#define BOOST_PP_NODE_90(p) BOOST_PP_IIF(p(90), BOOST_PP_NODE_89, BOOST_PP_NODE_91)
#define BOOST_PP_NODE_89(p) BOOST_PP_IIF(p(89), 89, 90)
#define BOOST_PP_NODE_91(p) BOOST_PP_IIF(p(91), 91, 92)
#define BOOST_PP_NODE_94(p) BOOST_PP_IIF(p(94), BOOST_PP_NODE_93, BOOST_PP_NODE_95)
#define BOOST_PP_NODE_93(p) BOOST_PP_IIF(p(93), 93, 94)
#define BOOST_PP_NODE_95(p) BOOST_PP_IIF(p(95), 95, 96)
#define BOOST_PP_NODE_112(p) BOOST_PP_IIF(p(112), BOOST_PP_NODE_104, BOOST_PP_NODE_120)
#define BOOST_PP_NODE_104(p) BOOST_PP_IIF(p(104), BOOST_PP_NODE_100, BOOST_PP_NODE_108)
#define BOOST_PP_NODE_100(p) BOOST_PP_IIF(p(100), BOOST_PP_NODE_98, BOOST_PP_NODE_102)
#define BOOST_PP_NODE_98(p) BOOST_PP_IIF(p(98), BOOST_PP_NODE_97, BOOST_PP_NODE_99)
#define BOOST_PP_NODE_97(p) BOOST_PP_IIF(p(97), 97, 98)
#define BOOST_PP_NODE_99(p) BOOST_PP_IIF(p(99), 99, 100)
#define BOOST_PP_NODE_102(p) BOOST_PP_IIF(p(102), BOOST_PP_NODE_101, BOOST_PP_NODE_103)
#define BOOST_PP_NODE_101(p) BOOST_PP_IIF(p(101), 101, 102)
#define BOOST_PP_NODE_103(p) BOOST_PP_IIF(p(103), 103, 104)
#define BOOST_PP_NODE_108(p) BOOST_PP_IIF(p(108), BOOST_PP_NODE_106, BOOST_PP_NODE_110)
#define BOOST_PP_NODE_106(p) BOOST_PP_IIF(p(106), BOOST_PP_NODE_105, BOOST_PP_NODE_107)
#define BOOST_PP_NODE_105(p) BOOST_PP_IIF(p(105), 105, 106)
#define BOOST_PP_NODE_107(p) BOOST_PP_IIF(p(107), 107, 108)
#define BOOST_PP_NODE_110(p) BOOST_PP_IIF(p(110), BOOST_PP_NODE_109, BOOST_PP_NODE_111)
#define BOOST_PP_NODE_109(p) BOOST_PP_IIF(p(109), 109, 110)
#define BOOST_PP_NODE_111(p) BOOST_PP_IIF(p(111), 111, 112)
#define BOOST_PP_NODE_120(p) BOOST_PP_IIF(p(120), BOOST_PP_NODE_116, BOOST_PP_NODE_124)
#define BOOST_PP_NODE_116(p) BOOST_PP_IIF(p(116), BOOST_PP_NODE_114, BOOST_PP_NODE_118)
#define BOOST_PP_NODE_114(p) BOOST_PP_IIF(p(114), BOOST_PP_NODE_113, BOOST_PP_NODE_115)
#define BOOST_PP_NODE_113(p) BOOST_PP_IIF(p(113), 113, 114)
#define BOOST_PP_NODE_115(p) BOOST_PP_IIF(p(115), 115, 116)
#define BOOST_PP_NODE_118(p) BOOST_PP_IIF(p(118), BOOST_PP_NODE_117, BOOST_PP_NODE_119)
#define BOOST_PP_NODE_117(p) BOOST_PP_IIF(p(117), 117, 118)
#define BOOST_PP_NODE_119(p) BOOST_PP_IIF(p(119), 119, 120)
#define BOOST_PP_NODE_124(p) BOOST_PP_IIF(p(124), BOOST_PP_NODE_122, BOOST_PP_NODE_126)
#define BOOST_PP_NODE_122(p) BOOST_PP_IIF(p(122), BOOST_PP_NODE_121, BOOST_PP_NODE_123)
#define BOOST_PP_NODE_121(p) BOOST_PP_IIF(p(121), 121, 122)
#define BOOST_PP_NODE_123(p) BOOST_PP_IIF(p(123), 123, 124)
#define BOOST_PP_NODE_126(p) BOOST_PP_IIF(p(126), BOOST_PP_NODE_125, BOOST_PP_NODE_127)
#define BOOST_PP_NODE_125(p) BOOST_PP_IIF(p(125), 125, 126)
#define BOOST_PP_NODE_127(p) BOOST_PP_IIF(p(127), 127, 128)
#define BOOST_PP_NODE_192(p) BOOST_PP_IIF(p(192), BOOST_PP_NODE_160, BOOST_PP_NODE_224)
#define BOOST_PP_NODE_160(p) BOOST_PP_IIF(p(160), BOOST_PP_NODE_144, BOOST_PP_NODE_176)
#define BOOST_PP_NODE_144(p) BOOST_PP_IIF(p(144), BOOST_PP_NODE_136, BOOST_PP_NODE_152)
#define BOOST_PP_NODE_136(p) BOOST_PP_IIF(p(136), BOOST_PP_NODE_132, BOOST_PP_NODE_140)
#define BOOST_PP_NODE_132(p) BOOST_PP_IIF(p(132), BOOST_PP_NODE_130, BOOST_PP_NODE_134)
#define BOOST_PP_NODE_130(p) BOOST_PP_IIF(p(130), BOOST_PP_NODE_129, BOOST_PP_NODE_131)
#define BOOST_PP_NODE_129(p) BOOST_PP_IIF(p(129), 129, 130)
#define BOOST_PP_NODE_131(p) BOOST_PP_IIF(p(131), 131, 132)
#define BOOST_PP_NODE_134(p) BOOST_PP_IIF(p(134), BOOST_PP_NODE_133, BOOST_PP_NODE_135)
#define BOOST_PP_NODE_133(p) BOOST_PP_IIF(p(133), 133, 134)
#define BOOST_PP_NODE_135(p) BOOST_PP_IIF(p(135), 135, 136)
#define BOOST_PP_NODE_140(p) BOOST_PP_IIF(p(140), BOOST_PP_NODE_138, BOOST_PP_NODE_142)
#define BOOST_PP_NODE_138(p) BOOST_PP_IIF(p(138), BOOST_PP_NODE_137, BOOST_PP_NODE_139)
#define BOOST_PP_NODE_137(p) BOOST_PP_IIF(p(137), 137, 138)
#define BOOST_PP_NODE_139(p) BOOST_PP_IIF(p(139), 139, 140)
#define BOOST_PP_NODE_142(p) BOOST_PP_IIF(p(142), BOOST_PP_NODE_141, BOOST_PP_NODE_143)
#define BOOST_PP_NODE_141(p) BOOST_PP_IIF(p(141), 141, 142)
#define BOOST_PP_NODE_143(p) BOOST_PP_IIF(p(143), 143, 144)
#define BOOST_PP_NODE_152(p) BOOST_PP_IIF(p(152), BOOST_PP_NODE_148, BOOST_PP_NODE_156)
#define BOOST_PP_NODE_148(p) BOOST_PP_IIF(p(148), BOOST_PP_NODE_146, BOOST_PP_NODE_150)
#define BOOST_PP_NODE_146(p) BOOST_PP_IIF(p(146), BOOST_PP_NODE_145, BOOST_PP_NODE_147)
#define BOOST_PP_NODE_145(p) BOOST_PP_IIF(p(145), 145, 146)
#define BOOST_PP_NODE_147(p) BOOST_PP_IIF(p(147), 147, 148)
#define BOOST_PP_NODE_150(p) BOOST_PP_IIF(p(150), BOOST_PP_NODE_149, BOOST_PP_NODE_151)
#define BOOST_PP_NODE_149(p) BOOST_PP_IIF(p(149), 149, 150)
#define BOOST_PP_NODE_151(p) BOOST_PP_IIF(p(151), 151, 152)
#define BOOST_PP_NODE_156(p) BOOST_PP_IIF(p(156), BOOST_PP_NODE_154, BOOST_PP_NODE_158)
#define BOOST_PP_NODE_154(p) BOOST_PP_IIF(p(154), BOOST_PP_NODE_153, BOOST_PP_NODE_155)
#define BOOST_PP_NODE_153(p) BOOST_PP_IIF(p(153), 153, 154)
#define BOOST_PP_NODE_155(p) BOOST_PP_IIF(p(155), 155, 156)
#define BOOST_PP_NODE_158(p) BOOST_PP_IIF(p(158), BOOST_PP_NODE_157, BOOST_PP_NODE_159)
#define BOOST_PP_NODE_157(p) BOOST_PP_IIF(p(157), 157, 158)
#define BOOST_PP_NODE_159(p) BOOST_PP_IIF(p(159), 159, 160)
#define BOOST_PP_NODE_176(p) BOOST_PP_IIF(p(176), BOOST_PP_NODE_168, BOOST_PP_NODE_184)
#define BOOST_PP_NODE_168(p) BOOST_PP_IIF(p(168), BOOST_PP_NODE_164, BOOST_PP_NODE_172)
#define BOOST_PP_NODE_164(p) BOOST_PP_IIF(p(164), BOOST_PP_NODE_162, BOOST_PP_NODE_166)
#define BOOST_PP_NODE_162(p) BOOST_PP_IIF(p(162), BOOST_PP_NODE_161, BOOST_PP_NODE_163)
#define BOOST_PP_NODE_161(p) BOOST_PP_IIF(p(161), 161, 162)
#define BOOST_PP_NODE_163(p) BOOST_PP_IIF(p(163), 163, 164)
#define BOOST_PP_NODE_166(p) BOOST_PP_IIF(p(166), BOOST_PP_NODE_165, BOOST_PP_NODE_167)
#define BOOST_PP_NODE_165(p) BOOST_PP_IIF(p(165), 165, 166)
#define BOOST_PP_NODE_167(p) BOOST_PP_IIF(p(167), 167, 168)
#define BOOST_PP_NODE_172(p) BOOST_PP_IIF(p(172), BOOST_PP_NODE_170, BOOST_PP_NODE_174)
#define BOOST_PP_NODE_170(p) BOOST_PP_IIF(p(170), BOOST_PP_NODE_169, BOOST_PP_NODE_171)
#define BOOST_PP_NODE_169(p) BOOST_PP_IIF(p(169), 169, 170)
#define BOOST_PP_NODE_171(p) BOOST_PP_IIF(p(171), 171, 172)
#define BOOST_PP_NODE_174(p) BOOST_PP_IIF(p(174), BOOST_PP_NODE_173, BOOST_PP_NODE_175)
#define BOOST_PP_NODE_173(p) BOOST_PP_IIF(p(173), 173, 174)
#define BOOST_PP_NODE_175(p) BOOST_PP_IIF(p(175), 175, 176)
#define BOOST_PP_NODE_184(p) BOOST_PP_IIF(p(184), BOOST_PP_NODE_180, BOOST_PP_NODE_188)
#define BOOST_PP_NODE_180(p) BOOST_PP_IIF(p(180), BOOST_PP_NODE_178, BOOST_PP_NODE_182)
#define BOOST_PP_NODE_178(p) BOOST_PP_IIF(p(178), BOOST_PP_NODE_177, BOOST_PP_NODE_179)
#define BOOST_PP_NODE_177(p) BOOST_PP_IIF(p(177), 177, 178)
#define BOOST_PP_NODE_179(p) BOOST_PP_IIF(p(179), 179, 180)
#define BOOST_PP_NODE_182(p) BOOST_PP_IIF(p(182), BOOST_PP_NODE_181, BOOST_PP_NODE_183)
#define BOOST_PP_NODE_181(p) BOOST_PP_IIF(p(181), 181, 182)
#define BOOST_PP_NODE_183(p) BOOST_PP_IIF(p(183), 183, 184)
#define BOOST_PP_NODE_188(p) BOOST_PP_IIF(p(188), BOOST_PP_NODE_186, BOOST_PP_NODE_190)
#define BOOST_PP_NODE_186(p) BOOST_PP_IIF(p(186), BOOST_PP_NODE_185, BOOST_PP_NODE_187)
#define BOOST_PP_NODE_185(p) BOOST_PP_IIF(p(185), 185, 186)
#define BOOST_PP_NODE_187(p) BOOST_PP_IIF(p(187), 187, 188)
#define BOOST_PP_NODE_190(p) BOOST_PP_IIF(p(190), BOOST_PP_NODE_189, BOOST_PP_NODE_191)
#define BOOST_PP_NODE_189(p) BOOST_PP_IIF(p(189), 189, 190)
#define BOOST_PP_NODE_191(p) BOOST_PP_IIF(p(191), 191, 192)
#define BOOST_PP_NODE_224(p) BOOST_PP_IIF(p(224), BOOST_PP_NODE_208, BOOST_PP_NODE_240)
#define BOOST_PP_NODE_208(p) BOOST_PP_IIF(p(208), BOOST_PP_NODE_200, BOOST_PP_NODE_216)
#define BOOST_PP_NODE_200(p) BOOST_PP_IIF(p(200), BOOST_PP_NODE_196, BOOST_PP_NODE_204)
#define BOOST_PP_NODE_196(p) BOOST_PP_IIF(p(196), BOOST_PP_NODE_194, BOOST_PP_NODE_198)
#define BOOST_PP_NODE_194(p) BOOST_PP_IIF(p(194), BOOST_PP_NODE_193, BOOST_PP_NODE_195)
#define BOOST_PP_NODE_193(p) BOOST_PP_IIF(p(193), 193, 194)
#define BOOST_PP_NODE_195(p) BOOST_PP_IIF(p(195), 195, 196)
#define BOOST_PP_NODE_198(p) BOOST_PP_IIF(p(198), BOOST_PP_NODE_197, BOOST_PP_NODE_199)
#define BOOST_PP_NODE_197(p) BOOST_PP_IIF(p(197), 197, 198)
#define BOOST_PP_NODE_199(p) BOOST_PP_IIF(p(199), 199, 200)
#define BOOST_PP_NODE_204(p) BOOST_PP_IIF(p(204), BOOST_PP_NODE_202, BOOST_PP_NODE_206)
#define BOOST_PP_NODE_202(p) BOOST_PP_IIF(p(202), BOOST_PP_NODE_201, BOOST_PP_NODE_203)
#define BOOST_PP_NODE_201(p) BOOST_PP_IIF(p(201), 201, 202)
#define BOOST_PP_NODE_203(p) BOOST_PP_IIF(p(203), 203, 204)
#define BOOST_PP_NODE_206(p) BOOST_PP_IIF(p(206), BOOST_PP_NODE_205, BOOST_PP_NODE_207)
#define BOOST_PP_NODE_205(p) BOOST_PP_IIF(p(205), 205, 206)
#define BOOST_PP_NODE_207(p) BOOST_PP_IIF(p(207), 207, 208)
#define BOOST_PP_NODE_216(p) BOOST_PP_IIF(p(216), BOOST_PP_NODE_212, BOOST_PP_NODE_220)
#define BOOST_PP_NODE_212(p) BOOST_PP_IIF(p(212), BOOST_PP_NODE_210, BOOST_PP_NODE_214)
#define BOOST_PP_NODE_210(p) BOOST_PP_IIF(p(210), BOOST_PP_NODE_209, BOOST_PP_NODE_211)
#define BOOST_PP_NODE_209(p) BOOST_PP_IIF(p(209), 209, 210)
#define BOOST_PP_NODE_211(p) BOOST_PP_IIF(p(211), 211, 212)
#define BOOST_PP_NODE_214(p) BOOST_PP_IIF(p(214), BOOST_PP_NODE_213, BOOST_PP_NODE_215)
#define BOOST_PP_NODE_213(p) BOOST_PP_IIF(p(213), 213, 214)
#define BOOST_PP_NODE_215(p) BOOST_PP_IIF(p(215), 215, 216)
#define BOOST_PP_NODE_220(p) BOOST_PP_IIF(p(220), BOOST_PP_NODE_218, BOOST_PP_NODE_222)
#define BOOST_PP_NODE_218(p) BOOST_PP_IIF(p(218), BOOST_PP_NODE_217, BOOST_PP_NODE_219)
#define BOOST_PP_NODE_217(p) BOOST_PP_IIF(p(217), 217, 218)
#define BOOST_PP_NODE_219(p) BOOST_PP_IIF(p(219), 219, 220)
#define BOOST_PP_NODE_222(p) BOOST_PP_IIF(p(222), BOOST_PP_NODE_221, BOOST_PP_NODE_223)
#define BOOST_PP_NODE_221(p) BOOST_PP_IIF(p(221), 221, 222)
#define BOOST_PP_NODE_223(p) BOOST_PP_IIF(p(223), 223, 224)
#define BOOST_PP_NODE_240(p) BOOST_PP_IIF(p(240), BOOST_PP_NODE_232, BOOST_PP_NODE_248)
#define BOOST_PP_NODE_232(p) BOOST_PP_IIF(p(232), BOOST_PP_NODE_228, BOOST_PP_NODE_236)
#define BOOST_PP_NODE_228(p) BOOST_PP_IIF(p(228), BOOST_PP_NODE_226, BOOST_PP_NODE_230)
#define BOOST_PP_NODE_226(p) BOOST_PP_IIF(p(226), BOOST_PP_NODE_225, BOOST_PP_NODE_227)
#define BOOST_PP_NODE_225(p) BOOST_PP_IIF(p(225), 225, 226)
#define BOOST_PP_NODE_227(p) BOOST_PP_IIF(p(227), 227, 228)
#define BOOST_PP_NODE_230(p) BOOST_PP_IIF(p(230), BOOST_PP_NODE_229, BOOST_PP_NODE_231)
#define BOOST_PP_NODE_229(p) BOOST_PP_IIF(p(229), 229, 230)
#define BOOST_PP_NODE_231(p) BOOST_PP_IIF(p(231), 231, 232)
#define BOOST_PP_NODE_236(p) BOOST_PP_IIF(p(236), BOOST_PP_NODE_234, BOOST_PP_NODE_238)
#define BOOST_PP_NODE_234(p) BOOST_PP_IIF(p(234), BOOST_PP_NODE_233, BOOST_PP_NODE_235)
#define BOOST_PP_NODE_233(p) BOOST_PP_IIF(p(233), 233, 234)
#define BOOST_PP_NODE_235(p) BOOST_PP_IIF(p(235), 235, 236)
#define BOOST_PP_NODE_238(p) BOOST_PP_IIF(p(238), BOOST_PP_NODE_237, BOOST_PP_NODE_239)
#define BOOST_PP_NODE_237(p) BOOST_PP_IIF(p(237), 237, 238)
#define BOOST_PP_NODE_239(p) BOOST_PP_IIF(p(239), 239, 240)
#define BOOST_PP_NODE_248(p) BOOST_PP_IIF(p(248), BOOST_PP_NODE_244, BOOST_PP_NODE_252)
#define BOOST_PP_NODE_244(p) BOOST_PP_IIF(p(244), BOOST_PP_NODE_242, BOOST_PP_NODE_246)
#define BOOST_PP_NODE_242(p) BOOST_PP_IIF(p(242), BOOST_PP_NODE_241, BOOST_PP_NODE_243)
#define BOOST_PP_NODE_241(p) BOOST_PP_IIF(p(241), 241, 242)
#define BOOST_PP_NODE_243(p) BOOST_PP_IIF(p(243), 243, 244)
#define BOOST_PP_NODE_246(p) BOOST_PP_IIF(p(246), BOOST_PP_NODE_245, BOOST_PP_NODE_247)
#define BOOST_PP_NODE_245(p) BOOST_PP_IIF(p(245), 245, 246)
#define BOOST_PP_NODE_247(p) BOOST_PP_IIF(p(247), 247, 248)
#define BOOST_PP_NODE_252(p) BOOST_PP_IIF(p(252), BOOST_PP_NODE_250, BOOST_PP_NODE_254)
#define BOOST_PP_NODE_250(p) BOOST_PP_IIF(p(250), BOOST_PP_NODE_249, BOOST_PP_NODE_251)
#define BOOST_PP_NODE_249(p) BOOST_PP_IIF(p(249), 249, 250)
#define BOOST_PP_NODE_251(p) BOOST_PP_IIF(p(251), 251, 252)
#define BOOST_PP_NODE_254(p) BOOST_PP_IIF(p(254), BOOST_PP_NODE_253, BOOST_PP_NODE_255)
#define BOOST_PP_NODE_253(p) BOOST_PP_IIF(p(253), 253, 254)
#define BOOST_PP_NODE_255(p) BOOST_PP_IIF(p(255), 255, 256)
#define BOOST_PREPROCESSOR_TUPLE_EAT_HPP
#define BOOST_PP_EAT(...)
#define BOOST_PP_TUPLE_EAT(size) BOOST_PP_EAT
#define BOOST_PP_TUPLE_EAT_1(e0)
#define BOOST_PP_TUPLE_EAT_2(e0,e1)
#define BOOST_PP_TUPLE_EAT_3(e0,e1,e2)
#define BOOST_PP_TUPLE_EAT_4(e0,e1,e2,e3)
#define BOOST_PP_TUPLE_EAT_5(e0,e1,e2,e3,e4)
#define BOOST_PP_TUPLE_EAT_6(e0,e1,e2,e3,e4,e5)
#define BOOST_PP_TUPLE_EAT_7(e0,e1,e2,e3,e4,e5,e6)
#define BOOST_PP_TUPLE_EAT_8(e0,e1,e2,e3,e4,e5,e6,e7)
#define BOOST_PP_TUPLE_EAT_9(e0,e1,e2,e3,e4,e5,e6,e7,e8)
#define BOOST_PP_TUPLE_EAT_10(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9)
#define BOOST_PP_TUPLE_EAT_11(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10)
#define BOOST_PP_TUPLE_EAT_12(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11)
#define BOOST_PP_TUPLE_EAT_13(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12)
#define BOOST_PP_TUPLE_EAT_14(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13)
#define BOOST_PP_TUPLE_EAT_15(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14)
#define BOOST_PP_TUPLE_EAT_16(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15)
#define BOOST_PP_TUPLE_EAT_17(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16)
#define BOOST_PP_TUPLE_EAT_18(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17)
#define BOOST_PP_TUPLE_EAT_19(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18)
#define BOOST_PP_TUPLE_EAT_20(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19)
#define BOOST_PP_TUPLE_EAT_21(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20)
#define BOOST_PP_TUPLE_EAT_22(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21)
#define BOOST_PP_TUPLE_EAT_23(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22)
#define BOOST_PP_TUPLE_EAT_24(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23)
#define BOOST_PP_TUPLE_EAT_25(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24)
#define BOOST_PP_TUPLE_EAT_26(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25)
#define BOOST_PP_TUPLE_EAT_27(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26)
#define BOOST_PP_TUPLE_EAT_28(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27)
#define BOOST_PP_TUPLE_EAT_29(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28)
#define BOOST_PP_TUPLE_EAT_30(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29)
#define BOOST_PP_TUPLE_EAT_31(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30)
#define BOOST_PP_TUPLE_EAT_32(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31)
#define BOOST_PP_TUPLE_EAT_33(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32)
#define BOOST_PP_TUPLE_EAT_34(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33)
#define BOOST_PP_TUPLE_EAT_35(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34)
#define BOOST_PP_TUPLE_EAT_36(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35)
#define BOOST_PP_TUPLE_EAT_37(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36)
#define BOOST_PP_TUPLE_EAT_38(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37)
#define BOOST_PP_TUPLE_EAT_39(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38)
#define BOOST_PP_TUPLE_EAT_40(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39)
#define BOOST_PP_TUPLE_EAT_41(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40)
#define BOOST_PP_TUPLE_EAT_42(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41)
#define BOOST_PP_TUPLE_EAT_43(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42)
#define BOOST_PP_TUPLE_EAT_44(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43)
#define BOOST_PP_TUPLE_EAT_45(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44)
#define BOOST_PP_TUPLE_EAT_46(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45)
#define BOOST_PP_TUPLE_EAT_47(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46)
#define BOOST_PP_TUPLE_EAT_48(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47)
#define BOOST_PP_TUPLE_EAT_49(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48)
#define BOOST_PP_TUPLE_EAT_50(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49)
#define BOOST_PP_TUPLE_EAT_51(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50)
#define BOOST_PP_TUPLE_EAT_52(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51)
#define BOOST_PP_TUPLE_EAT_53(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52)
#define BOOST_PP_TUPLE_EAT_54(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53)
#define BOOST_PP_TUPLE_EAT_55(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54)
#define BOOST_PP_TUPLE_EAT_56(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55)
#define BOOST_PP_TUPLE_EAT_57(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56)
#define BOOST_PP_TUPLE_EAT_58(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57)
#define BOOST_PP_TUPLE_EAT_59(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58)
#define BOOST_PP_TUPLE_EAT_60(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59)
#define BOOST_PP_TUPLE_EAT_61(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60)
#define BOOST_PP_TUPLE_EAT_62(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61)
#define BOOST_PP_TUPLE_EAT_63(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62)
#define BOOST_PP_TUPLE_EAT_64(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62,e63)
#define BOOST_PP_REPEAT BOOST_PP_CAT(BOOST_PP_REPEAT_, BOOST_PP_AUTO_REC(BOOST_PP_REPEAT_P, 4))
#define BOOST_PP_REPEAT_P(n) BOOST_PP_CAT(BOOST_PP_REPEAT_CHECK_, BOOST_PP_REPEAT_ ## n(1, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3, BOOST_PP_NIL))
#define BOOST_PP_REPEAT_CHECK_BOOST_PP_NIL 1
#define BOOST_PP_REPEAT_CHECK_BOOST_PP_REPEAT_1(c,m,d) 0
#define BOOST_PP_REPEAT_CHECK_BOOST_PP_REPEAT_2(c,m,d) 0
#define BOOST_PP_REPEAT_CHECK_BOOST_PP_REPEAT_3(c,m,d) 0
#define BOOST_PP_REPEAT_1(c,m,d) BOOST_PP_REPEAT_1_I(c, m, d)
#define BOOST_PP_REPEAT_2(c,m,d) BOOST_PP_REPEAT_2_I(c, m, d)
#define BOOST_PP_REPEAT_3(c,m,d) BOOST_PP_REPEAT_3_I(c, m, d)
#define BOOST_PP_REPEAT_4(c,m,d) BOOST_PP_ERROR(0x0003)
#define BOOST_PP_REPEAT_1_I(c,m,d) BOOST_PP_REPEAT_1_ ## c(m, d)
#define BOOST_PP_REPEAT_2_I(c,m,d) BOOST_PP_REPEAT_2_ ## c(m, d)
#define BOOST_PP_REPEAT_3_I(c,m,d) BOOST_PP_REPEAT_3_ ## c(m, d)
#define BOOST_PP_REPEAT_1ST BOOST_PP_REPEAT_1
#define BOOST_PP_REPEAT_2ND BOOST_PP_REPEAT_2
#define BOOST_PP_REPEAT_3RD BOOST_PP_REPEAT_3
#define BOOST_PP_REPEAT_1_0(m,d)
#define BOOST_PP_REPEAT_1_1(m,d) m(2, 0, d)
#define BOOST_PP_REPEAT_1_2(m,d) BOOST_PP_REPEAT_1_1(m, d) m(2, 1, d)
#define BOOST_PP_REPEAT_1_3(m,d) BOOST_PP_REPEAT_1_2(m, d) m(2, 2, d)
#define BOOST_PP_REPEAT_1_4(m,d) BOOST_PP_REPEAT_1_3(m, d) m(2, 3, d)
#define BOOST_PP_REPEAT_1_5(m,d) BOOST_PP_REPEAT_1_4(m, d) m(2, 4, d)
#define BOOST_PP_REPEAT_1_6(m,d) BOOST_PP_REPEAT_1_5(m, d) m(2, 5, d)
#define BOOST_PP_REPEAT_1_7(m,d) BOOST_PP_REPEAT_1_6(m, d) m(2, 6, d)
#define BOOST_PP_REPEAT_1_8(m,d) BOOST_PP_REPEAT_1_7(m, d) m(2, 7, d)
#define BOOST_PP_REPEAT_1_9(m,d) BOOST_PP_REPEAT_1_8(m, d) m(2, 8, d)
#define BOOST_PP_REPEAT_1_10(m,d) BOOST_PP_REPEAT_1_9(m, d) m(2, 9, d)
#define BOOST_PP_REPEAT_1_11(m,d) BOOST_PP_REPEAT_1_10(m, d) m(2, 10, d)
#define BOOST_PP_REPEAT_1_12(m,d) BOOST_PP_REPEAT_1_11(m, d) m(2, 11, d)
#define BOOST_PP_REPEAT_1_13(m,d) BOOST_PP_REPEAT_1_12(m, d) m(2, 12, d)
#define BOOST_PP_REPEAT_1_14(m,d) BOOST_PP_REPEAT_1_13(m, d) m(2, 13, d)
#define BOOST_PP_REPEAT_1_15(m,d) BOOST_PP_REPEAT_1_14(m, d) m(2, 14, d)
#define BOOST_PP_REPEAT_1_16(m,d) BOOST_PP_REPEAT_1_15(m, d) m(2, 15, d)
#define BOOST_PP_REPEAT_1_17(m,d) BOOST_PP_REPEAT_1_16(m, d) m(2, 16, d)
#define BOOST_PP_REPEAT_1_18(m,d) BOOST_PP_REPEAT_1_17(m, d) m(2, 17, d)
#define BOOST_PP_REPEAT_1_19(m,d) BOOST_PP_REPEAT_1_18(m, d) m(2, 18, d)
#define BOOST_PP_REPEAT_1_20(m,d) BOOST_PP_REPEAT_1_19(m, d) m(2, 19, d)
#define BOOST_PP_REPEAT_1_21(m,d) BOOST_PP_REPEAT_1_20(m, d) m(2, 20, d)
#define BOOST_PP_REPEAT_1_22(m,d) BOOST_PP_REPEAT_1_21(m, d) m(2, 21, d)
#define BOOST_PP_REPEAT_1_23(m,d) BOOST_PP_REPEAT_1_22(m, d) m(2, 22, d)
#define BOOST_PP_REPEAT_1_24(m,d) BOOST_PP_REPEAT_1_23(m, d) m(2, 23, d)
#define BOOST_PP_REPEAT_1_25(m,d) BOOST_PP_REPEAT_1_24(m, d) m(2, 24, d)
#define BOOST_PP_REPEAT_1_26(m,d) BOOST_PP_REPEAT_1_25(m, d) m(2, 25, d)
#define BOOST_PP_REPEAT_1_27(m,d) BOOST_PP_REPEAT_1_26(m, d) m(2, 26, d)
#define BOOST_PP_REPEAT_1_28(m,d) BOOST_PP_REPEAT_1_27(m, d) m(2, 27, d)
#define BOOST_PP_REPEAT_1_29(m,d) BOOST_PP_REPEAT_1_28(m, d) m(2, 28, d)
#define BOOST_PP_REPEAT_1_30(m,d) BOOST_PP_REPEAT_1_29(m, d) m(2, 29, d)
#define BOOST_PP_REPEAT_1_31(m,d) BOOST_PP_REPEAT_1_30(m, d) m(2, 30, d)
#define BOOST_PP_REPEAT_1_32(m,d) BOOST_PP_REPEAT_1_31(m, d) m(2, 31, d)
#define BOOST_PP_REPEAT_1_33(m,d) BOOST_PP_REPEAT_1_32(m, d) m(2, 32, d)
#define BOOST_PP_REPEAT_1_34(m,d) BOOST_PP_REPEAT_1_33(m, d) m(2, 33, d)
#define BOOST_PP_REPEAT_1_35(m,d) BOOST_PP_REPEAT_1_34(m, d) m(2, 34, d)
#define BOOST_PP_REPEAT_1_36(m,d) BOOST_PP_REPEAT_1_35(m, d) m(2, 35, d)
#define BOOST_PP_REPEAT_1_37(m,d) BOOST_PP_REPEAT_1_36(m, d) m(2, 36, d)
#define BOOST_PP_REPEAT_1_38(m,d) BOOST_PP_REPEAT_1_37(m, d) m(2, 37, d)
#define BOOST_PP_REPEAT_1_39(m,d) BOOST_PP_REPEAT_1_38(m, d) m(2, 38, d)
#define BOOST_PP_REPEAT_1_40(m,d) BOOST_PP_REPEAT_1_39(m, d) m(2, 39, d)
#define BOOST_PP_REPEAT_1_41(m,d) BOOST_PP_REPEAT_1_40(m, d) m(2, 40, d)
#define BOOST_PP_REPEAT_1_42(m,d) BOOST_PP_REPEAT_1_41(m, d) m(2, 41, d)
#define BOOST_PP_REPEAT_1_43(m,d) BOOST_PP_REPEAT_1_42(m, d) m(2, 42, d)
#define BOOST_PP_REPEAT_1_44(m,d) BOOST_PP_REPEAT_1_43(m, d) m(2, 43, d)
#define BOOST_PP_REPEAT_1_45(m,d) BOOST_PP_REPEAT_1_44(m, d) m(2, 44, d)
#define BOOST_PP_REPEAT_1_46(m,d) BOOST_PP_REPEAT_1_45(m, d) m(2, 45, d)
#define BOOST_PP_REPEAT_1_47(m,d) BOOST_PP_REPEAT_1_46(m, d) m(2, 46, d)
#define BOOST_PP_REPEAT_1_48(m,d) BOOST_PP_REPEAT_1_47(m, d) m(2, 47, d)
#define BOOST_PP_REPEAT_1_49(m,d) BOOST_PP_REPEAT_1_48(m, d) m(2, 48, d)
#define BOOST_PP_REPEAT_1_50(m,d) BOOST_PP_REPEAT_1_49(m, d) m(2, 49, d)
#define BOOST_PP_REPEAT_1_51(m,d) BOOST_PP_REPEAT_1_50(m, d) m(2, 50, d)
#define BOOST_PP_REPEAT_1_52(m,d) BOOST_PP_REPEAT_1_51(m, d) m(2, 51, d)
#define BOOST_PP_REPEAT_1_53(m,d) BOOST_PP_REPEAT_1_52(m, d) m(2, 52, d)
#define BOOST_PP_REPEAT_1_54(m,d) BOOST_PP_REPEAT_1_53(m, d) m(2, 53, d)
#define BOOST_PP_REPEAT_1_55(m,d) BOOST_PP_REPEAT_1_54(m, d) m(2, 54, d)
#define BOOST_PP_REPEAT_1_56(m,d) BOOST_PP_REPEAT_1_55(m, d) m(2, 55, d)
#define BOOST_PP_REPEAT_1_57(m,d) BOOST_PP_REPEAT_1_56(m, d) m(2, 56, d)
#define BOOST_PP_REPEAT_1_58(m,d) BOOST_PP_REPEAT_1_57(m, d) m(2, 57, d)
#define BOOST_PP_REPEAT_1_59(m,d) BOOST_PP_REPEAT_1_58(m, d) m(2, 58, d)
#define BOOST_PP_REPEAT_1_60(m,d) BOOST_PP_REPEAT_1_59(m, d) m(2, 59, d)
#define BOOST_PP_REPEAT_1_61(m,d) BOOST_PP_REPEAT_1_60(m, d) m(2, 60, d)
#define BOOST_PP_REPEAT_1_62(m,d) BOOST_PP_REPEAT_1_61(m, d) m(2, 61, d)
#define BOOST_PP_REPEAT_1_63(m,d) BOOST_PP_REPEAT_1_62(m, d) m(2, 62, d)
#define BOOST_PP_REPEAT_1_64(m,d) BOOST_PP_REPEAT_1_63(m, d) m(2, 63, d)
#define BOOST_PP_REPEAT_1_65(m,d) BOOST_PP_REPEAT_1_64(m, d) m(2, 64, d)
#define BOOST_PP_REPEAT_1_66(m,d) BOOST_PP_REPEAT_1_65(m, d) m(2, 65, d)
#define BOOST_PP_REPEAT_1_67(m,d) BOOST_PP_REPEAT_1_66(m, d) m(2, 66, d)
#define BOOST_PP_REPEAT_1_68(m,d) BOOST_PP_REPEAT_1_67(m, d) m(2, 67, d)
#define BOOST_PP_REPEAT_1_69(m,d) BOOST_PP_REPEAT_1_68(m, d) m(2, 68, d)
#define BOOST_PP_REPEAT_1_70(m,d) BOOST_PP_REPEAT_1_69(m, d) m(2, 69, d)
#define BOOST_PP_REPEAT_1_71(m,d) BOOST_PP_REPEAT_1_70(m, d) m(2, 70, d)
#define BOOST_PP_REPEAT_1_72(m,d) BOOST_PP_REPEAT_1_71(m, d) m(2, 71, d)
#define BOOST_PP_REPEAT_1_73(m,d) BOOST_PP_REPEAT_1_72(m, d) m(2, 72, d)
#define BOOST_PP_REPEAT_1_74(m,d) BOOST_PP_REPEAT_1_73(m, d) m(2, 73, d)
#define BOOST_PP_REPEAT_1_75(m,d) BOOST_PP_REPEAT_1_74(m, d) m(2, 74, d)
#define BOOST_PP_REPEAT_1_76(m,d) BOOST_PP_REPEAT_1_75(m, d) m(2, 75, d)
#define BOOST_PP_REPEAT_1_77(m,d) BOOST_PP_REPEAT_1_76(m, d) m(2, 76, d)
#define BOOST_PP_REPEAT_1_78(m,d) BOOST_PP_REPEAT_1_77(m, d) m(2, 77, d)
#define BOOST_PP_REPEAT_1_79(m,d) BOOST_PP_REPEAT_1_78(m, d) m(2, 78, d)
#define BOOST_PP_REPEAT_1_80(m,d) BOOST_PP_REPEAT_1_79(m, d) m(2, 79, d)
#define BOOST_PP_REPEAT_1_81(m,d) BOOST_PP_REPEAT_1_80(m, d) m(2, 80, d)
#define BOOST_PP_REPEAT_1_82(m,d) BOOST_PP_REPEAT_1_81(m, d) m(2, 81, d)
#define BOOST_PP_REPEAT_1_83(m,d) BOOST_PP_REPEAT_1_82(m, d) m(2, 82, d)
#define BOOST_PP_REPEAT_1_84(m,d) BOOST_PP_REPEAT_1_83(m, d) m(2, 83, d)
#define BOOST_PP_REPEAT_1_85(m,d) BOOST_PP_REPEAT_1_84(m, d) m(2, 84, d)
#define BOOST_PP_REPEAT_1_86(m,d) BOOST_PP_REPEAT_1_85(m, d) m(2, 85, d)
#define BOOST_PP_REPEAT_1_87(m,d) BOOST_PP_REPEAT_1_86(m, d) m(2, 86, d)
#define BOOST_PP_REPEAT_1_88(m,d) BOOST_PP_REPEAT_1_87(m, d) m(2, 87, d)
#define BOOST_PP_REPEAT_1_89(m,d) BOOST_PP_REPEAT_1_88(m, d) m(2, 88, d)
#define BOOST_PP_REPEAT_1_90(m,d) BOOST_PP_REPEAT_1_89(m, d) m(2, 89, d)
#define BOOST_PP_REPEAT_1_91(m,d) BOOST_PP_REPEAT_1_90(m, d) m(2, 90, d)
#define BOOST_PP_REPEAT_1_92(m,d) BOOST_PP_REPEAT_1_91(m, d) m(2, 91, d)
#define BOOST_PP_REPEAT_1_93(m,d) BOOST_PP_REPEAT_1_92(m, d) m(2, 92, d)
#define BOOST_PP_REPEAT_1_94(m,d) BOOST_PP_REPEAT_1_93(m, d) m(2, 93, d)
#define BOOST_PP_REPEAT_1_95(m,d) BOOST_PP_REPEAT_1_94(m, d) m(2, 94, d)
#define BOOST_PP_REPEAT_1_96(m,d) BOOST_PP_REPEAT_1_95(m, d) m(2, 95, d)
#define BOOST_PP_REPEAT_1_97(m,d) BOOST_PP_REPEAT_1_96(m, d) m(2, 96, d)
#define BOOST_PP_REPEAT_1_98(m,d) BOOST_PP_REPEAT_1_97(m, d) m(2, 97, d)
#define BOOST_PP_REPEAT_1_99(m,d) BOOST_PP_REPEAT_1_98(m, d) m(2, 98, d)
#define BOOST_PP_REPEAT_1_100(m,d) BOOST_PP_REPEAT_1_99(m, d) m(2, 99, d)
#define BOOST_PP_REPEAT_1_101(m,d) BOOST_PP_REPEAT_1_100(m, d) m(2, 100, d)
#define BOOST_PP_REPEAT_1_102(m,d) BOOST_PP_REPEAT_1_101(m, d) m(2, 101, d)
#define BOOST_PP_REPEAT_1_103(m,d) BOOST_PP_REPEAT_1_102(m, d) m(2, 102, d)
#define BOOST_PP_REPEAT_1_104(m,d) BOOST_PP_REPEAT_1_103(m, d) m(2, 103, d)
#define BOOST_PP_REPEAT_1_105(m,d) BOOST_PP_REPEAT_1_104(m, d) m(2, 104, d)
#define BOOST_PP_REPEAT_1_106(m,d) BOOST_PP_REPEAT_1_105(m, d) m(2, 105, d)
#define BOOST_PP_REPEAT_1_107(m,d) BOOST_PP_REPEAT_1_106(m, d) m(2, 106, d)
#define BOOST_PP_REPEAT_1_108(m,d) BOOST_PP_REPEAT_1_107(m, d) m(2, 107, d)
#define BOOST_PP_REPEAT_1_109(m,d) BOOST_PP_REPEAT_1_108(m, d) m(2, 108, d)
#define BOOST_PP_REPEAT_1_110(m,d) BOOST_PP_REPEAT_1_109(m, d) m(2, 109, d)
#define BOOST_PP_REPEAT_1_111(m,d) BOOST_PP_REPEAT_1_110(m, d) m(2, 110, d)
#define BOOST_PP_REPEAT_1_112(m,d) BOOST_PP_REPEAT_1_111(m, d) m(2, 111, d)
#define BOOST_PP_REPEAT_1_113(m,d) BOOST_PP_REPEAT_1_112(m, d) m(2, 112, d)
#define BOOST_PP_REPEAT_1_114(m,d) BOOST_PP_REPEAT_1_113(m, d) m(2, 113, d)
#define BOOST_PP_REPEAT_1_115(m,d) BOOST_PP_REPEAT_1_114(m, d) m(2, 114, d)
#define BOOST_PP_REPEAT_1_116(m,d) BOOST_PP_REPEAT_1_115(m, d) m(2, 115, d)
#define BOOST_PP_REPEAT_1_117(m,d) BOOST_PP_REPEAT_1_116(m, d) m(2, 116, d)
#define BOOST_PP_REPEAT_1_118(m,d) BOOST_PP_REPEAT_1_117(m, d) m(2, 117, d)
#define BOOST_PP_REPEAT_1_119(m,d) BOOST_PP_REPEAT_1_118(m, d) m(2, 118, d)
#define BOOST_PP_REPEAT_1_120(m,d) BOOST_PP_REPEAT_1_119(m, d) m(2, 119, d)
#define BOOST_PP_REPEAT_1_121(m,d) BOOST_PP_REPEAT_1_120(m, d) m(2, 120, d)
#define BOOST_PP_REPEAT_1_122(m,d) BOOST_PP_REPEAT_1_121(m, d) m(2, 121, d)
#define BOOST_PP_REPEAT_1_123(m,d) BOOST_PP_REPEAT_1_122(m, d) m(2, 122, d)
#define BOOST_PP_REPEAT_1_124(m,d) BOOST_PP_REPEAT_1_123(m, d) m(2, 123, d)
#define BOOST_PP_REPEAT_1_125(m,d) BOOST_PP_REPEAT_1_124(m, d) m(2, 124, d)
#define BOOST_PP_REPEAT_1_126(m,d) BOOST_PP_REPEAT_1_125(m, d) m(2, 125, d)
#define BOOST_PP_REPEAT_1_127(m,d) BOOST_PP_REPEAT_1_126(m, d) m(2, 126, d)
#define BOOST_PP_REPEAT_1_128(m,d) BOOST_PP_REPEAT_1_127(m, d) m(2, 127, d)
#define BOOST_PP_REPEAT_1_129(m,d) BOOST_PP_REPEAT_1_128(m, d) m(2, 128, d)
#define BOOST_PP_REPEAT_1_130(m,d) BOOST_PP_REPEAT_1_129(m, d) m(2, 129, d)
#define BOOST_PP_REPEAT_1_131(m,d) BOOST_PP_REPEAT_1_130(m, d) m(2, 130, d)
#define BOOST_PP_REPEAT_1_132(m,d) BOOST_PP_REPEAT_1_131(m, d) m(2, 131, d)
#define BOOST_PP_REPEAT_1_133(m,d) BOOST_PP_REPEAT_1_132(m, d) m(2, 132, d)
#define BOOST_PP_REPEAT_1_134(m,d) BOOST_PP_REPEAT_1_133(m, d) m(2, 133, d)
#define BOOST_PP_REPEAT_1_135(m,d) BOOST_PP_REPEAT_1_134(m, d) m(2, 134, d)
#define BOOST_PP_REPEAT_1_136(m,d) BOOST_PP_REPEAT_1_135(m, d) m(2, 135, d)
#define BOOST_PP_REPEAT_1_137(m,d) BOOST_PP_REPEAT_1_136(m, d) m(2, 136, d)
#define BOOST_PP_REPEAT_1_138(m,d) BOOST_PP_REPEAT_1_137(m, d) m(2, 137, d)
#define BOOST_PP_REPEAT_1_139(m,d) BOOST_PP_REPEAT_1_138(m, d) m(2, 138, d)
#define BOOST_PP_REPEAT_1_140(m,d) BOOST_PP_REPEAT_1_139(m, d) m(2, 139, d)
#define BOOST_PP_REPEAT_1_141(m,d) BOOST_PP_REPEAT_1_140(m, d) m(2, 140, d)
#define BOOST_PP_REPEAT_1_142(m,d) BOOST_PP_REPEAT_1_141(m, d) m(2, 141, d)
#define BOOST_PP_REPEAT_1_143(m,d) BOOST_PP_REPEAT_1_142(m, d) m(2, 142, d)
#define BOOST_PP_REPEAT_1_144(m,d) BOOST_PP_REPEAT_1_143(m, d) m(2, 143, d)
#define BOOST_PP_REPEAT_1_145(m,d) BOOST_PP_REPEAT_1_144(m, d) m(2, 144, d)
#define BOOST_PP_REPEAT_1_146(m,d) BOOST_PP_REPEAT_1_145(m, d) m(2, 145, d)
#define BOOST_PP_REPEAT_1_147(m,d) BOOST_PP_REPEAT_1_146(m, d) m(2, 146, d)
#define BOOST_PP_REPEAT_1_148(m,d) BOOST_PP_REPEAT_1_147(m, d) m(2, 147, d)
#define BOOST_PP_REPEAT_1_149(m,d) BOOST_PP_REPEAT_1_148(m, d) m(2, 148, d)
#define BOOST_PP_REPEAT_1_150(m,d) BOOST_PP_REPEAT_1_149(m, d) m(2, 149, d)
#define BOOST_PP_REPEAT_1_151(m,d) BOOST_PP_REPEAT_1_150(m, d) m(2, 150, d)
#define BOOST_PP_REPEAT_1_152(m,d) BOOST_PP_REPEAT_1_151(m, d) m(2, 151, d)
#define BOOST_PP_REPEAT_1_153(m,d) BOOST_PP_REPEAT_1_152(m, d) m(2, 152, d)
#define BOOST_PP_REPEAT_1_154(m,d) BOOST_PP_REPEAT_1_153(m, d) m(2, 153, d)
#define BOOST_PP_REPEAT_1_155(m,d) BOOST_PP_REPEAT_1_154(m, d) m(2, 154, d)
#define BOOST_PP_REPEAT_1_156(m,d) BOOST_PP_REPEAT_1_155(m, d) m(2, 155, d)
#define BOOST_PP_REPEAT_1_157(m,d) BOOST_PP_REPEAT_1_156(m, d) m(2, 156, d)
#define BOOST_PP_REPEAT_1_158(m,d) BOOST_PP_REPEAT_1_157(m, d) m(2, 157, d)
#define BOOST_PP_REPEAT_1_159(m,d) BOOST_PP_REPEAT_1_158(m, d) m(2, 158, d)
#define BOOST_PP_REPEAT_1_160(m,d) BOOST_PP_REPEAT_1_159(m, d) m(2, 159, d)
#define BOOST_PP_REPEAT_1_161(m,d) BOOST_PP_REPEAT_1_160(m, d) m(2, 160, d)
#define BOOST_PP_REPEAT_1_162(m,d) BOOST_PP_REPEAT_1_161(m, d) m(2, 161, d)
#define BOOST_PP_REPEAT_1_163(m,d) BOOST_PP_REPEAT_1_162(m, d) m(2, 162, d)
#define BOOST_PP_REPEAT_1_164(m,d) BOOST_PP_REPEAT_1_163(m, d) m(2, 163, d)
#define BOOST_PP_REPEAT_1_165(m,d) BOOST_PP_REPEAT_1_164(m, d) m(2, 164, d)
#define BOOST_PP_REPEAT_1_166(m,d) BOOST_PP_REPEAT_1_165(m, d) m(2, 165, d)
#define BOOST_PP_REPEAT_1_167(m,d) BOOST_PP_REPEAT_1_166(m, d) m(2, 166, d)
#define BOOST_PP_REPEAT_1_168(m,d) BOOST_PP_REPEAT_1_167(m, d) m(2, 167, d)
#define BOOST_PP_REPEAT_1_169(m,d) BOOST_PP_REPEAT_1_168(m, d) m(2, 168, d)
#define BOOST_PP_REPEAT_1_170(m,d) BOOST_PP_REPEAT_1_169(m, d) m(2, 169, d)
#define BOOST_PP_REPEAT_1_171(m,d) BOOST_PP_REPEAT_1_170(m, d) m(2, 170, d)
#define BOOST_PP_REPEAT_1_172(m,d) BOOST_PP_REPEAT_1_171(m, d) m(2, 171, d)
#define BOOST_PP_REPEAT_1_173(m,d) BOOST_PP_REPEAT_1_172(m, d) m(2, 172, d)
#define BOOST_PP_REPEAT_1_174(m,d) BOOST_PP_REPEAT_1_173(m, d) m(2, 173, d)
#define BOOST_PP_REPEAT_1_175(m,d) BOOST_PP_REPEAT_1_174(m, d) m(2, 174, d)
#define BOOST_PP_REPEAT_1_176(m,d) BOOST_PP_REPEAT_1_175(m, d) m(2, 175, d)
#define BOOST_PP_REPEAT_1_177(m,d) BOOST_PP_REPEAT_1_176(m, d) m(2, 176, d)
#define BOOST_PP_REPEAT_1_178(m,d) BOOST_PP_REPEAT_1_177(m, d) m(2, 177, d)
#define BOOST_PP_REPEAT_1_179(m,d) BOOST_PP_REPEAT_1_178(m, d) m(2, 178, d)
#define BOOST_PP_REPEAT_1_180(m,d) BOOST_PP_REPEAT_1_179(m, d) m(2, 179, d)
#define BOOST_PP_REPEAT_1_181(m,d) BOOST_PP_REPEAT_1_180(m, d) m(2, 180, d)
#define BOOST_PP_REPEAT_1_182(m,d) BOOST_PP_REPEAT_1_181(m, d) m(2, 181, d)
#define BOOST_PP_REPEAT_1_183(m,d) BOOST_PP_REPEAT_1_182(m, d) m(2, 182, d)
#define BOOST_PP_REPEAT_1_184(m,d) BOOST_PP_REPEAT_1_183(m, d) m(2, 183, d)
#define BOOST_PP_REPEAT_1_185(m,d) BOOST_PP_REPEAT_1_184(m, d) m(2, 184, d)
#define BOOST_PP_REPEAT_1_186(m,d) BOOST_PP_REPEAT_1_185(m, d) m(2, 185, d)
#define BOOST_PP_REPEAT_1_187(m,d) BOOST_PP_REPEAT_1_186(m, d) m(2, 186, d)
#define BOOST_PP_REPEAT_1_188(m,d) BOOST_PP_REPEAT_1_187(m, d) m(2, 187, d)
#define BOOST_PP_REPEAT_1_189(m,d) BOOST_PP_REPEAT_1_188(m, d) m(2, 188, d)
#define BOOST_PP_REPEAT_1_190(m,d) BOOST_PP_REPEAT_1_189(m, d) m(2, 189, d)
#define BOOST_PP_REPEAT_1_191(m,d) BOOST_PP_REPEAT_1_190(m, d) m(2, 190, d)
#define BOOST_PP_REPEAT_1_192(m,d) BOOST_PP_REPEAT_1_191(m, d) m(2, 191, d)
#define BOOST_PP_REPEAT_1_193(m,d) BOOST_PP_REPEAT_1_192(m, d) m(2, 192, d)
#define BOOST_PP_REPEAT_1_194(m,d) BOOST_PP_REPEAT_1_193(m, d) m(2, 193, d)
#define BOOST_PP_REPEAT_1_195(m,d) BOOST_PP_REPEAT_1_194(m, d) m(2, 194, d)
#define BOOST_PP_REPEAT_1_196(m,d) BOOST_PP_REPEAT_1_195(m, d) m(2, 195, d)
#define BOOST_PP_REPEAT_1_197(m,d) BOOST_PP_REPEAT_1_196(m, d) m(2, 196, d)
#define BOOST_PP_REPEAT_1_198(m,d) BOOST_PP_REPEAT_1_197(m, d) m(2, 197, d)
#define BOOST_PP_REPEAT_1_199(m,d) BOOST_PP_REPEAT_1_198(m, d) m(2, 198, d)
#define BOOST_PP_REPEAT_1_200(m,d) BOOST_PP_REPEAT_1_199(m, d) m(2, 199, d)
#define BOOST_PP_REPEAT_1_201(m,d) BOOST_PP_REPEAT_1_200(m, d) m(2, 200, d)
#define BOOST_PP_REPEAT_1_202(m,d) BOOST_PP_REPEAT_1_201(m, d) m(2, 201, d)
#define BOOST_PP_REPEAT_1_203(m,d) BOOST_PP_REPEAT_1_202(m, d) m(2, 202, d)
#define BOOST_PP_REPEAT_1_204(m,d) BOOST_PP_REPEAT_1_203(m, d) m(2, 203, d)
#define BOOST_PP_REPEAT_1_205(m,d) BOOST_PP_REPEAT_1_204(m, d) m(2, 204, d)
#define BOOST_PP_REPEAT_1_206(m,d) BOOST_PP_REPEAT_1_205(m, d) m(2, 205, d)
#define BOOST_PP_REPEAT_1_207(m,d) BOOST_PP_REPEAT_1_206(m, d) m(2, 206, d)
#define BOOST_PP_REPEAT_1_208(m,d) BOOST_PP_REPEAT_1_207(m, d) m(2, 207, d)
#define BOOST_PP_REPEAT_1_209(m,d) BOOST_PP_REPEAT_1_208(m, d) m(2, 208, d)
#define BOOST_PP_REPEAT_1_210(m,d) BOOST_PP_REPEAT_1_209(m, d) m(2, 209, d)
#define BOOST_PP_REPEAT_1_211(m,d) BOOST_PP_REPEAT_1_210(m, d) m(2, 210, d)
#define BOOST_PP_REPEAT_1_212(m,d) BOOST_PP_REPEAT_1_211(m, d) m(2, 211, d)
#define BOOST_PP_REPEAT_1_213(m,d) BOOST_PP_REPEAT_1_212(m, d) m(2, 212, d)
#define BOOST_PP_REPEAT_1_214(m,d) BOOST_PP_REPEAT_1_213(m, d) m(2, 213, d)
#define BOOST_PP_REPEAT_1_215(m,d) BOOST_PP_REPEAT_1_214(m, d) m(2, 214, d)
#define BOOST_PP_REPEAT_1_216(m,d) BOOST_PP_REPEAT_1_215(m, d) m(2, 215, d)
#define BOOST_PP_REPEAT_1_217(m,d) BOOST_PP_REPEAT_1_216(m, d) m(2, 216, d)
#define BOOST_PP_REPEAT_1_218(m,d) BOOST_PP_REPEAT_1_217(m, d) m(2, 217, d)
#define BOOST_PP_REPEAT_1_219(m,d) BOOST_PP_REPEAT_1_218(m, d) m(2, 218, d)
#define BOOST_PP_REPEAT_1_220(m,d) BOOST_PP_REPEAT_1_219(m, d) m(2, 219, d)
#define BOOST_PP_REPEAT_1_221(m,d) BOOST_PP_REPEAT_1_220(m, d) m(2, 220, d)
#define BOOST_PP_REPEAT_1_222(m,d) BOOST_PP_REPEAT_1_221(m, d) m(2, 221, d)
#define BOOST_PP_REPEAT_1_223(m,d) BOOST_PP_REPEAT_1_222(m, d) m(2, 222, d)
#define BOOST_PP_REPEAT_1_224(m,d) BOOST_PP_REPEAT_1_223(m, d) m(2, 223, d)
#define BOOST_PP_REPEAT_1_225(m,d) BOOST_PP_REPEAT_1_224(m, d) m(2, 224, d)
#define BOOST_PP_REPEAT_1_226(m,d) BOOST_PP_REPEAT_1_225(m, d) m(2, 225, d)
#define BOOST_PP_REPEAT_1_227(m,d) BOOST_PP_REPEAT_1_226(m, d) m(2, 226, d)
#define BOOST_PP_REPEAT_1_228(m,d) BOOST_PP_REPEAT_1_227(m, d) m(2, 227, d)
#define BOOST_PP_REPEAT_1_229(m,d) BOOST_PP_REPEAT_1_228(m, d) m(2, 228, d)
#define BOOST_PP_REPEAT_1_230(m,d) BOOST_PP_REPEAT_1_229(m, d) m(2, 229, d)
#define BOOST_PP_REPEAT_1_231(m,d) BOOST_PP_REPEAT_1_230(m, d) m(2, 230, d)
#define BOOST_PP_REPEAT_1_232(m,d) BOOST_PP_REPEAT_1_231(m, d) m(2, 231, d)
#define BOOST_PP_REPEAT_1_233(m,d) BOOST_PP_REPEAT_1_232(m, d) m(2, 232, d)
#define BOOST_PP_REPEAT_1_234(m,d) BOOST_PP_REPEAT_1_233(m, d) m(2, 233, d)
#define BOOST_PP_REPEAT_1_235(m,d) BOOST_PP_REPEAT_1_234(m, d) m(2, 234, d)
#define BOOST_PP_REPEAT_1_236(m,d) BOOST_PP_REPEAT_1_235(m, d) m(2, 235, d)
#define BOOST_PP_REPEAT_1_237(m,d) BOOST_PP_REPEAT_1_236(m, d) m(2, 236, d)
#define BOOST_PP_REPEAT_1_238(m,d) BOOST_PP_REPEAT_1_237(m, d) m(2, 237, d)
#define BOOST_PP_REPEAT_1_239(m,d) BOOST_PP_REPEAT_1_238(m, d) m(2, 238, d)
#define BOOST_PP_REPEAT_1_240(m,d) BOOST_PP_REPEAT_1_239(m, d) m(2, 239, d)
#define BOOST_PP_REPEAT_1_241(m,d) BOOST_PP_REPEAT_1_240(m, d) m(2, 240, d)
#define BOOST_PP_REPEAT_1_242(m,d) BOOST_PP_REPEAT_1_241(m, d) m(2, 241, d)
#define BOOST_PP_REPEAT_1_243(m,d) BOOST_PP_REPEAT_1_242(m, d) m(2, 242, d)
#define BOOST_PP_REPEAT_1_244(m,d) BOOST_PP_REPEAT_1_243(m, d) m(2, 243, d)
#define BOOST_PP_REPEAT_1_245(m,d) BOOST_PP_REPEAT_1_244(m, d) m(2, 244, d)
#define BOOST_PP_REPEAT_1_246(m,d) BOOST_PP_REPEAT_1_245(m, d) m(2, 245, d)
#define BOOST_PP_REPEAT_1_247(m,d) BOOST_PP_REPEAT_1_246(m, d) m(2, 246, d)
#define BOOST_PP_REPEAT_1_248(m,d) BOOST_PP_REPEAT_1_247(m, d) m(2, 247, d)
#define BOOST_PP_REPEAT_1_249(m,d) BOOST_PP_REPEAT_1_248(m, d) m(2, 248, d)
#define BOOST_PP_REPEAT_1_250(m,d) BOOST_PP_REPEAT_1_249(m, d) m(2, 249, d)
#define BOOST_PP_REPEAT_1_251(m,d) BOOST_PP_REPEAT_1_250(m, d) m(2, 250, d)
#define BOOST_PP_REPEAT_1_252(m,d) BOOST_PP_REPEAT_1_251(m, d) m(2, 251, d)
#define BOOST_PP_REPEAT_1_253(m,d) BOOST_PP_REPEAT_1_252(m, d) m(2, 252, d)
#define BOOST_PP_REPEAT_1_254(m,d) BOOST_PP_REPEAT_1_253(m, d) m(2, 253, d)
#define BOOST_PP_REPEAT_1_255(m,d) BOOST_PP_REPEAT_1_254(m, d) m(2, 254, d)
#define BOOST_PP_REPEAT_1_256(m,d) BOOST_PP_REPEAT_1_255(m, d) m(2, 255, d)
#define BOOST_PP_REPEAT_2_0(m,d)
#define BOOST_PP_REPEAT_2_1(m,d) m(3, 0, d)
#define BOOST_PP_REPEAT_2_2(m,d) BOOST_PP_REPEAT_2_1(m, d) m(3, 1, d)
#define BOOST_PP_REPEAT_2_3(m,d) BOOST_PP_REPEAT_2_2(m, d) m(3, 2, d)
#define BOOST_PP_REPEAT_2_4(m,d) BOOST_PP_REPEAT_2_3(m, d) m(3, 3, d)
#define BOOST_PP_REPEAT_2_5(m,d) BOOST_PP_REPEAT_2_4(m, d) m(3, 4, d)
#define BOOST_PP_REPEAT_2_6(m,d) BOOST_PP_REPEAT_2_5(m, d) m(3, 5, d)
#define BOOST_PP_REPEAT_2_7(m,d) BOOST_PP_REPEAT_2_6(m, d) m(3, 6, d)
#define BOOST_PP_REPEAT_2_8(m,d) BOOST_PP_REPEAT_2_7(m, d) m(3, 7, d)
#define BOOST_PP_REPEAT_2_9(m,d) BOOST_PP_REPEAT_2_8(m, d) m(3, 8, d)
#define BOOST_PP_REPEAT_2_10(m,d) BOOST_PP_REPEAT_2_9(m, d) m(3, 9, d)
#define BOOST_PP_REPEAT_2_11(m,d) BOOST_PP_REPEAT_2_10(m, d) m(3, 10, d)
#define BOOST_PP_REPEAT_2_12(m,d) BOOST_PP_REPEAT_2_11(m, d) m(3, 11, d)
#define BOOST_PP_REPEAT_2_13(m,d) BOOST_PP_REPEAT_2_12(m, d) m(3, 12, d)
#define BOOST_PP_REPEAT_2_14(m,d) BOOST_PP_REPEAT_2_13(m, d) m(3, 13, d)
#define BOOST_PP_REPEAT_2_15(m,d) BOOST_PP_REPEAT_2_14(m, d) m(3, 14, d)
#define BOOST_PP_REPEAT_2_16(m,d) BOOST_PP_REPEAT_2_15(m, d) m(3, 15, d)
#define BOOST_PP_REPEAT_2_17(m,d) BOOST_PP_REPEAT_2_16(m, d) m(3, 16, d)
#define BOOST_PP_REPEAT_2_18(m,d) BOOST_PP_REPEAT_2_17(m, d) m(3, 17, d)
#define BOOST_PP_REPEAT_2_19(m,d) BOOST_PP_REPEAT_2_18(m, d) m(3, 18, d)
#define BOOST_PP_REPEAT_2_20(m,d) BOOST_PP_REPEAT_2_19(m, d) m(3, 19, d)
#define BOOST_PP_REPEAT_2_21(m,d) BOOST_PP_REPEAT_2_20(m, d) m(3, 20, d)
#define BOOST_PP_REPEAT_2_22(m,d) BOOST_PP_REPEAT_2_21(m, d) m(3, 21, d)
#define BOOST_PP_REPEAT_2_23(m,d) BOOST_PP_REPEAT_2_22(m, d) m(3, 22, d)
#define BOOST_PP_REPEAT_2_24(m,d) BOOST_PP_REPEAT_2_23(m, d) m(3, 23, d)
#define BOOST_PP_REPEAT_2_25(m,d) BOOST_PP_REPEAT_2_24(m, d) m(3, 24, d)
#define BOOST_PP_REPEAT_2_26(m,d) BOOST_PP_REPEAT_2_25(m, d) m(3, 25, d)
#define BOOST_PP_REPEAT_2_27(m,d) BOOST_PP_REPEAT_2_26(m, d) m(3, 26, d)
#define BOOST_PP_REPEAT_2_28(m,d) BOOST_PP_REPEAT_2_27(m, d) m(3, 27, d)
#define BOOST_PP_REPEAT_2_29(m,d) BOOST_PP_REPEAT_2_28(m, d) m(3, 28, d)
#define BOOST_PP_REPEAT_2_30(m,d) BOOST_PP_REPEAT_2_29(m, d) m(3, 29, d)
#define BOOST_PP_REPEAT_2_31(m,d) BOOST_PP_REPEAT_2_30(m, d) m(3, 30, d)
#define BOOST_PP_REPEAT_2_32(m,d) BOOST_PP_REPEAT_2_31(m, d) m(3, 31, d)
#define BOOST_PP_REPEAT_2_33(m,d) BOOST_PP_REPEAT_2_32(m, d) m(3, 32, d)
#define BOOST_PP_REPEAT_2_34(m,d) BOOST_PP_REPEAT_2_33(m, d) m(3, 33, d)
#define BOOST_PP_REPEAT_2_35(m,d) BOOST_PP_REPEAT_2_34(m, d) m(3, 34, d)
#define BOOST_PP_REPEAT_2_36(m,d) BOOST_PP_REPEAT_2_35(m, d) m(3, 35, d)
#define BOOST_PP_REPEAT_2_37(m,d) BOOST_PP_REPEAT_2_36(m, d) m(3, 36, d)
#define BOOST_PP_REPEAT_2_38(m,d) BOOST_PP_REPEAT_2_37(m, d) m(3, 37, d)
#define BOOST_PP_REPEAT_2_39(m,d) BOOST_PP_REPEAT_2_38(m, d) m(3, 38, d)
#define BOOST_PP_REPEAT_2_40(m,d) BOOST_PP_REPEAT_2_39(m, d) m(3, 39, d)
#define BOOST_PP_REPEAT_2_41(m,d) BOOST_PP_REPEAT_2_40(m, d) m(3, 40, d)
#define BOOST_PP_REPEAT_2_42(m,d) BOOST_PP_REPEAT_2_41(m, d) m(3, 41, d)
#define BOOST_PP_REPEAT_2_43(m,d) BOOST_PP_REPEAT_2_42(m, d) m(3, 42, d)
#define BOOST_PP_REPEAT_2_44(m,d) BOOST_PP_REPEAT_2_43(m, d) m(3, 43, d)
#define BOOST_PP_REPEAT_2_45(m,d) BOOST_PP_REPEAT_2_44(m, d) m(3, 44, d)
#define BOOST_PP_REPEAT_2_46(m,d) BOOST_PP_REPEAT_2_45(m, d) m(3, 45, d)
#define BOOST_PP_REPEAT_2_47(m,d) BOOST_PP_REPEAT_2_46(m, d) m(3, 46, d)
#define BOOST_PP_REPEAT_2_48(m,d) BOOST_PP_REPEAT_2_47(m, d) m(3, 47, d)
#define BOOST_PP_REPEAT_2_49(m,d) BOOST_PP_REPEAT_2_48(m, d) m(3, 48, d)
#define BOOST_PP_REPEAT_2_50(m,d) BOOST_PP_REPEAT_2_49(m, d) m(3, 49, d)
#define BOOST_PP_REPEAT_2_51(m,d) BOOST_PP_REPEAT_2_50(m, d) m(3, 50, d)
#define BOOST_PP_REPEAT_2_52(m,d) BOOST_PP_REPEAT_2_51(m, d) m(3, 51, d)
#define BOOST_PP_REPEAT_2_53(m,d) BOOST_PP_REPEAT_2_52(m, d) m(3, 52, d)
#define BOOST_PP_REPEAT_2_54(m,d) BOOST_PP_REPEAT_2_53(m, d) m(3, 53, d)
#define BOOST_PP_REPEAT_2_55(m,d) BOOST_PP_REPEAT_2_54(m, d) m(3, 54, d)
#define BOOST_PP_REPEAT_2_56(m,d) BOOST_PP_REPEAT_2_55(m, d) m(3, 55, d)
#define BOOST_PP_REPEAT_2_57(m,d) BOOST_PP_REPEAT_2_56(m, d) m(3, 56, d)
#define BOOST_PP_REPEAT_2_58(m,d) BOOST_PP_REPEAT_2_57(m, d) m(3, 57, d)
#define BOOST_PP_REPEAT_2_59(m,d) BOOST_PP_REPEAT_2_58(m, d) m(3, 58, d)
#define BOOST_PP_REPEAT_2_60(m,d) BOOST_PP_REPEAT_2_59(m, d) m(3, 59, d)
#define BOOST_PP_REPEAT_2_61(m,d) BOOST_PP_REPEAT_2_60(m, d) m(3, 60, d)
#define BOOST_PP_REPEAT_2_62(m,d) BOOST_PP_REPEAT_2_61(m, d) m(3, 61, d)
#define BOOST_PP_REPEAT_2_63(m,d) BOOST_PP_REPEAT_2_62(m, d) m(3, 62, d)
#define BOOST_PP_REPEAT_2_64(m,d) BOOST_PP_REPEAT_2_63(m, d) m(3, 63, d)
#define BOOST_PP_REPEAT_2_65(m,d) BOOST_PP_REPEAT_2_64(m, d) m(3, 64, d)
#define BOOST_PP_REPEAT_2_66(m,d) BOOST_PP_REPEAT_2_65(m, d) m(3, 65, d)
#define BOOST_PP_REPEAT_2_67(m,d) BOOST_PP_REPEAT_2_66(m, d) m(3, 66, d)
#define BOOST_PP_REPEAT_2_68(m,d) BOOST_PP_REPEAT_2_67(m, d) m(3, 67, d)
#define BOOST_PP_REPEAT_2_69(m,d) BOOST_PP_REPEAT_2_68(m, d) m(3, 68, d)
#define BOOST_PP_REPEAT_2_70(m,d) BOOST_PP_REPEAT_2_69(m, d) m(3, 69, d)
#define BOOST_PP_REPEAT_2_71(m,d) BOOST_PP_REPEAT_2_70(m, d) m(3, 70, d)
#define BOOST_PP_REPEAT_2_72(m,d) BOOST_PP_REPEAT_2_71(m, d) m(3, 71, d)
#define BOOST_PP_REPEAT_2_73(m,d) BOOST_PP_REPEAT_2_72(m, d) m(3, 72, d)
#define BOOST_PP_REPEAT_2_74(m,d) BOOST_PP_REPEAT_2_73(m, d) m(3, 73, d)
#define BOOST_PP_REPEAT_2_75(m,d) BOOST_PP_REPEAT_2_74(m, d) m(3, 74, d)
#define BOOST_PP_REPEAT_2_76(m,d) BOOST_PP_REPEAT_2_75(m, d) m(3, 75, d)
#define BOOST_PP_REPEAT_2_77(m,d) BOOST_PP_REPEAT_2_76(m, d) m(3, 76, d)
#define BOOST_PP_REPEAT_2_78(m,d) BOOST_PP_REPEAT_2_77(m, d) m(3, 77, d)
#define BOOST_PP_REPEAT_2_79(m,d) BOOST_PP_REPEAT_2_78(m, d) m(3, 78, d)
#define BOOST_PP_REPEAT_2_80(m,d) BOOST_PP_REPEAT_2_79(m, d) m(3, 79, d)
#define BOOST_PP_REPEAT_2_81(m,d) BOOST_PP_REPEAT_2_80(m, d) m(3, 80, d)
#define BOOST_PP_REPEAT_2_82(m,d) BOOST_PP_REPEAT_2_81(m, d) m(3, 81, d)
#define BOOST_PP_REPEAT_2_83(m,d) BOOST_PP_REPEAT_2_82(m, d) m(3, 82, d)
#define BOOST_PP_REPEAT_2_84(m,d) BOOST_PP_REPEAT_2_83(m, d) m(3, 83, d)
#define BOOST_PP_REPEAT_2_85(m,d) BOOST_PP_REPEAT_2_84(m, d) m(3, 84, d)
#define BOOST_PP_REPEAT_2_86(m,d) BOOST_PP_REPEAT_2_85(m, d) m(3, 85, d)
#define BOOST_PP_REPEAT_2_87(m,d) BOOST_PP_REPEAT_2_86(m, d) m(3, 86, d)
#define BOOST_PP_REPEAT_2_88(m,d) BOOST_PP_REPEAT_2_87(m, d) m(3, 87, d)
#define BOOST_PP_REPEAT_2_89(m,d) BOOST_PP_REPEAT_2_88(m, d) m(3, 88, d)
#define BOOST_PP_REPEAT_2_90(m,d) BOOST_PP_REPEAT_2_89(m, d) m(3, 89, d)
#define BOOST_PP_REPEAT_2_91(m,d) BOOST_PP_REPEAT_2_90(m, d) m(3, 90, d)
#define BOOST_PP_REPEAT_2_92(m,d) BOOST_PP_REPEAT_2_91(m, d) m(3, 91, d)
#define BOOST_PP_REPEAT_2_93(m,d) BOOST_PP_REPEAT_2_92(m, d) m(3, 92, d)
#define BOOST_PP_REPEAT_2_94(m,d) BOOST_PP_REPEAT_2_93(m, d) m(3, 93, d)
#define BOOST_PP_REPEAT_2_95(m,d) BOOST_PP_REPEAT_2_94(m, d) m(3, 94, d)
#define BOOST_PP_REPEAT_2_96(m,d) BOOST_PP_REPEAT_2_95(m, d) m(3, 95, d)
#define BOOST_PP_REPEAT_2_97(m,d) BOOST_PP_REPEAT_2_96(m, d) m(3, 96, d)
#define BOOST_PP_REPEAT_2_98(m,d) BOOST_PP_REPEAT_2_97(m, d) m(3, 97, d)
#define BOOST_PP_REPEAT_2_99(m,d) BOOST_PP_REPEAT_2_98(m, d) m(3, 98, d)
#define BOOST_PP_REPEAT_2_100(m,d) BOOST_PP_REPEAT_2_99(m, d) m(3, 99, d)
#define BOOST_PP_REPEAT_2_101(m,d) BOOST_PP_REPEAT_2_100(m, d) m(3, 100, d)
#define BOOST_PP_REPEAT_2_102(m,d) BOOST_PP_REPEAT_2_101(m, d) m(3, 101, d)
#define BOOST_PP_REPEAT_2_103(m,d) BOOST_PP_REPEAT_2_102(m, d) m(3, 102, d)
#define BOOST_PP_REPEAT_2_104(m,d) BOOST_PP_REPEAT_2_103(m, d) m(3, 103, d)
#define BOOST_PP_REPEAT_2_105(m,d) BOOST_PP_REPEAT_2_104(m, d) m(3, 104, d)
#define BOOST_PP_REPEAT_2_106(m,d) BOOST_PP_REPEAT_2_105(m, d) m(3, 105, d)
#define BOOST_PP_REPEAT_2_107(m,d) BOOST_PP_REPEAT_2_106(m, d) m(3, 106, d)
#define BOOST_PP_REPEAT_2_108(m,d) BOOST_PP_REPEAT_2_107(m, d) m(3, 107, d)
#define BOOST_PP_REPEAT_2_109(m,d) BOOST_PP_REPEAT_2_108(m, d) m(3, 108, d)
#define BOOST_PP_REPEAT_2_110(m,d) BOOST_PP_REPEAT_2_109(m, d) m(3, 109, d)
#define BOOST_PP_REPEAT_2_111(m,d) BOOST_PP_REPEAT_2_110(m, d) m(3, 110, d)
#define BOOST_PP_REPEAT_2_112(m,d) BOOST_PP_REPEAT_2_111(m, d) m(3, 111, d)
#define BOOST_PP_REPEAT_2_113(m,d) BOOST_PP_REPEAT_2_112(m, d) m(3, 112, d)
#define BOOST_PP_REPEAT_2_114(m,d) BOOST_PP_REPEAT_2_113(m, d) m(3, 113, d)
#define BOOST_PP_REPEAT_2_115(m,d) BOOST_PP_REPEAT_2_114(m, d) m(3, 114, d)
#define BOOST_PP_REPEAT_2_116(m,d) BOOST_PP_REPEAT_2_115(m, d) m(3, 115, d)
#define BOOST_PP_REPEAT_2_117(m,d) BOOST_PP_REPEAT_2_116(m, d) m(3, 116, d)
#define BOOST_PP_REPEAT_2_118(m,d) BOOST_PP_REPEAT_2_117(m, d) m(3, 117, d)
#define BOOST_PP_REPEAT_2_119(m,d) BOOST_PP_REPEAT_2_118(m, d) m(3, 118, d)
#define BOOST_PP_REPEAT_2_120(m,d) BOOST_PP_REPEAT_2_119(m, d) m(3, 119, d)
#define BOOST_PP_REPEAT_2_121(m,d) BOOST_PP_REPEAT_2_120(m, d) m(3, 120, d)
#define BOOST_PP_REPEAT_2_122(m,d) BOOST_PP_REPEAT_2_121(m, d) m(3, 121, d)
#define BOOST_PP_REPEAT_2_123(m,d) BOOST_PP_REPEAT_2_122(m, d) m(3, 122, d)
#define BOOST_PP_REPEAT_2_124(m,d) BOOST_PP_REPEAT_2_123(m, d) m(3, 123, d)
#define BOOST_PP_REPEAT_2_125(m,d) BOOST_PP_REPEAT_2_124(m, d) m(3, 124, d)
#define BOOST_PP_REPEAT_2_126(m,d) BOOST_PP_REPEAT_2_125(m, d) m(3, 125, d)
#define BOOST_PP_REPEAT_2_127(m,d) BOOST_PP_REPEAT_2_126(m, d) m(3, 126, d)
#define BOOST_PP_REPEAT_2_128(m,d) BOOST_PP_REPEAT_2_127(m, d) m(3, 127, d)
#define BOOST_PP_REPEAT_2_129(m,d) BOOST_PP_REPEAT_2_128(m, d) m(3, 128, d)
#define BOOST_PP_REPEAT_2_130(m,d) BOOST_PP_REPEAT_2_129(m, d) m(3, 129, d)
#define BOOST_PP_REPEAT_2_131(m,d) BOOST_PP_REPEAT_2_130(m, d) m(3, 130, d)
#define BOOST_PP_REPEAT_2_132(m,d) BOOST_PP_REPEAT_2_131(m, d) m(3, 131, d)
#define BOOST_PP_REPEAT_2_133(m,d) BOOST_PP_REPEAT_2_132(m, d) m(3, 132, d)
#define BOOST_PP_REPEAT_2_134(m,d) BOOST_PP_REPEAT_2_133(m, d) m(3, 133, d)
#define BOOST_PP_REPEAT_2_135(m,d) BOOST_PP_REPEAT_2_134(m, d) m(3, 134, d)
#define BOOST_PP_REPEAT_2_136(m,d) BOOST_PP_REPEAT_2_135(m, d) m(3, 135, d)
#define BOOST_PP_REPEAT_2_137(m,d) BOOST_PP_REPEAT_2_136(m, d) m(3, 136, d)
#define BOOST_PP_REPEAT_2_138(m,d) BOOST_PP_REPEAT_2_137(m, d) m(3, 137, d)
#define BOOST_PP_REPEAT_2_139(m,d) BOOST_PP_REPEAT_2_138(m, d) m(3, 138, d)
#define BOOST_PP_REPEAT_2_140(m,d) BOOST_PP_REPEAT_2_139(m, d) m(3, 139, d)
#define BOOST_PP_REPEAT_2_141(m,d) BOOST_PP_REPEAT_2_140(m, d) m(3, 140, d)
#define BOOST_PP_REPEAT_2_142(m,d) BOOST_PP_REPEAT_2_141(m, d) m(3, 141, d)
#define BOOST_PP_REPEAT_2_143(m,d) BOOST_PP_REPEAT_2_142(m, d) m(3, 142, d)
#define BOOST_PP_REPEAT_2_144(m,d) BOOST_PP_REPEAT_2_143(m, d) m(3, 143, d)
#define BOOST_PP_REPEAT_2_145(m,d) BOOST_PP_REPEAT_2_144(m, d) m(3, 144, d)
#define BOOST_PP_REPEAT_2_146(m,d) BOOST_PP_REPEAT_2_145(m, d) m(3, 145, d)
#define BOOST_PP_REPEAT_2_147(m,d) BOOST_PP_REPEAT_2_146(m, d) m(3, 146, d)
#define BOOST_PP_REPEAT_2_148(m,d) BOOST_PP_REPEAT_2_147(m, d) m(3, 147, d)
#define BOOST_PP_REPEAT_2_149(m,d) BOOST_PP_REPEAT_2_148(m, d) m(3, 148, d)
#define BOOST_PP_REPEAT_2_150(m,d) BOOST_PP_REPEAT_2_149(m, d) m(3, 149, d)
#define BOOST_PP_REPEAT_2_151(m,d) BOOST_PP_REPEAT_2_150(m, d) m(3, 150, d)
#define BOOST_PP_REPEAT_2_152(m,d) BOOST_PP_REPEAT_2_151(m, d) m(3, 151, d)
#define BOOST_PP_REPEAT_2_153(m,d) BOOST_PP_REPEAT_2_152(m, d) m(3, 152, d)
#define BOOST_PP_REPEAT_2_154(m,d) BOOST_PP_REPEAT_2_153(m, d) m(3, 153, d)
#define BOOST_PP_REPEAT_2_155(m,d) BOOST_PP_REPEAT_2_154(m, d) m(3, 154, d)
#define BOOST_PP_REPEAT_2_156(m,d) BOOST_PP_REPEAT_2_155(m, d) m(3, 155, d)
#define BOOST_PP_REPEAT_2_157(m,d) BOOST_PP_REPEAT_2_156(m, d) m(3, 156, d)
#define BOOST_PP_REPEAT_2_158(m,d) BOOST_PP_REPEAT_2_157(m, d) m(3, 157, d)
#define BOOST_PP_REPEAT_2_159(m,d) BOOST_PP_REPEAT_2_158(m, d) m(3, 158, d)
#define BOOST_PP_REPEAT_2_160(m,d) BOOST_PP_REPEAT_2_159(m, d) m(3, 159, d)
#define BOOST_PP_REPEAT_2_161(m,d) BOOST_PP_REPEAT_2_160(m, d) m(3, 160, d)
#define BOOST_PP_REPEAT_2_162(m,d) BOOST_PP_REPEAT_2_161(m, d) m(3, 161, d)
#define BOOST_PP_REPEAT_2_163(m,d) BOOST_PP_REPEAT_2_162(m, d) m(3, 162, d)
#define BOOST_PP_REPEAT_2_164(m,d) BOOST_PP_REPEAT_2_163(m, d) m(3, 163, d)
#define BOOST_PP_REPEAT_2_165(m,d) BOOST_PP_REPEAT_2_164(m, d) m(3, 164, d)
#define BOOST_PP_REPEAT_2_166(m,d) BOOST_PP_REPEAT_2_165(m, d) m(3, 165, d)
#define BOOST_PP_REPEAT_2_167(m,d) BOOST_PP_REPEAT_2_166(m, d) m(3, 166, d)
#define BOOST_PP_REPEAT_2_168(m,d) BOOST_PP_REPEAT_2_167(m, d) m(3, 167, d)
#define BOOST_PP_REPEAT_2_169(m,d) BOOST_PP_REPEAT_2_168(m, d) m(3, 168, d)
#define BOOST_PP_REPEAT_2_170(m,d) BOOST_PP_REPEAT_2_169(m, d) m(3, 169, d)
#define BOOST_PP_REPEAT_2_171(m,d) BOOST_PP_REPEAT_2_170(m, d) m(3, 170, d)
#define BOOST_PP_REPEAT_2_172(m,d) BOOST_PP_REPEAT_2_171(m, d) m(3, 171, d)
#define BOOST_PP_REPEAT_2_173(m,d) BOOST_PP_REPEAT_2_172(m, d) m(3, 172, d)
#define BOOST_PP_REPEAT_2_174(m,d) BOOST_PP_REPEAT_2_173(m, d) m(3, 173, d)
#define BOOST_PP_REPEAT_2_175(m,d) BOOST_PP_REPEAT_2_174(m, d) m(3, 174, d)
#define BOOST_PP_REPEAT_2_176(m,d) BOOST_PP_REPEAT_2_175(m, d) m(3, 175, d)
#define BOOST_PP_REPEAT_2_177(m,d) BOOST_PP_REPEAT_2_176(m, d) m(3, 176, d)
#define BOOST_PP_REPEAT_2_178(m,d) BOOST_PP_REPEAT_2_177(m, d) m(3, 177, d)
#define BOOST_PP_REPEAT_2_179(m,d) BOOST_PP_REPEAT_2_178(m, d) m(3, 178, d)
#define BOOST_PP_REPEAT_2_180(m,d) BOOST_PP_REPEAT_2_179(m, d) m(3, 179, d)
#define BOOST_PP_REPEAT_2_181(m,d) BOOST_PP_REPEAT_2_180(m, d) m(3, 180, d)
#define BOOST_PP_REPEAT_2_182(m,d) BOOST_PP_REPEAT_2_181(m, d) m(3, 181, d)
#define BOOST_PP_REPEAT_2_183(m,d) BOOST_PP_REPEAT_2_182(m, d) m(3, 182, d)
#define BOOST_PP_REPEAT_2_184(m,d) BOOST_PP_REPEAT_2_183(m, d) m(3, 183, d)
#define BOOST_PP_REPEAT_2_185(m,d) BOOST_PP_REPEAT_2_184(m, d) m(3, 184, d)
#define BOOST_PP_REPEAT_2_186(m,d) BOOST_PP_REPEAT_2_185(m, d) m(3, 185, d)
#define BOOST_PP_REPEAT_2_187(m,d) BOOST_PP_REPEAT_2_186(m, d) m(3, 186, d)
#define BOOST_PP_REPEAT_2_188(m,d) BOOST_PP_REPEAT_2_187(m, d) m(3, 187, d)
#define BOOST_PP_REPEAT_2_189(m,d) BOOST_PP_REPEAT_2_188(m, d) m(3, 188, d)
#define BOOST_PP_REPEAT_2_190(m,d) BOOST_PP_REPEAT_2_189(m, d) m(3, 189, d)
#define BOOST_PP_REPEAT_2_191(m,d) BOOST_PP_REPEAT_2_190(m, d) m(3, 190, d)
#define BOOST_PP_REPEAT_2_192(m,d) BOOST_PP_REPEAT_2_191(m, d) m(3, 191, d)
#define BOOST_PP_REPEAT_2_193(m,d) BOOST_PP_REPEAT_2_192(m, d) m(3, 192, d)
#define BOOST_PP_REPEAT_2_194(m,d) BOOST_PP_REPEAT_2_193(m, d) m(3, 193, d)
#define BOOST_PP_REPEAT_2_195(m,d) BOOST_PP_REPEAT_2_194(m, d) m(3, 194, d)
#define BOOST_PP_REPEAT_2_196(m,d) BOOST_PP_REPEAT_2_195(m, d) m(3, 195, d)
#define BOOST_PP_REPEAT_2_197(m,d) BOOST_PP_REPEAT_2_196(m, d) m(3, 196, d)
#define BOOST_PP_REPEAT_2_198(m,d) BOOST_PP_REPEAT_2_197(m, d) m(3, 197, d)
#define BOOST_PP_REPEAT_2_199(m,d) BOOST_PP_REPEAT_2_198(m, d) m(3, 198, d)
#define BOOST_PP_REPEAT_2_200(m,d) BOOST_PP_REPEAT_2_199(m, d) m(3, 199, d)
#define BOOST_PP_REPEAT_2_201(m,d) BOOST_PP_REPEAT_2_200(m, d) m(3, 200, d)
#define BOOST_PP_REPEAT_2_202(m,d) BOOST_PP_REPEAT_2_201(m, d) m(3, 201, d)
#define BOOST_PP_REPEAT_2_203(m,d) BOOST_PP_REPEAT_2_202(m, d) m(3, 202, d)
#define BOOST_PP_REPEAT_2_204(m,d) BOOST_PP_REPEAT_2_203(m, d) m(3, 203, d)
#define BOOST_PP_REPEAT_2_205(m,d) BOOST_PP_REPEAT_2_204(m, d) m(3, 204, d)
#define BOOST_PP_REPEAT_2_206(m,d) BOOST_PP_REPEAT_2_205(m, d) m(3, 205, d)
#define BOOST_PP_REPEAT_2_207(m,d) BOOST_PP_REPEAT_2_206(m, d) m(3, 206, d)
#define BOOST_PP_REPEAT_2_208(m,d) BOOST_PP_REPEAT_2_207(m, d) m(3, 207, d)
#define BOOST_PP_REPEAT_2_209(m,d) BOOST_PP_REPEAT_2_208(m, d) m(3, 208, d)
#define BOOST_PP_REPEAT_2_210(m,d) BOOST_PP_REPEAT_2_209(m, d) m(3, 209, d)
#define BOOST_PP_REPEAT_2_211(m,d) BOOST_PP_REPEAT_2_210(m, d) m(3, 210, d)
#define BOOST_PP_REPEAT_2_212(m,d) BOOST_PP_REPEAT_2_211(m, d) m(3, 211, d)
#define BOOST_PP_REPEAT_2_213(m,d) BOOST_PP_REPEAT_2_212(m, d) m(3, 212, d)
#define BOOST_PP_REPEAT_2_214(m,d) BOOST_PP_REPEAT_2_213(m, d) m(3, 213, d)
#define BOOST_PP_REPEAT_2_215(m,d) BOOST_PP_REPEAT_2_214(m, d) m(3, 214, d)
#define BOOST_PP_REPEAT_2_216(m,d) BOOST_PP_REPEAT_2_215(m, d) m(3, 215, d)
#define BOOST_PP_REPEAT_2_217(m,d) BOOST_PP_REPEAT_2_216(m, d) m(3, 216, d)
#define BOOST_PP_REPEAT_2_218(m,d) BOOST_PP_REPEAT_2_217(m, d) m(3, 217, d)
#define BOOST_PP_REPEAT_2_219(m,d) BOOST_PP_REPEAT_2_218(m, d) m(3, 218, d)
#define BOOST_PP_REPEAT_2_220(m,d) BOOST_PP_REPEAT_2_219(m, d) m(3, 219, d)
#define BOOST_PP_REPEAT_2_221(m,d) BOOST_PP_REPEAT_2_220(m, d) m(3, 220, d)
#define BOOST_PP_REPEAT_2_222(m,d) BOOST_PP_REPEAT_2_221(m, d) m(3, 221, d)
#define BOOST_PP_REPEAT_2_223(m,d) BOOST_PP_REPEAT_2_222(m, d) m(3, 222, d)
#define BOOST_PP_REPEAT_2_224(m,d) BOOST_PP_REPEAT_2_223(m, d) m(3, 223, d)
#define BOOST_PP_REPEAT_2_225(m,d) BOOST_PP_REPEAT_2_224(m, d) m(3, 224, d)
#define BOOST_PP_REPEAT_2_226(m,d) BOOST_PP_REPEAT_2_225(m, d) m(3, 225, d)
#define BOOST_PP_REPEAT_2_227(m,d) BOOST_PP_REPEAT_2_226(m, d) m(3, 226, d)
#define BOOST_PP_REPEAT_2_228(m,d) BOOST_PP_REPEAT_2_227(m, d) m(3, 227, d)
#define BOOST_PP_REPEAT_2_229(m,d) BOOST_PP_REPEAT_2_228(m, d) m(3, 228, d)
#define BOOST_PP_REPEAT_2_230(m,d) BOOST_PP_REPEAT_2_229(m, d) m(3, 229, d)
#define BOOST_PP_REPEAT_2_231(m,d) BOOST_PP_REPEAT_2_230(m, d) m(3, 230, d)
#define BOOST_PP_REPEAT_2_232(m,d) BOOST_PP_REPEAT_2_231(m, d) m(3, 231, d)
#define BOOST_PP_REPEAT_2_233(m,d) BOOST_PP_REPEAT_2_232(m, d) m(3, 232, d)
#define BOOST_PP_REPEAT_2_234(m,d) BOOST_PP_REPEAT_2_233(m, d) m(3, 233, d)
#define BOOST_PP_REPEAT_2_235(m,d) BOOST_PP_REPEAT_2_234(m, d) m(3, 234, d)
#define BOOST_PP_REPEAT_2_236(m,d) BOOST_PP_REPEAT_2_235(m, d) m(3, 235, d)
#define BOOST_PP_REPEAT_2_237(m,d) BOOST_PP_REPEAT_2_236(m, d) m(3, 236, d)
#define BOOST_PP_REPEAT_2_238(m,d) BOOST_PP_REPEAT_2_237(m, d) m(3, 237, d)
#define BOOST_PP_REPEAT_2_239(m,d) BOOST_PP_REPEAT_2_238(m, d) m(3, 238, d)
#define BOOST_PP_REPEAT_2_240(m,d) BOOST_PP_REPEAT_2_239(m, d) m(3, 239, d)
#define BOOST_PP_REPEAT_2_241(m,d) BOOST_PP_REPEAT_2_240(m, d) m(3, 240, d)
#define BOOST_PP_REPEAT_2_242(m,d) BOOST_PP_REPEAT_2_241(m, d) m(3, 241, d)
#define BOOST_PP_REPEAT_2_243(m,d) BOOST_PP_REPEAT_2_242(m, d) m(3, 242, d)
#define BOOST_PP_REPEAT_2_244(m,d) BOOST_PP_REPEAT_2_243(m, d) m(3, 243, d)
#define BOOST_PP_REPEAT_2_245(m,d) BOOST_PP_REPEAT_2_244(m, d) m(3, 244, d)
#define BOOST_PP_REPEAT_2_246(m,d) BOOST_PP_REPEAT_2_245(m, d) m(3, 245, d)
#define BOOST_PP_REPEAT_2_247(m,d) BOOST_PP_REPEAT_2_246(m, d) m(3, 246, d)
#define BOOST_PP_REPEAT_2_248(m,d) BOOST_PP_REPEAT_2_247(m, d) m(3, 247, d)
#define BOOST_PP_REPEAT_2_249(m,d) BOOST_PP_REPEAT_2_248(m, d) m(3, 248, d)
#define BOOST_PP_REPEAT_2_250(m,d) BOOST_PP_REPEAT_2_249(m, d) m(3, 249, d)
#define BOOST_PP_REPEAT_2_251(m,d) BOOST_PP_REPEAT_2_250(m, d) m(3, 250, d)
#define BOOST_PP_REPEAT_2_252(m,d) BOOST_PP_REPEAT_2_251(m, d) m(3, 251, d)
#define BOOST_PP_REPEAT_2_253(m,d) BOOST_PP_REPEAT_2_252(m, d) m(3, 252, d)
#define BOOST_PP_REPEAT_2_254(m,d) BOOST_PP_REPEAT_2_253(m, d) m(3, 253, d)
#define BOOST_PP_REPEAT_2_255(m,d) BOOST_PP_REPEAT_2_254(m, d) m(3, 254, d)
#define BOOST_PP_REPEAT_2_256(m,d) BOOST_PP_REPEAT_2_255(m, d) m(3, 255, d)
#define BOOST_PP_REPEAT_3_0(m,d)
#define BOOST_PP_REPEAT_3_1(m,d) m(4, 0, d)
#define BOOST_PP_REPEAT_3_2(m,d) BOOST_PP_REPEAT_3_1(m, d) m(4, 1, d)
#define BOOST_PP_REPEAT_3_3(m,d) BOOST_PP_REPEAT_3_2(m, d) m(4, 2, d)
#define BOOST_PP_REPEAT_3_4(m,d) BOOST_PP_REPEAT_3_3(m, d) m(4, 3, d)
#define BOOST_PP_REPEAT_3_5(m,d) BOOST_PP_REPEAT_3_4(m, d) m(4, 4, d)
#define BOOST_PP_REPEAT_3_6(m,d) BOOST_PP_REPEAT_3_5(m, d) m(4, 5, d)
#define BOOST_PP_REPEAT_3_7(m,d) BOOST_PP_REPEAT_3_6(m, d) m(4, 6, d)
#define BOOST_PP_REPEAT_3_8(m,d) BOOST_PP_REPEAT_3_7(m, d) m(4, 7, d)
#define BOOST_PP_REPEAT_3_9(m,d) BOOST_PP_REPEAT_3_8(m, d) m(4, 8, d)
#define BOOST_PP_REPEAT_3_10(m,d) BOOST_PP_REPEAT_3_9(m, d) m(4, 9, d)
#define BOOST_PP_REPEAT_3_11(m,d) BOOST_PP_REPEAT_3_10(m, d) m(4, 10, d)
#define BOOST_PP_REPEAT_3_12(m,d) BOOST_PP_REPEAT_3_11(m, d) m(4, 11, d)
#define BOOST_PP_REPEAT_3_13(m,d) BOOST_PP_REPEAT_3_12(m, d) m(4, 12, d)
#define BOOST_PP_REPEAT_3_14(m,d) BOOST_PP_REPEAT_3_13(m, d) m(4, 13, d)
#define BOOST_PP_REPEAT_3_15(m,d) BOOST_PP_REPEAT_3_14(m, d) m(4, 14, d)
#define BOOST_PP_REPEAT_3_16(m,d) BOOST_PP_REPEAT_3_15(m, d) m(4, 15, d)
#define BOOST_PP_REPEAT_3_17(m,d) BOOST_PP_REPEAT_3_16(m, d) m(4, 16, d)
#define BOOST_PP_REPEAT_3_18(m,d) BOOST_PP_REPEAT_3_17(m, d) m(4, 17, d)
#define BOOST_PP_REPEAT_3_19(m,d) BOOST_PP_REPEAT_3_18(m, d) m(4, 18, d)
#define BOOST_PP_REPEAT_3_20(m,d) BOOST_PP_REPEAT_3_19(m, d) m(4, 19, d)
#define BOOST_PP_REPEAT_3_21(m,d) BOOST_PP_REPEAT_3_20(m, d) m(4, 20, d)
#define BOOST_PP_REPEAT_3_22(m,d) BOOST_PP_REPEAT_3_21(m, d) m(4, 21, d)
#define BOOST_PP_REPEAT_3_23(m,d) BOOST_PP_REPEAT_3_22(m, d) m(4, 22, d)
#define BOOST_PP_REPEAT_3_24(m,d) BOOST_PP_REPEAT_3_23(m, d) m(4, 23, d)
#define BOOST_PP_REPEAT_3_25(m,d) BOOST_PP_REPEAT_3_24(m, d) m(4, 24, d)
#define BOOST_PP_REPEAT_3_26(m,d) BOOST_PP_REPEAT_3_25(m, d) m(4, 25, d)
#define BOOST_PP_REPEAT_3_27(m,d) BOOST_PP_REPEAT_3_26(m, d) m(4, 26, d)
#define BOOST_PP_REPEAT_3_28(m,d) BOOST_PP_REPEAT_3_27(m, d) m(4, 27, d)
#define BOOST_PP_REPEAT_3_29(m,d) BOOST_PP_REPEAT_3_28(m, d) m(4, 28, d)
#define BOOST_PP_REPEAT_3_30(m,d) BOOST_PP_REPEAT_3_29(m, d) m(4, 29, d)
#define BOOST_PP_REPEAT_3_31(m,d) BOOST_PP_REPEAT_3_30(m, d) m(4, 30, d)
#define BOOST_PP_REPEAT_3_32(m,d) BOOST_PP_REPEAT_3_31(m, d) m(4, 31, d)
#define BOOST_PP_REPEAT_3_33(m,d) BOOST_PP_REPEAT_3_32(m, d) m(4, 32, d)
#define BOOST_PP_REPEAT_3_34(m,d) BOOST_PP_REPEAT_3_33(m, d) m(4, 33, d)
#define BOOST_PP_REPEAT_3_35(m,d) BOOST_PP_REPEAT_3_34(m, d) m(4, 34, d)
#define BOOST_PP_REPEAT_3_36(m,d) BOOST_PP_REPEAT_3_35(m, d) m(4, 35, d)
#define BOOST_PP_REPEAT_3_37(m,d) BOOST_PP_REPEAT_3_36(m, d) m(4, 36, d)
#define BOOST_PP_REPEAT_3_38(m,d) BOOST_PP_REPEAT_3_37(m, d) m(4, 37, d)
#define BOOST_PP_REPEAT_3_39(m,d) BOOST_PP_REPEAT_3_38(m, d) m(4, 38, d)
#define BOOST_PP_REPEAT_3_40(m,d) BOOST_PP_REPEAT_3_39(m, d) m(4, 39, d)
#define BOOST_PP_REPEAT_3_41(m,d) BOOST_PP_REPEAT_3_40(m, d) m(4, 40, d)
#define BOOST_PP_REPEAT_3_42(m,d) BOOST_PP_REPEAT_3_41(m, d) m(4, 41, d)
#define BOOST_PP_REPEAT_3_43(m,d) BOOST_PP_REPEAT_3_42(m, d) m(4, 42, d)
#define BOOST_PP_REPEAT_3_44(m,d) BOOST_PP_REPEAT_3_43(m, d) m(4, 43, d)
#define BOOST_PP_REPEAT_3_45(m,d) BOOST_PP_REPEAT_3_44(m, d) m(4, 44, d)
#define BOOST_PP_REPEAT_3_46(m,d) BOOST_PP_REPEAT_3_45(m, d) m(4, 45, d)
#define BOOST_PP_REPEAT_3_47(m,d) BOOST_PP_REPEAT_3_46(m, d) m(4, 46, d)
#define BOOST_PP_REPEAT_3_48(m,d) BOOST_PP_REPEAT_3_47(m, d) m(4, 47, d)
#define BOOST_PP_REPEAT_3_49(m,d) BOOST_PP_REPEAT_3_48(m, d) m(4, 48, d)
#define BOOST_PP_REPEAT_3_50(m,d) BOOST_PP_REPEAT_3_49(m, d) m(4, 49, d)
#define BOOST_PP_REPEAT_3_51(m,d) BOOST_PP_REPEAT_3_50(m, d) m(4, 50, d)
#define BOOST_PP_REPEAT_3_52(m,d) BOOST_PP_REPEAT_3_51(m, d) m(4, 51, d)
#define BOOST_PP_REPEAT_3_53(m,d) BOOST_PP_REPEAT_3_52(m, d) m(4, 52, d)
#define BOOST_PP_REPEAT_3_54(m,d) BOOST_PP_REPEAT_3_53(m, d) m(4, 53, d)
#define BOOST_PP_REPEAT_3_55(m,d) BOOST_PP_REPEAT_3_54(m, d) m(4, 54, d)
#define BOOST_PP_REPEAT_3_56(m,d) BOOST_PP_REPEAT_3_55(m, d) m(4, 55, d)
#define BOOST_PP_REPEAT_3_57(m,d) BOOST_PP_REPEAT_3_56(m, d) m(4, 56, d)
#define BOOST_PP_REPEAT_3_58(m,d) BOOST_PP_REPEAT_3_57(m, d) m(4, 57, d)
#define BOOST_PP_REPEAT_3_59(m,d) BOOST_PP_REPEAT_3_58(m, d) m(4, 58, d)
#define BOOST_PP_REPEAT_3_60(m,d) BOOST_PP_REPEAT_3_59(m, d) m(4, 59, d)
#define BOOST_PP_REPEAT_3_61(m,d) BOOST_PP_REPEAT_3_60(m, d) m(4, 60, d)
#define BOOST_PP_REPEAT_3_62(m,d) BOOST_PP_REPEAT_3_61(m, d) m(4, 61, d)
#define BOOST_PP_REPEAT_3_63(m,d) BOOST_PP_REPEAT_3_62(m, d) m(4, 62, d)
#define BOOST_PP_REPEAT_3_64(m,d) BOOST_PP_REPEAT_3_63(m, d) m(4, 63, d)
#define BOOST_PP_REPEAT_3_65(m,d) BOOST_PP_REPEAT_3_64(m, d) m(4, 64, d)
#define BOOST_PP_REPEAT_3_66(m,d) BOOST_PP_REPEAT_3_65(m, d) m(4, 65, d)
#define BOOST_PP_REPEAT_3_67(m,d) BOOST_PP_REPEAT_3_66(m, d) m(4, 66, d)
#define BOOST_PP_REPEAT_3_68(m,d) BOOST_PP_REPEAT_3_67(m, d) m(4, 67, d)
#define BOOST_PP_REPEAT_3_69(m,d) BOOST_PP_REPEAT_3_68(m, d) m(4, 68, d)
#define BOOST_PP_REPEAT_3_70(m,d) BOOST_PP_REPEAT_3_69(m, d) m(4, 69, d)
#define BOOST_PP_REPEAT_3_71(m,d) BOOST_PP_REPEAT_3_70(m, d) m(4, 70, d)
#define BOOST_PP_REPEAT_3_72(m,d) BOOST_PP_REPEAT_3_71(m, d) m(4, 71, d)
#define BOOST_PP_REPEAT_3_73(m,d) BOOST_PP_REPEAT_3_72(m, d) m(4, 72, d)
#define BOOST_PP_REPEAT_3_74(m,d) BOOST_PP_REPEAT_3_73(m, d) m(4, 73, d)
#define BOOST_PP_REPEAT_3_75(m,d) BOOST_PP_REPEAT_3_74(m, d) m(4, 74, d)
#define BOOST_PP_REPEAT_3_76(m,d) BOOST_PP_REPEAT_3_75(m, d) m(4, 75, d)
#define BOOST_PP_REPEAT_3_77(m,d) BOOST_PP_REPEAT_3_76(m, d) m(4, 76, d)
#define BOOST_PP_REPEAT_3_78(m,d) BOOST_PP_REPEAT_3_77(m, d) m(4, 77, d)
#define BOOST_PP_REPEAT_3_79(m,d) BOOST_PP_REPEAT_3_78(m, d) m(4, 78, d)
#define BOOST_PP_REPEAT_3_80(m,d) BOOST_PP_REPEAT_3_79(m, d) m(4, 79, d)
#define BOOST_PP_REPEAT_3_81(m,d) BOOST_PP_REPEAT_3_80(m, d) m(4, 80, d)
#define BOOST_PP_REPEAT_3_82(m,d) BOOST_PP_REPEAT_3_81(m, d) m(4, 81, d)
#define BOOST_PP_REPEAT_3_83(m,d) BOOST_PP_REPEAT_3_82(m, d) m(4, 82, d)
#define BOOST_PP_REPEAT_3_84(m,d) BOOST_PP_REPEAT_3_83(m, d) m(4, 83, d)
#define BOOST_PP_REPEAT_3_85(m,d) BOOST_PP_REPEAT_3_84(m, d) m(4, 84, d)
#define BOOST_PP_REPEAT_3_86(m,d) BOOST_PP_REPEAT_3_85(m, d) m(4, 85, d)
#define BOOST_PP_REPEAT_3_87(m,d) BOOST_PP_REPEAT_3_86(m, d) m(4, 86, d)
#define BOOST_PP_REPEAT_3_88(m,d) BOOST_PP_REPEAT_3_87(m, d) m(4, 87, d)
#define BOOST_PP_REPEAT_3_89(m,d) BOOST_PP_REPEAT_3_88(m, d) m(4, 88, d)
#define BOOST_PP_REPEAT_3_90(m,d) BOOST_PP_REPEAT_3_89(m, d) m(4, 89, d)
#define BOOST_PP_REPEAT_3_91(m,d) BOOST_PP_REPEAT_3_90(m, d) m(4, 90, d)
#define BOOST_PP_REPEAT_3_92(m,d) BOOST_PP_REPEAT_3_91(m, d) m(4, 91, d)
#define BOOST_PP_REPEAT_3_93(m,d) BOOST_PP_REPEAT_3_92(m, d) m(4, 92, d)
#define BOOST_PP_REPEAT_3_94(m,d) BOOST_PP_REPEAT_3_93(m, d) m(4, 93, d)
#define BOOST_PP_REPEAT_3_95(m,d) BOOST_PP_REPEAT_3_94(m, d) m(4, 94, d)
#define BOOST_PP_REPEAT_3_96(m,d) BOOST_PP_REPEAT_3_95(m, d) m(4, 95, d)
#define BOOST_PP_REPEAT_3_97(m,d) BOOST_PP_REPEAT_3_96(m, d) m(4, 96, d)
#define BOOST_PP_REPEAT_3_98(m,d) BOOST_PP_REPEAT_3_97(m, d) m(4, 97, d)
#define BOOST_PP_REPEAT_3_99(m,d) BOOST_PP_REPEAT_3_98(m, d) m(4, 98, d)
#define BOOST_PP_REPEAT_3_100(m,d) BOOST_PP_REPEAT_3_99(m, d) m(4, 99, d)
#define BOOST_PP_REPEAT_3_101(m,d) BOOST_PP_REPEAT_3_100(m, d) m(4, 100, d)
#define BOOST_PP_REPEAT_3_102(m,d) BOOST_PP_REPEAT_3_101(m, d) m(4, 101, d)
#define BOOST_PP_REPEAT_3_103(m,d) BOOST_PP_REPEAT_3_102(m, d) m(4, 102, d)
#define BOOST_PP_REPEAT_3_104(m,d) BOOST_PP_REPEAT_3_103(m, d) m(4, 103, d)
#define BOOST_PP_REPEAT_3_105(m,d) BOOST_PP_REPEAT_3_104(m, d) m(4, 104, d)
#define BOOST_PP_REPEAT_3_106(m,d) BOOST_PP_REPEAT_3_105(m, d) m(4, 105, d)
#define BOOST_PP_REPEAT_3_107(m,d) BOOST_PP_REPEAT_3_106(m, d) m(4, 106, d)
#define BOOST_PP_REPEAT_3_108(m,d) BOOST_PP_REPEAT_3_107(m, d) m(4, 107, d)
#define BOOST_PP_REPEAT_3_109(m,d) BOOST_PP_REPEAT_3_108(m, d) m(4, 108, d)
#define BOOST_PP_REPEAT_3_110(m,d) BOOST_PP_REPEAT_3_109(m, d) m(4, 109, d)
#define BOOST_PP_REPEAT_3_111(m,d) BOOST_PP_REPEAT_3_110(m, d) m(4, 110, d)
#define BOOST_PP_REPEAT_3_112(m,d) BOOST_PP_REPEAT_3_111(m, d) m(4, 111, d)
#define BOOST_PP_REPEAT_3_113(m,d) BOOST_PP_REPEAT_3_112(m, d) m(4, 112, d)
#define BOOST_PP_REPEAT_3_114(m,d) BOOST_PP_REPEAT_3_113(m, d) m(4, 113, d)
#define BOOST_PP_REPEAT_3_115(m,d) BOOST_PP_REPEAT_3_114(m, d) m(4, 114, d)
#define BOOST_PP_REPEAT_3_116(m,d) BOOST_PP_REPEAT_3_115(m, d) m(4, 115, d)
#define BOOST_PP_REPEAT_3_117(m,d) BOOST_PP_REPEAT_3_116(m, d) m(4, 116, d)
#define BOOST_PP_REPEAT_3_118(m,d) BOOST_PP_REPEAT_3_117(m, d) m(4, 117, d)
#define BOOST_PP_REPEAT_3_119(m,d) BOOST_PP_REPEAT_3_118(m, d) m(4, 118, d)
#define BOOST_PP_REPEAT_3_120(m,d) BOOST_PP_REPEAT_3_119(m, d) m(4, 119, d)
#define BOOST_PP_REPEAT_3_121(m,d) BOOST_PP_REPEAT_3_120(m, d) m(4, 120, d)
#define BOOST_PP_REPEAT_3_122(m,d) BOOST_PP_REPEAT_3_121(m, d) m(4, 121, d)
#define BOOST_PP_REPEAT_3_123(m,d) BOOST_PP_REPEAT_3_122(m, d) m(4, 122, d)
#define BOOST_PP_REPEAT_3_124(m,d) BOOST_PP_REPEAT_3_123(m, d) m(4, 123, d)
#define BOOST_PP_REPEAT_3_125(m,d) BOOST_PP_REPEAT_3_124(m, d) m(4, 124, d)
#define BOOST_PP_REPEAT_3_126(m,d) BOOST_PP_REPEAT_3_125(m, d) m(4, 125, d)
#define BOOST_PP_REPEAT_3_127(m,d) BOOST_PP_REPEAT_3_126(m, d) m(4, 126, d)
#define BOOST_PP_REPEAT_3_128(m,d) BOOST_PP_REPEAT_3_127(m, d) m(4, 127, d)
#define BOOST_PP_REPEAT_3_129(m,d) BOOST_PP_REPEAT_3_128(m, d) m(4, 128, d)
#define BOOST_PP_REPEAT_3_130(m,d) BOOST_PP_REPEAT_3_129(m, d) m(4, 129, d)
#define BOOST_PP_REPEAT_3_131(m,d) BOOST_PP_REPEAT_3_130(m, d) m(4, 130, d)
#define BOOST_PP_REPEAT_3_132(m,d) BOOST_PP_REPEAT_3_131(m, d) m(4, 131, d)
#define BOOST_PP_REPEAT_3_133(m,d) BOOST_PP_REPEAT_3_132(m, d) m(4, 132, d)
#define BOOST_PP_REPEAT_3_134(m,d) BOOST_PP_REPEAT_3_133(m, d) m(4, 133, d)
#define BOOST_PP_REPEAT_3_135(m,d) BOOST_PP_REPEAT_3_134(m, d) m(4, 134, d)
#define BOOST_PP_REPEAT_3_136(m,d) BOOST_PP_REPEAT_3_135(m, d) m(4, 135, d)
#define BOOST_PP_REPEAT_3_137(m,d) BOOST_PP_REPEAT_3_136(m, d) m(4, 136, d)
#define BOOST_PP_REPEAT_3_138(m,d) BOOST_PP_REPEAT_3_137(m, d) m(4, 137, d)
#define BOOST_PP_REPEAT_3_139(m,d) BOOST_PP_REPEAT_3_138(m, d) m(4, 138, d)
#define BOOST_PP_REPEAT_3_140(m,d) BOOST_PP_REPEAT_3_139(m, d) m(4, 139, d)
#define BOOST_PP_REPEAT_3_141(m,d) BOOST_PP_REPEAT_3_140(m, d) m(4, 140, d)
#define BOOST_PP_REPEAT_3_142(m,d) BOOST_PP_REPEAT_3_141(m, d) m(4, 141, d)
#define BOOST_PP_REPEAT_3_143(m,d) BOOST_PP_REPEAT_3_142(m, d) m(4, 142, d)
#define BOOST_PP_REPEAT_3_144(m,d) BOOST_PP_REPEAT_3_143(m, d) m(4, 143, d)
#define BOOST_PP_REPEAT_3_145(m,d) BOOST_PP_REPEAT_3_144(m, d) m(4, 144, d)
#define BOOST_PP_REPEAT_3_146(m,d) BOOST_PP_REPEAT_3_145(m, d) m(4, 145, d)
#define BOOST_PP_REPEAT_3_147(m,d) BOOST_PP_REPEAT_3_146(m, d) m(4, 146, d)
#define BOOST_PP_REPEAT_3_148(m,d) BOOST_PP_REPEAT_3_147(m, d) m(4, 147, d)
#define BOOST_PP_REPEAT_3_149(m,d) BOOST_PP_REPEAT_3_148(m, d) m(4, 148, d)
#define BOOST_PP_REPEAT_3_150(m,d) BOOST_PP_REPEAT_3_149(m, d) m(4, 149, d)
#define BOOST_PP_REPEAT_3_151(m,d) BOOST_PP_REPEAT_3_150(m, d) m(4, 150, d)
#define BOOST_PP_REPEAT_3_152(m,d) BOOST_PP_REPEAT_3_151(m, d) m(4, 151, d)
#define BOOST_PP_REPEAT_3_153(m,d) BOOST_PP_REPEAT_3_152(m, d) m(4, 152, d)
#define BOOST_PP_REPEAT_3_154(m,d) BOOST_PP_REPEAT_3_153(m, d) m(4, 153, d)
#define BOOST_PP_REPEAT_3_155(m,d) BOOST_PP_REPEAT_3_154(m, d) m(4, 154, d)
#define BOOST_PP_REPEAT_3_156(m,d) BOOST_PP_REPEAT_3_155(m, d) m(4, 155, d)
#define BOOST_PP_REPEAT_3_157(m,d) BOOST_PP_REPEAT_3_156(m, d) m(4, 156, d)
#define BOOST_PP_REPEAT_3_158(m,d) BOOST_PP_REPEAT_3_157(m, d) m(4, 157, d)
#define BOOST_PP_REPEAT_3_159(m,d) BOOST_PP_REPEAT_3_158(m, d) m(4, 158, d)
#define BOOST_PP_REPEAT_3_160(m,d) BOOST_PP_REPEAT_3_159(m, d) m(4, 159, d)
#define BOOST_PP_REPEAT_3_161(m,d) BOOST_PP_REPEAT_3_160(m, d) m(4, 160, d)
#define BOOST_PP_REPEAT_3_162(m,d) BOOST_PP_REPEAT_3_161(m, d) m(4, 161, d)
#define BOOST_PP_REPEAT_3_163(m,d) BOOST_PP_REPEAT_3_162(m, d) m(4, 162, d)
#define BOOST_PP_REPEAT_3_164(m,d) BOOST_PP_REPEAT_3_163(m, d) m(4, 163, d)
#define BOOST_PP_REPEAT_3_165(m,d) BOOST_PP_REPEAT_3_164(m, d) m(4, 164, d)
#define BOOST_PP_REPEAT_3_166(m,d) BOOST_PP_REPEAT_3_165(m, d) m(4, 165, d)
#define BOOST_PP_REPEAT_3_167(m,d) BOOST_PP_REPEAT_3_166(m, d) m(4, 166, d)
#define BOOST_PP_REPEAT_3_168(m,d) BOOST_PP_REPEAT_3_167(m, d) m(4, 167, d)
#define BOOST_PP_REPEAT_3_169(m,d) BOOST_PP_REPEAT_3_168(m, d) m(4, 168, d)
#define BOOST_PP_REPEAT_3_170(m,d) BOOST_PP_REPEAT_3_169(m, d) m(4, 169, d)
#define BOOST_PP_REPEAT_3_171(m,d) BOOST_PP_REPEAT_3_170(m, d) m(4, 170, d)
#define BOOST_PP_REPEAT_3_172(m,d) BOOST_PP_REPEAT_3_171(m, d) m(4, 171, d)
#define BOOST_PP_REPEAT_3_173(m,d) BOOST_PP_REPEAT_3_172(m, d) m(4, 172, d)
#define BOOST_PP_REPEAT_3_174(m,d) BOOST_PP_REPEAT_3_173(m, d) m(4, 173, d)
#define BOOST_PP_REPEAT_3_175(m,d) BOOST_PP_REPEAT_3_174(m, d) m(4, 174, d)
#define BOOST_PP_REPEAT_3_176(m,d) BOOST_PP_REPEAT_3_175(m, d) m(4, 175, d)
#define BOOST_PP_REPEAT_3_177(m,d) BOOST_PP_REPEAT_3_176(m, d) m(4, 176, d)
#define BOOST_PP_REPEAT_3_178(m,d) BOOST_PP_REPEAT_3_177(m, d) m(4, 177, d)
#define BOOST_PP_REPEAT_3_179(m,d) BOOST_PP_REPEAT_3_178(m, d) m(4, 178, d)
#define BOOST_PP_REPEAT_3_180(m,d) BOOST_PP_REPEAT_3_179(m, d) m(4, 179, d)
#define BOOST_PP_REPEAT_3_181(m,d) BOOST_PP_REPEAT_3_180(m, d) m(4, 180, d)
#define BOOST_PP_REPEAT_3_182(m,d) BOOST_PP_REPEAT_3_181(m, d) m(4, 181, d)
#define BOOST_PP_REPEAT_3_183(m,d) BOOST_PP_REPEAT_3_182(m, d) m(4, 182, d)
#define BOOST_PP_REPEAT_3_184(m,d) BOOST_PP_REPEAT_3_183(m, d) m(4, 183, d)
#define BOOST_PP_REPEAT_3_185(m,d) BOOST_PP_REPEAT_3_184(m, d) m(4, 184, d)
#define BOOST_PP_REPEAT_3_186(m,d) BOOST_PP_REPEAT_3_185(m, d) m(4, 185, d)
#define BOOST_PP_REPEAT_3_187(m,d) BOOST_PP_REPEAT_3_186(m, d) m(4, 186, d)
#define BOOST_PP_REPEAT_3_188(m,d) BOOST_PP_REPEAT_3_187(m, d) m(4, 187, d)
#define BOOST_PP_REPEAT_3_189(m,d) BOOST_PP_REPEAT_3_188(m, d) m(4, 188, d)
#define BOOST_PP_REPEAT_3_190(m,d) BOOST_PP_REPEAT_3_189(m, d) m(4, 189, d)
#define BOOST_PP_REPEAT_3_191(m,d) BOOST_PP_REPEAT_3_190(m, d) m(4, 190, d)
#define BOOST_PP_REPEAT_3_192(m,d) BOOST_PP_REPEAT_3_191(m, d) m(4, 191, d)
#define BOOST_PP_REPEAT_3_193(m,d) BOOST_PP_REPEAT_3_192(m, d) m(4, 192, d)
#define BOOST_PP_REPEAT_3_194(m,d) BOOST_PP_REPEAT_3_193(m, d) m(4, 193, d)
#define BOOST_PP_REPEAT_3_195(m,d) BOOST_PP_REPEAT_3_194(m, d) m(4, 194, d)
#define BOOST_PP_REPEAT_3_196(m,d) BOOST_PP_REPEAT_3_195(m, d) m(4, 195, d)
#define BOOST_PP_REPEAT_3_197(m,d) BOOST_PP_REPEAT_3_196(m, d) m(4, 196, d)
#define BOOST_PP_REPEAT_3_198(m,d) BOOST_PP_REPEAT_3_197(m, d) m(4, 197, d)
#define BOOST_PP_REPEAT_3_199(m,d) BOOST_PP_REPEAT_3_198(m, d) m(4, 198, d)
#define BOOST_PP_REPEAT_3_200(m,d) BOOST_PP_REPEAT_3_199(m, d) m(4, 199, d)
#define BOOST_PP_REPEAT_3_201(m,d) BOOST_PP_REPEAT_3_200(m, d) m(4, 200, d)
#define BOOST_PP_REPEAT_3_202(m,d) BOOST_PP_REPEAT_3_201(m, d) m(4, 201, d)
#define BOOST_PP_REPEAT_3_203(m,d) BOOST_PP_REPEAT_3_202(m, d) m(4, 202, d)
#define BOOST_PP_REPEAT_3_204(m,d) BOOST_PP_REPEAT_3_203(m, d) m(4, 203, d)
#define BOOST_PP_REPEAT_3_205(m,d) BOOST_PP_REPEAT_3_204(m, d) m(4, 204, d)
#define BOOST_PP_REPEAT_3_206(m,d) BOOST_PP_REPEAT_3_205(m, d) m(4, 205, d)
#define BOOST_PP_REPEAT_3_207(m,d) BOOST_PP_REPEAT_3_206(m, d) m(4, 206, d)
#define BOOST_PP_REPEAT_3_208(m,d) BOOST_PP_REPEAT_3_207(m, d) m(4, 207, d)
#define BOOST_PP_REPEAT_3_209(m,d) BOOST_PP_REPEAT_3_208(m, d) m(4, 208, d)
#define BOOST_PP_REPEAT_3_210(m,d) BOOST_PP_REPEAT_3_209(m, d) m(4, 209, d)
#define BOOST_PP_REPEAT_3_211(m,d) BOOST_PP_REPEAT_3_210(m, d) m(4, 210, d)
#define BOOST_PP_REPEAT_3_212(m,d) BOOST_PP_REPEAT_3_211(m, d) m(4, 211, d)
#define BOOST_PP_REPEAT_3_213(m,d) BOOST_PP_REPEAT_3_212(m, d) m(4, 212, d)
#define BOOST_PP_REPEAT_3_214(m,d) BOOST_PP_REPEAT_3_213(m, d) m(4, 213, d)
#define BOOST_PP_REPEAT_3_215(m,d) BOOST_PP_REPEAT_3_214(m, d) m(4, 214, d)
#define BOOST_PP_REPEAT_3_216(m,d) BOOST_PP_REPEAT_3_215(m, d) m(4, 215, d)
#define BOOST_PP_REPEAT_3_217(m,d) BOOST_PP_REPEAT_3_216(m, d) m(4, 216, d)
#define BOOST_PP_REPEAT_3_218(m,d) BOOST_PP_REPEAT_3_217(m, d) m(4, 217, d)
#define BOOST_PP_REPEAT_3_219(m,d) BOOST_PP_REPEAT_3_218(m, d) m(4, 218, d)
#define BOOST_PP_REPEAT_3_220(m,d) BOOST_PP_REPEAT_3_219(m, d) m(4, 219, d)
#define BOOST_PP_REPEAT_3_221(m,d) BOOST_PP_REPEAT_3_220(m, d) m(4, 220, d)
#define BOOST_PP_REPEAT_3_222(m,d) BOOST_PP_REPEAT_3_221(m, d) m(4, 221, d)
#define BOOST_PP_REPEAT_3_223(m,d) BOOST_PP_REPEAT_3_222(m, d) m(4, 222, d)
#define BOOST_PP_REPEAT_3_224(m,d) BOOST_PP_REPEAT_3_223(m, d) m(4, 223, d)
#define BOOST_PP_REPEAT_3_225(m,d) BOOST_PP_REPEAT_3_224(m, d) m(4, 224, d)
#define BOOST_PP_REPEAT_3_226(m,d) BOOST_PP_REPEAT_3_225(m, d) m(4, 225, d)
#define BOOST_PP_REPEAT_3_227(m,d) BOOST_PP_REPEAT_3_226(m, d) m(4, 226, d)
#define BOOST_PP_REPEAT_3_228(m,d) BOOST_PP_REPEAT_3_227(m, d) m(4, 227, d)
#define BOOST_PP_REPEAT_3_229(m,d) BOOST_PP_REPEAT_3_228(m, d) m(4, 228, d)
#define BOOST_PP_REPEAT_3_230(m,d) BOOST_PP_REPEAT_3_229(m, d) m(4, 229, d)
#define BOOST_PP_REPEAT_3_231(m,d) BOOST_PP_REPEAT_3_230(m, d) m(4, 230, d)
#define BOOST_PP_REPEAT_3_232(m,d) BOOST_PP_REPEAT_3_231(m, d) m(4, 231, d)
#define BOOST_PP_REPEAT_3_233(m,d) BOOST_PP_REPEAT_3_232(m, d) m(4, 232, d)
#define BOOST_PP_REPEAT_3_234(m,d) BOOST_PP_REPEAT_3_233(m, d) m(4, 233, d)
#define BOOST_PP_REPEAT_3_235(m,d) BOOST_PP_REPEAT_3_234(m, d) m(4, 234, d)
#define BOOST_PP_REPEAT_3_236(m,d) BOOST_PP_REPEAT_3_235(m, d) m(4, 235, d)
#define BOOST_PP_REPEAT_3_237(m,d) BOOST_PP_REPEAT_3_236(m, d) m(4, 236, d)
#define BOOST_PP_REPEAT_3_238(m,d) BOOST_PP_REPEAT_3_237(m, d) m(4, 237, d)
#define BOOST_PP_REPEAT_3_239(m,d) BOOST_PP_REPEAT_3_238(m, d) m(4, 238, d)
#define BOOST_PP_REPEAT_3_240(m,d) BOOST_PP_REPEAT_3_239(m, d) m(4, 239, d)
#define BOOST_PP_REPEAT_3_241(m,d) BOOST_PP_REPEAT_3_240(m, d) m(4, 240, d)
#define BOOST_PP_REPEAT_3_242(m,d) BOOST_PP_REPEAT_3_241(m, d) m(4, 241, d)
#define BOOST_PP_REPEAT_3_243(m,d) BOOST_PP_REPEAT_3_242(m, d) m(4, 242, d)
#define BOOST_PP_REPEAT_3_244(m,d) BOOST_PP_REPEAT_3_243(m, d) m(4, 243, d)
#define BOOST_PP_REPEAT_3_245(m,d) BOOST_PP_REPEAT_3_244(m, d) m(4, 244, d)
#define BOOST_PP_REPEAT_3_246(m,d) BOOST_PP_REPEAT_3_245(m, d) m(4, 245, d)
#define BOOST_PP_REPEAT_3_247(m,d) BOOST_PP_REPEAT_3_246(m, d) m(4, 246, d)
#define BOOST_PP_REPEAT_3_248(m,d) BOOST_PP_REPEAT_3_247(m, d) m(4, 247, d)
#define BOOST_PP_REPEAT_3_249(m,d) BOOST_PP_REPEAT_3_248(m, d) m(4, 248, d)
#define BOOST_PP_REPEAT_3_250(m,d) BOOST_PP_REPEAT_3_249(m, d) m(4, 249, d)
#define BOOST_PP_REPEAT_3_251(m,d) BOOST_PP_REPEAT_3_250(m, d) m(4, 250, d)
#define BOOST_PP_REPEAT_3_252(m,d) BOOST_PP_REPEAT_3_251(m, d) m(4, 251, d)
#define BOOST_PP_REPEAT_3_253(m,d) BOOST_PP_REPEAT_3_252(m, d) m(4, 252, d)
#define BOOST_PP_REPEAT_3_254(m,d) BOOST_PP_REPEAT_3_253(m, d) m(4, 253, d)
#define BOOST_PP_REPEAT_3_255(m,d) BOOST_PP_REPEAT_3_254(m, d) m(4, 254, d)
#define BOOST_PP_REPEAT_3_256(m,d) BOOST_PP_REPEAT_3_255(m, d) m(4, 255, d)
#define BOOST_PREPROCESSOR_INC_HPP
#define BOOST_PREPROCESSOR_ARITHMETIC_INC_HPP
#define BOOST_PP_INC(x) BOOST_PP_INC_I(x)
#define BOOST_PP_INC_I(x) BOOST_PP_INC_ ## x
#define BOOST_PP_INC_0 1
#define BOOST_PP_INC_1 2
#define BOOST_PP_INC_2 3
#define BOOST_PP_INC_3 4
#define BOOST_PP_INC_4 5
#define BOOST_PP_INC_5 6
#define BOOST_PP_INC_6 7
#define BOOST_PP_INC_7 8
#define BOOST_PP_INC_8 9
#define BOOST_PP_INC_9 10
#define BOOST_PP_INC_10 11
#define BOOST_PP_INC_11 12
#define BOOST_PP_INC_12 13
#define BOOST_PP_INC_13 14
#define BOOST_PP_INC_14 15
#define BOOST_PP_INC_15 16
#define BOOST_PP_INC_16 17
#define BOOST_PP_INC_17 18
#define BOOST_PP_INC_18 19
#define BOOST_PP_INC_19 20
#define BOOST_PP_INC_20 21
#define BOOST_PP_INC_21 22
#define BOOST_PP_INC_22 23
#define BOOST_PP_INC_23 24
#define BOOST_PP_INC_24 25
#define BOOST_PP_INC_25 26
#define BOOST_PP_INC_26 27
#define BOOST_PP_INC_27 28
#define BOOST_PP_INC_28 29
#define BOOST_PP_INC_29 30
#define BOOST_PP_INC_30 31
#define BOOST_PP_INC_31 32
#define BOOST_PP_INC_32 33
#define BOOST_PP_INC_33 34
#define BOOST_PP_INC_34 35
#define BOOST_PP_INC_35 36
#define BOOST_PP_INC_36 37
#define BOOST_PP_INC_37 38
#define BOOST_PP_INC_38 39
#define BOOST_PP_INC_39 40
#define BOOST_PP_INC_40 41
#define BOOST_PP_INC_41 42
#define BOOST_PP_INC_42 43
#define BOOST_PP_INC_43 44
#define BOOST_PP_INC_44 45
#define BOOST_PP_INC_45 46
#define BOOST_PP_INC_46 47
#define BOOST_PP_INC_47 48
#define BOOST_PP_INC_48 49
#define BOOST_PP_INC_49 50
#define BOOST_PP_INC_50 51
#define BOOST_PP_INC_51 52
#define BOOST_PP_INC_52 53
#define BOOST_PP_INC_53 54
#define BOOST_PP_INC_54 55
#define BOOST_PP_INC_55 56
#define BOOST_PP_INC_56 57
#define BOOST_PP_INC_57 58
#define BOOST_PP_INC_58 59
#define BOOST_PP_INC_59 60
#define BOOST_PP_INC_60 61
#define BOOST_PP_INC_61 62
#define BOOST_PP_INC_62 63
#define BOOST_PP_INC_63 64
#define BOOST_PP_INC_64 65
#define BOOST_PP_INC_65 66
#define BOOST_PP_INC_66 67
#define BOOST_PP_INC_67 68
#define BOOST_PP_INC_68 69
#define BOOST_PP_INC_69 70
#define BOOST_PP_INC_70 71
#define BOOST_PP_INC_71 72
#define BOOST_PP_INC_72 73
#define BOOST_PP_INC_73 74
#define BOOST_PP_INC_74 75
#define BOOST_PP_INC_75 76
#define BOOST_PP_INC_76 77
#define BOOST_PP_INC_77 78
#define BOOST_PP_INC_78 79
#define BOOST_PP_INC_79 80
#define BOOST_PP_INC_80 81
#define BOOST_PP_INC_81 82
#define BOOST_PP_INC_82 83
#define BOOST_PP_INC_83 84
#define BOOST_PP_INC_84 85
#define BOOST_PP_INC_85 86
#define BOOST_PP_INC_86 87
#define BOOST_PP_INC_87 88
#define BOOST_PP_INC_88 89
#define BOOST_PP_INC_89 90
#define BOOST_PP_INC_90 91
#define BOOST_PP_INC_91 92
#define BOOST_PP_INC_92 93
#define BOOST_PP_INC_93 94
#define BOOST_PP_INC_94 95
#define BOOST_PP_INC_95 96
#define BOOST_PP_INC_96 97
#define BOOST_PP_INC_97 98
#define BOOST_PP_INC_98 99
#define BOOST_PP_INC_99 100
#define BOOST_PP_INC_100 101
#define BOOST_PP_INC_101 102
#define BOOST_PP_INC_102 103
#define BOOST_PP_INC_103 104
#define BOOST_PP_INC_104 105
#define BOOST_PP_INC_105 106
#define BOOST_PP_INC_106 107
#define BOOST_PP_INC_107 108
#define BOOST_PP_INC_108 109
#define BOOST_PP_INC_109 110
#define BOOST_PP_INC_110 111
#define BOOST_PP_INC_111 112
#define BOOST_PP_INC_112 113
#define BOOST_PP_INC_113 114
#define BOOST_PP_INC_114 115
#define BOOST_PP_INC_115 116
#define BOOST_PP_INC_116 117
#define BOOST_PP_INC_117 118
#define BOOST_PP_INC_118 119
#define BOOST_PP_INC_119 120
#define BOOST_PP_INC_120 121
#define BOOST_PP_INC_121 122
#define BOOST_PP_INC_122 123
#define BOOST_PP_INC_123 124
#define BOOST_PP_INC_124 125
#define BOOST_PP_INC_125 126
#define BOOST_PP_INC_126 127
#define BOOST_PP_INC_127 128
#define BOOST_PP_INC_128 129
#define BOOST_PP_INC_129 130
#define BOOST_PP_INC_130 131
#define BOOST_PP_INC_131 132
#define BOOST_PP_INC_132 133
#define BOOST_PP_INC_133 134
#define BOOST_PP_INC_134 135
#define BOOST_PP_INC_135 136
#define BOOST_PP_INC_136 137
#define BOOST_PP_INC_137 138
#define BOOST_PP_INC_138 139
#define BOOST_PP_INC_139 140
#define BOOST_PP_INC_140 141
#define BOOST_PP_INC_141 142
#define BOOST_PP_INC_142 143
#define BOOST_PP_INC_143 144
#define BOOST_PP_INC_144 145
#define BOOST_PP_INC_145 146
#define BOOST_PP_INC_146 147
#define BOOST_PP_INC_147 148
#define BOOST_PP_INC_148 149
#define BOOST_PP_INC_149 150
#define BOOST_PP_INC_150 151
#define BOOST_PP_INC_151 152
#define BOOST_PP_INC_152 153
#define BOOST_PP_INC_153 154
#define BOOST_PP_INC_154 155
#define BOOST_PP_INC_155 156
#define BOOST_PP_INC_156 157
#define BOOST_PP_INC_157 158
#define BOOST_PP_INC_158 159
#define BOOST_PP_INC_159 160
#define BOOST_PP_INC_160 161
#define BOOST_PP_INC_161 162
#define BOOST_PP_INC_162 163
#define BOOST_PP_INC_163 164
#define BOOST_PP_INC_164 165
#define BOOST_PP_INC_165 166
#define BOOST_PP_INC_166 167
#define BOOST_PP_INC_167 168
#define BOOST_PP_INC_168 169
#define BOOST_PP_INC_169 170
#define BOOST_PP_INC_170 171
#define BOOST_PP_INC_171 172
#define BOOST_PP_INC_172 173
#define BOOST_PP_INC_173 174
#define BOOST_PP_INC_174 175
#define BOOST_PP_INC_175 176
#define BOOST_PP_INC_176 177
#define BOOST_PP_INC_177 178
#define BOOST_PP_INC_178 179
#define BOOST_PP_INC_179 180
#define BOOST_PP_INC_180 181
#define BOOST_PP_INC_181 182
#define BOOST_PP_INC_182 183
#define BOOST_PP_INC_183 184
#define BOOST_PP_INC_184 185
#define BOOST_PP_INC_185 186
#define BOOST_PP_INC_186 187
#define BOOST_PP_INC_187 188
#define BOOST_PP_INC_188 189
#define BOOST_PP_INC_189 190
#define BOOST_PP_INC_190 191
#define BOOST_PP_INC_191 192
#define BOOST_PP_INC_192 193
#define BOOST_PP_INC_193 194
#define BOOST_PP_INC_194 195
#define BOOST_PP_INC_195 196
#define BOOST_PP_INC_196 197
#define BOOST_PP_INC_197 198
#define BOOST_PP_INC_198 199
#define BOOST_PP_INC_199 200
#define BOOST_PP_INC_200 201
#define BOOST_PP_INC_201 202
#define BOOST_PP_INC_202 203
#define BOOST_PP_INC_203 204
#define BOOST_PP_INC_204 205
#define BOOST_PP_INC_205 206
#define BOOST_PP_INC_206 207
#define BOOST_PP_INC_207 208
#define BOOST_PP_INC_208 209
#define BOOST_PP_INC_209 210
#define BOOST_PP_INC_210 211
#define BOOST_PP_INC_211 212
#define BOOST_PP_INC_212 213
#define BOOST_PP_INC_213 214
#define BOOST_PP_INC_214 215
#define BOOST_PP_INC_215 216
#define BOOST_PP_INC_216 217
#define BOOST_PP_INC_217 218
#define BOOST_PP_INC_218 219
#define BOOST_PP_INC_219 220
#define BOOST_PP_INC_220 221
#define BOOST_PP_INC_221 222
#define BOOST_PP_INC_222 223
#define BOOST_PP_INC_223 224
#define BOOST_PP_INC_224 225
#define BOOST_PP_INC_225 226
#define BOOST_PP_INC_226 227
#define BOOST_PP_INC_227 228
#define BOOST_PP_INC_228 229
#define BOOST_PP_INC_229 230
#define BOOST_PP_INC_230 231
#define BOOST_PP_INC_231 232
#define BOOST_PP_INC_232 233
#define BOOST_PP_INC_233 234
#define BOOST_PP_INC_234 235
#define BOOST_PP_INC_235 236
#define BOOST_PP_INC_236 237
#define BOOST_PP_INC_237 238
#define BOOST_PP_INC_238 239
#define BOOST_PP_INC_239 240
#define BOOST_PP_INC_240 241
#define BOOST_PP_INC_241 242
#define BOOST_PP_INC_242 243
#define BOOST_PP_INC_243 244
#define BOOST_PP_INC_244 245
#define BOOST_PP_INC_245 246
#define BOOST_PP_INC_246 247
#define BOOST_PP_INC_247 248
#define BOOST_PP_INC_248 249
#define BOOST_PP_INC_249 250
#define BOOST_PP_INC_250 251
#define BOOST_PP_INC_251 252
#define BOOST_PP_INC_252 253
#define BOOST_PP_INC_253 254
#define BOOST_PP_INC_254 255
#define BOOST_PP_INC_255 256
#define BOOST_PP_INC_256 256
#define BOOST_MPL_PP_AUX_PARAM_FUNC(unused,i,param) BOOST_PP_COMMA_IF(i) BOOST_PP_CAT(param, BOOST_PP_INC(i))
#define BOOST_MPL_PP_PARAMS(n,param) BOOST_PP_REPEAT( n , BOOST_MPL_PP_AUX_PARAM_FUNC , param )
#define BOOST_MPL_AUX_PREPROCESSOR_ENUM_HPP_INCLUDED
#define BOOST_MPL_PP_AUX_ENUM_FUNC(unused,i,param) BOOST_PP_COMMA_IF(i) param
#define BOOST_MPL_PP_ENUM(n,param) BOOST_PP_REPEAT( n , BOOST_MPL_PP_AUX_ENUM_FUNC , param )
#define BOOST_MPL_AUX_PREPROCESSOR_DEF_PARAMS_TAIL_HPP_INCLUDED
#define BOOST_MPL_LIMITS_ARITY_HPP_INCLUDED
#define BOOST_MPL_LIMIT_METAFUNCTION_ARITY 5
#define BOOST_PREPROCESSOR_LOGICAL_AND_HPP
#define BOOST_PREPROCESSOR_LOGICAL_BITAND_HPP
#define BOOST_PP_BITAND(x,y) BOOST_PP_BITAND_I(x, y)
#define BOOST_PP_BITAND_I(x,y) BOOST_PP_BITAND_ ## x ## y
#define BOOST_PP_BITAND_00 0
#define BOOST_PP_BITAND_01 0
#define BOOST_PP_BITAND_10 0
#define BOOST_PP_BITAND_11 1
#define BOOST_PP_AND(p,q) BOOST_PP_BITAND(BOOST_PP_BOOL(p), BOOST_PP_BOOL(q))
#define BOOST_PREPROCESSOR_IDENTITY_HPP
#define BOOST_PREPROCESSOR_FACILITIES_IDENTITY_HPP
#define BOOST_PP_IDENTITY(item) item BOOST_PP_EMPTY
#define BOOST_PREPROCESSOR_EMPTY_HPP
#define BOOST_PREPROCESSOR_ARITHMETIC_ADD_HPP
#define BOOST_PREPROCESSOR_ARITHMETIC_DEC_HPP
#define BOOST_PP_DEC(x) BOOST_PP_DEC_I(x)
#define BOOST_PP_DEC_I(x) BOOST_PP_DEC_ ## x
#define BOOST_PP_DEC_0 0
#define BOOST_PP_DEC_1 0
#define BOOST_PP_DEC_2 1
#define BOOST_PP_DEC_3 2
#define BOOST_PP_DEC_4 3
#define BOOST_PP_DEC_5 4
#define BOOST_PP_DEC_6 5
#define BOOST_PP_DEC_7 6
#define BOOST_PP_DEC_8 7
#define BOOST_PP_DEC_9 8
#define BOOST_PP_DEC_10 9
#define BOOST_PP_DEC_11 10
#define BOOST_PP_DEC_12 11
#define BOOST_PP_DEC_13 12
#define BOOST_PP_DEC_14 13
#define BOOST_PP_DEC_15 14
#define BOOST_PP_DEC_16 15
#define BOOST_PP_DEC_17 16
#define BOOST_PP_DEC_18 17
#define BOOST_PP_DEC_19 18
#define BOOST_PP_DEC_20 19
#define BOOST_PP_DEC_21 20
#define BOOST_PP_DEC_22 21
#define BOOST_PP_DEC_23 22
#define BOOST_PP_DEC_24 23
#define BOOST_PP_DEC_25 24
#define BOOST_PP_DEC_26 25
#define BOOST_PP_DEC_27 26
#define BOOST_PP_DEC_28 27
#define BOOST_PP_DEC_29 28
#define BOOST_PP_DEC_30 29
#define BOOST_PP_DEC_31 30
#define BOOST_PP_DEC_32 31
#define BOOST_PP_DEC_33 32
#define BOOST_PP_DEC_34 33
#define BOOST_PP_DEC_35 34
#define BOOST_PP_DEC_36 35
#define BOOST_PP_DEC_37 36
#define BOOST_PP_DEC_38 37
#define BOOST_PP_DEC_39 38
#define BOOST_PP_DEC_40 39
#define BOOST_PP_DEC_41 40
#define BOOST_PP_DEC_42 41
#define BOOST_PP_DEC_43 42
#define BOOST_PP_DEC_44 43
#define BOOST_PP_DEC_45 44
#define BOOST_PP_DEC_46 45
#define BOOST_PP_DEC_47 46
#define BOOST_PP_DEC_48 47
#define BOOST_PP_DEC_49 48
#define BOOST_PP_DEC_50 49
#define BOOST_PP_DEC_51 50
#define BOOST_PP_DEC_52 51
#define BOOST_PP_DEC_53 52
#define BOOST_PP_DEC_54 53
#define BOOST_PP_DEC_55 54
#define BOOST_PP_DEC_56 55
#define BOOST_PP_DEC_57 56
#define BOOST_PP_DEC_58 57
#define BOOST_PP_DEC_59 58
#define BOOST_PP_DEC_60 59
#define BOOST_PP_DEC_61 60
#define BOOST_PP_DEC_62 61
#define BOOST_PP_DEC_63 62
#define BOOST_PP_DEC_64 63
#define BOOST_PP_DEC_65 64
#define BOOST_PP_DEC_66 65
#define BOOST_PP_DEC_67 66
#define BOOST_PP_DEC_68 67
#define BOOST_PP_DEC_69 68
#define BOOST_PP_DEC_70 69
#define BOOST_PP_DEC_71 70
#define BOOST_PP_DEC_72 71
#define BOOST_PP_DEC_73 72
#define BOOST_PP_DEC_74 73
#define BOOST_PP_DEC_75 74
#define BOOST_PP_DEC_76 75
#define BOOST_PP_DEC_77 76
#define BOOST_PP_DEC_78 77
#define BOOST_PP_DEC_79 78
#define BOOST_PP_DEC_80 79
#define BOOST_PP_DEC_81 80
#define BOOST_PP_DEC_82 81
#define BOOST_PP_DEC_83 82
#define BOOST_PP_DEC_84 83
#define BOOST_PP_DEC_85 84
#define BOOST_PP_DEC_86 85
#define BOOST_PP_DEC_87 86
#define BOOST_PP_DEC_88 87
#define BOOST_PP_DEC_89 88
#define BOOST_PP_DEC_90 89
#define BOOST_PP_DEC_91 90
#define BOOST_PP_DEC_92 91
#define BOOST_PP_DEC_93 92
#define BOOST_PP_DEC_94 93
#define BOOST_PP_DEC_95 94
#define BOOST_PP_DEC_96 95
#define BOOST_PP_DEC_97 96
#define BOOST_PP_DEC_98 97
#define BOOST_PP_DEC_99 98
#define BOOST_PP_DEC_100 99
#define BOOST_PP_DEC_101 100
#define BOOST_PP_DEC_102 101
#define BOOST_PP_DEC_103 102
#define BOOST_PP_DEC_104 103
#define BOOST_PP_DEC_105 104
#define BOOST_PP_DEC_106 105
#define BOOST_PP_DEC_107 106
#define BOOST_PP_DEC_108 107
#define BOOST_PP_DEC_109 108
#define BOOST_PP_DEC_110 109
#define BOOST_PP_DEC_111 110
#define BOOST_PP_DEC_112 111
#define BOOST_PP_DEC_113 112
#define BOOST_PP_DEC_114 113
#define BOOST_PP_DEC_115 114
#define BOOST_PP_DEC_116 115
#define BOOST_PP_DEC_117 116
#define BOOST_PP_DEC_118 117
#define BOOST_PP_DEC_119 118
#define BOOST_PP_DEC_120 119
#define BOOST_PP_DEC_121 120
#define BOOST_PP_DEC_122 121
#define BOOST_PP_DEC_123 122
#define BOOST_PP_DEC_124 123
#define BOOST_PP_DEC_125 124
#define BOOST_PP_DEC_126 125
#define BOOST_PP_DEC_127 126
#define BOOST_PP_DEC_128 127
#define BOOST_PP_DEC_129 128
#define BOOST_PP_DEC_130 129
#define BOOST_PP_DEC_131 130
#define BOOST_PP_DEC_132 131
#define BOOST_PP_DEC_133 132
#define BOOST_PP_DEC_134 133
#define BOOST_PP_DEC_135 134
#define BOOST_PP_DEC_136 135
#define BOOST_PP_DEC_137 136
#define BOOST_PP_DEC_138 137
#define BOOST_PP_DEC_139 138
#define BOOST_PP_DEC_140 139
#define BOOST_PP_DEC_141 140
#define BOOST_PP_DEC_142 141
#define BOOST_PP_DEC_143 142
#define BOOST_PP_DEC_144 143
#define BOOST_PP_DEC_145 144
#define BOOST_PP_DEC_146 145
#define BOOST_PP_DEC_147 146
#define BOOST_PP_DEC_148 147
#define BOOST_PP_DEC_149 148
#define BOOST_PP_DEC_150 149
#define BOOST_PP_DEC_151 150
#define BOOST_PP_DEC_152 151
#define BOOST_PP_DEC_153 152
#define BOOST_PP_DEC_154 153
#define BOOST_PP_DEC_155 154
#define BOOST_PP_DEC_156 155
#define BOOST_PP_DEC_157 156
#define BOOST_PP_DEC_158 157
#define BOOST_PP_DEC_159 158
#define BOOST_PP_DEC_160 159
#define BOOST_PP_DEC_161 160
#define BOOST_PP_DEC_162 161
#define BOOST_PP_DEC_163 162
#define BOOST_PP_DEC_164 163
#define BOOST_PP_DEC_165 164
#define BOOST_PP_DEC_166 165
#define BOOST_PP_DEC_167 166
#define BOOST_PP_DEC_168 167
#define BOOST_PP_DEC_169 168
#define BOOST_PP_DEC_170 169
#define BOOST_PP_DEC_171 170
#define BOOST_PP_DEC_172 171
#define BOOST_PP_DEC_173 172
#define BOOST_PP_DEC_174 173
#define BOOST_PP_DEC_175 174
#define BOOST_PP_DEC_176 175
#define BOOST_PP_DEC_177 176
#define BOOST_PP_DEC_178 177
#define BOOST_PP_DEC_179 178
#define BOOST_PP_DEC_180 179
#define BOOST_PP_DEC_181 180
#define BOOST_PP_DEC_182 181
#define BOOST_PP_DEC_183 182
#define BOOST_PP_DEC_184 183
#define BOOST_PP_DEC_185 184
#define BOOST_PP_DEC_186 185
#define BOOST_PP_DEC_187 186
#define BOOST_PP_DEC_188 187
#define BOOST_PP_DEC_189 188
#define BOOST_PP_DEC_190 189
#define BOOST_PP_DEC_191 190
#define BOOST_PP_DEC_192 191
#define BOOST_PP_DEC_193 192
#define BOOST_PP_DEC_194 193
#define BOOST_PP_DEC_195 194
#define BOOST_PP_DEC_196 195
#define BOOST_PP_DEC_197 196
#define BOOST_PP_DEC_198 197
#define BOOST_PP_DEC_199 198
#define BOOST_PP_DEC_200 199
#define BOOST_PP_DEC_201 200
#define BOOST_PP_DEC_202 201
#define BOOST_PP_DEC_203 202
#define BOOST_PP_DEC_204 203
#define BOOST_PP_DEC_205 204
#define BOOST_PP_DEC_206 205
#define BOOST_PP_DEC_207 206
#define BOOST_PP_DEC_208 207
#define BOOST_PP_DEC_209 208
#define BOOST_PP_DEC_210 209
#define BOOST_PP_DEC_211 210
#define BOOST_PP_DEC_212 211
#define BOOST_PP_DEC_213 212
#define BOOST_PP_DEC_214 213
#define BOOST_PP_DEC_215 214
#define BOOST_PP_DEC_216 215
#define BOOST_PP_DEC_217 216
#define BOOST_PP_DEC_218 217
#define BOOST_PP_DEC_219 218
#define BOOST_PP_DEC_220 219
#define BOOST_PP_DEC_221 220
#define BOOST_PP_DEC_222 221
#define BOOST_PP_DEC_223 222
#define BOOST_PP_DEC_224 223
#define BOOST_PP_DEC_225 224
#define BOOST_PP_DEC_226 225
#define BOOST_PP_DEC_227 226
#define BOOST_PP_DEC_228 227
#define BOOST_PP_DEC_229 228
#define BOOST_PP_DEC_230 229
#define BOOST_PP_DEC_231 230
#define BOOST_PP_DEC_232 231
#define BOOST_PP_DEC_233 232
#define BOOST_PP_DEC_234 233
#define BOOST_PP_DEC_235 234
#define BOOST_PP_DEC_236 235
#define BOOST_PP_DEC_237 236
#define BOOST_PP_DEC_238 237
#define BOOST_PP_DEC_239 238
#define BOOST_PP_DEC_240 239
#define BOOST_PP_DEC_241 240
#define BOOST_PP_DEC_242 241
#define BOOST_PP_DEC_243 242
#define BOOST_PP_DEC_244 243
#define BOOST_PP_DEC_245 244
#define BOOST_PP_DEC_246 245
#define BOOST_PP_DEC_247 246
#define BOOST_PP_DEC_248 247
#define BOOST_PP_DEC_249 248
#define BOOST_PP_DEC_250 249
#define BOOST_PP_DEC_251 250
#define BOOST_PP_DEC_252 251
#define BOOST_PP_DEC_253 252
#define BOOST_PP_DEC_254 253
#define BOOST_PP_DEC_255 254
#define BOOST_PP_DEC_256 255
#define BOOST_PREPROCESSOR_CONTROL_WHILE_HPP
#define BOOST_PREPROCESSOR_LIST_FOLD_LEFT_HPP
#define BOOST_PP_LIST_FOLD_LEFT BOOST_PP_CAT(BOOST_PP_LIST_FOLD_LEFT_, BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256))
#define BOOST_PP_LIST_FOLD_LEFT_257(o,s,l) BOOST_PP_ERROR(0x0004)
#define BOOST_PP_LIST_FOLD_LEFT_D(d,o,s,l) BOOST_PP_LIST_FOLD_LEFT_ ## d(o, s, l)
#define BOOST_PP_LIST_FOLD_LEFT_2ND BOOST_PP_LIST_FOLD_LEFT
#define BOOST_PP_LIST_FOLD_LEFT_2ND_D BOOST_PP_LIST_FOLD_LEFT_D
#define BOOST_PREPROCESSOR_LIST_DETAIL_FOLD_LEFT_HPP
#define BOOST_PREPROCESSOR_CONTROL_EXPR_IIF_HPP
#define BOOST_PP_EXPR_IIF(bit,expr) BOOST_PP_EXPR_IIF_I(bit, expr)
#define BOOST_PP_EXPR_IIF_I(bit,expr) BOOST_PP_EXPR_IIF_ ## bit(expr)
#define BOOST_PP_EXPR_IIF_0(expr)
#define BOOST_PP_EXPR_IIF_1(expr) expr
#define BOOST_PREPROCESSOR_LIST_ADT_HPP
#define BOOST_PREPROCESSOR_DETAIL_IS_BINARY_HPP
#define BOOST_PREPROCESSOR_DETAIL_CHECK_HPP
#define BOOST_PP_CHECK(x,type) BOOST_PP_CHECK_D(x, type)
#define BOOST_PP_CHECK_D(x,type) BOOST_PP_CHECK_1(BOOST_PP_CAT(BOOST_PP_CHECK_RESULT_, type x))
#define BOOST_PP_CHECK_1(chk) BOOST_PP_CHECK_2(chk)
#define BOOST_PP_CHECK_2(res,_) res
#define BOOST_PP_CHECK_RESULT_1 1, BOOST_PP_NIL
#define BOOST_PP_IS_BINARY(x) BOOST_PP_CHECK(x, BOOST_PP_IS_BINARY_CHECK)
#define BOOST_PP_IS_BINARY_CHECK(a,b) 1
#define BOOST_PP_CHECK_RESULT_BOOST_PP_IS_BINARY_CHECK 0, BOOST_PP_NIL
#define BOOST_PREPROCESSOR_LOGICAL_COMPL_HPP
#define BOOST_PP_COMPL(x) BOOST_PP_COMPL_I(x)
#define BOOST_PP_COMPL_I(x) BOOST_PP_COMPL_ ## x
#define BOOST_PP_COMPL_0 1
#define BOOST_PP_COMPL_1 0
#define BOOST_PP_LIST_CONS(head,tail) (head, tail)
#define BOOST_PP_LIST_NIL BOOST_PP_NIL
#define BOOST_PP_LIST_FIRST(list) BOOST_PP_LIST_FIRST_D(list)
#define BOOST_PP_LIST_FIRST_D(list) BOOST_PP_LIST_FIRST_I list
#define BOOST_PP_LIST_FIRST_I(head,tail) head
#define BOOST_PP_LIST_REST(list) BOOST_PP_LIST_REST_D(list)
#define BOOST_PP_LIST_REST_D(list) BOOST_PP_LIST_REST_I list
#define BOOST_PP_LIST_REST_I(head,tail) tail
#define BOOST_PP_LIST_IS_CONS(list) BOOST_PP_IS_BINARY(list)
#define BOOST_PP_LIST_IS_NIL(list) BOOST_PP_COMPL(BOOST_PP_IS_BINARY(list))
#define BOOST_PP_LIST_FOLD_LEFT_1(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_2, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(2, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_2(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_3, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(3, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_3(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_4, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(4, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_4(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_5, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(5, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_5(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_6, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(6, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_6(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_7, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(7, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_7(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_8, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(8, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_8(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_9, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(9, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_9(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_10, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(10, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_10(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_11, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(11, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_11(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_12, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(12, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_12(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_13, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(13, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_13(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_14, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(14, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_14(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_15, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(15, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_15(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_16, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(16, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_16(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_17, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(17, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_17(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_18, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(18, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_18(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_19, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(19, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_19(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_20, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(20, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_20(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_21, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(21, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_21(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_22, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(22, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_22(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_23, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(23, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_23(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_24, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(24, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_24(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_25, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(25, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_25(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_26, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(26, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_26(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_27, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(27, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_27(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_28, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(28, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_28(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_29, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(29, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_29(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_30, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(30, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_30(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_31, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(31, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_31(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_32, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(32, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_32(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_33, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(33, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_33(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_34, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(34, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_34(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_35, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(35, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_35(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_36, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(36, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_36(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_37, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(37, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_37(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_38, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(38, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_38(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_39, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(39, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_39(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_40, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(40, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_40(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_41, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(41, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_41(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_42, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(42, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_42(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_43, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(43, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_43(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_44, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(44, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_44(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_45, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(45, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_45(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_46, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(46, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_46(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_47, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(47, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_47(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_48, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(48, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_48(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_49, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(49, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_49(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_50, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(50, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_50(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_51, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(51, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_51(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_52, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(52, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_52(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_53, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(53, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_53(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_54, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(54, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_54(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_55, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(55, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_55(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_56, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(56, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_56(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_57, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(57, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_57(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_58, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(58, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_58(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_59, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(59, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_59(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_60, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(60, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_60(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_61, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(61, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_61(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_62, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(62, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_62(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_63, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(63, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_63(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_64, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(64, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_64(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_65, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(65, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_65(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_66, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(66, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_66(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_67, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(67, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_67(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_68, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(68, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_68(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_69, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(69, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_69(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_70, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(70, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_70(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_71, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(71, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_71(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_72, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(72, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_72(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_73, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(73, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_73(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_74, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(74, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_74(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_75, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(75, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_75(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_76, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(76, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_76(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_77, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(77, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_77(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_78, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(78, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_78(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_79, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(79, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_79(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_80, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(80, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_80(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_81, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(81, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_81(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_82, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(82, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_82(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_83, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(83, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_83(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_84, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(84, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_84(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_85, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(85, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_85(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_86, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(86, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_86(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_87, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(87, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_87(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_88, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(88, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_88(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_89, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(89, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_89(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_90, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(90, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_90(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_91, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(91, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_91(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_92, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(92, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_92(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_93, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(93, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_93(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_94, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(94, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_94(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_95, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(95, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_95(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_96, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(96, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_96(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_97, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(97, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_97(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_98, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(98, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_98(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_99, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(99, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_99(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_100, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(100, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_100(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_101, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(101, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_101(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_102, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(102, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_102(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_103, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(103, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_103(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_104, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(104, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_104(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_105, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(105, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_105(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_106, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(106, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_106(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_107, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(107, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_107(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_108, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(108, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_108(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_109, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(109, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_109(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_110, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(110, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_110(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_111, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(111, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_111(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_112, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(112, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_112(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_113, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(113, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_113(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_114, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(114, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_114(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_115, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(115, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_115(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_116, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(116, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_116(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_117, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(117, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_117(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_118, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(118, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_118(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_119, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(119, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_119(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_120, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(120, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_120(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_121, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(121, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_121(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_122, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(122, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_122(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_123, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(123, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_123(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_124, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(124, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_124(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_125, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(125, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_125(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_126, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(126, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_126(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_127, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(127, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_127(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_128, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(128, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_128(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_129, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(129, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_129(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_130, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(130, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_130(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_131, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(131, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_131(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_132, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(132, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_132(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_133, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(133, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_133(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_134, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(134, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_134(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_135, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(135, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_135(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_136, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(136, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_136(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_137, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(137, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_137(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_138, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(138, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_138(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_139, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(139, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_139(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_140, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(140, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_140(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_141, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(141, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_141(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_142, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(142, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_142(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_143, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(143, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_143(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_144, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(144, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_144(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_145, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(145, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_145(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_146, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(146, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_146(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_147, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(147, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_147(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_148, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(148, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_148(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_149, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(149, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_149(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_150, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(150, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_150(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_151, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(151, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_151(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_152, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(152, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_152(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_153, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(153, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_153(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_154, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(154, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_154(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_155, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(155, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_155(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_156, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(156, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_156(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_157, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(157, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_157(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_158, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(158, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_158(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_159, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(159, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_159(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_160, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(160, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_160(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_161, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(161, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_161(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_162, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(162, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_162(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_163, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(163, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_163(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_164, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(164, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_164(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_165, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(165, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_165(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_166, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(166, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_166(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_167, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(167, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_167(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_168, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(168, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_168(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_169, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(169, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_169(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_170, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(170, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_170(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_171, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(171, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_171(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_172, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(172, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_172(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_173, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(173, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_173(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_174, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(174, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_174(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_175, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(175, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_175(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_176, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(176, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_176(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_177, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(177, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_177(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_178, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(178, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_178(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_179, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(179, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_179(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_180, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(180, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_180(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_181, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(181, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_181(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_182, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(182, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_182(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_183, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(183, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_183(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_184, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(184, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_184(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_185, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(185, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_185(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_186, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(186, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_186(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_187, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(187, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_187(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_188, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(188, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_188(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_189, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(189, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_189(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_190, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(190, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_190(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_191, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(191, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_191(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_192, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(192, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_192(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_193, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(193, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_193(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_194, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(194, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_194(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_195, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(195, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_195(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_196, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(196, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_196(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_197, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(197, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_197(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_198, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(198, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_198(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_199, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(199, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_199(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_200, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(200, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_200(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_201, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(201, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_201(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_202, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(202, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_202(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_203, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(203, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_203(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_204, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(204, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_204(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_205, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(205, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_205(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_206, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(206, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_206(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_207, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(207, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_207(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_208, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(208, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_208(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_209, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(209, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_209(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_210, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(210, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_210(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_211, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(211, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_211(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_212, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(212, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_212(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_213, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(213, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_213(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_214, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(214, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_214(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_215, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(215, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_215(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_216, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(216, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_216(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_217, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(217, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_217(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_218, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(218, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_218(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_219, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(219, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_219(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_220, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(220, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_220(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_221, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(221, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_221(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_222, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(222, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_222(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_223, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(223, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_223(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_224, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(224, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_224(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_225, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(225, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_225(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_226, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(226, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_226(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_227, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(227, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_227(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_228, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(228, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_228(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_229, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(229, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_229(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_230, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(230, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_230(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_231, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(231, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_231(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_232, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(232, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_232(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_233, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(233, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_233(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_234, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(234, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_234(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_235, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(235, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_235(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_236, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(236, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_236(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_237, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(237, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_237(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_238, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(238, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_238(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_239, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(239, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_239(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_240, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(240, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_240(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_241, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(241, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_241(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_242, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(242, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_242(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_243, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(243, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_243(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_244, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(244, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_244(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_245, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(245, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_245(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_246, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(246, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_246(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_247, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(247, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_247(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_248, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(248, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_248(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_249, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(249, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_249(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_250, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(250, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_250(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_251, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(251, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_251(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_252, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(252, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_252(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_253, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(253, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_253(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_254, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(254, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_254(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_255, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(255, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_255(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_256, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(256, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_256(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_257, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(257, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_NIL 1
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_1(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_2(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_3(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_4(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_5(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_6(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_7(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_8(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_9(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_10(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_11(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_12(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_13(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_14(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_15(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_16(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_17(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_18(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_19(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_20(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_21(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_22(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_23(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_24(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_25(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_26(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_27(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_28(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_29(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_30(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_31(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_32(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_33(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_34(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_35(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_36(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_37(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_38(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_39(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_40(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_41(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_42(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_43(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_44(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_45(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_46(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_47(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_48(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_49(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_50(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_51(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_52(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_53(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_54(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_55(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_56(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_57(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_58(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_59(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_60(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_61(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_62(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_63(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_64(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_65(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_66(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_67(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_68(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_69(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_70(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_71(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_72(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_73(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_74(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_75(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_76(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_77(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_78(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_79(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_80(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_81(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_82(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_83(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_84(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_85(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_86(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_87(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_88(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_89(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_90(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_91(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_92(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_93(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_94(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_95(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_96(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_97(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_98(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_99(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_100(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_101(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_102(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_103(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_104(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_105(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_106(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_107(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_108(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_109(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_110(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_111(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_112(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_113(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_114(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_115(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_116(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_117(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_118(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_119(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_120(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_121(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_122(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_123(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_124(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_125(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_126(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_127(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_128(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_129(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_130(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_131(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_132(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_133(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_134(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_135(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_136(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_137(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_138(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_139(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_140(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_141(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_142(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_143(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_144(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_145(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_146(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_147(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_148(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_149(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_150(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_151(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_152(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_153(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_154(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_155(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_156(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_157(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_158(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_159(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_160(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_161(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_162(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_163(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_164(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_165(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_166(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_167(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_168(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_169(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_170(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_171(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_172(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_173(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_174(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_175(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_176(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_177(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_178(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_179(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_180(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_181(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_182(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_183(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_184(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_185(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_186(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_187(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_188(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_189(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_190(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_191(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_192(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_193(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_194(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_195(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_196(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_197(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_198(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_199(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_200(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_201(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_202(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_203(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_204(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_205(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_206(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_207(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_208(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_209(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_210(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_211(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_212(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_213(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_214(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_215(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_216(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_217(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_218(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_219(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_220(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_221(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_222(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_223(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_224(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_225(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_226(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_227(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_228(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_229(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_230(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_231(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_232(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_233(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_234(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_235(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_236(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_237(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_238(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_239(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_240(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_241(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_242(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_243(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_244(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_245(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_246(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_247(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_248(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_249(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_250(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_251(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_252(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_253(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_254(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_255(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_256(o,s,l) 0
#define BOOST_PREPROCESSOR_LIST_FOLD_RIGHT_HPP
#define BOOST_PP_LIST_FOLD_RIGHT BOOST_PP_CAT(BOOST_PP_LIST_FOLD_RIGHT_, BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256))
#define BOOST_PP_LIST_FOLD_RIGHT_257(o,s,l) BOOST_PP_ERROR(0x0004)
#define BOOST_PP_LIST_FOLD_RIGHT_D(d,o,s,l) BOOST_PP_LIST_FOLD_RIGHT_ ## d(o, s, l)
#define BOOST_PP_LIST_FOLD_RIGHT_2ND BOOST_PP_LIST_FOLD_RIGHT
#define BOOST_PP_LIST_FOLD_RIGHT_2ND_D BOOST_PP_LIST_FOLD_RIGHT_D
#define BOOST_PREPROCESSOR_LIST_DETAIL_FOLD_RIGHT_HPP
#define BOOST_PREPROCESSOR_LIST_REVERSE_HPP
#define BOOST_PP_LIST_REVERSE(list) BOOST_PP_LIST_FOLD_LEFT(BOOST_PP_LIST_REVERSE_O, BOOST_PP_NIL, list)
#define BOOST_PP_LIST_REVERSE_O(d,s,x) (x, s)
#define BOOST_PP_LIST_REVERSE_D(d,list) BOOST_PP_LIST_FOLD_LEFT_ ## d(BOOST_PP_LIST_REVERSE_O, BOOST_PP_NIL, list)
#define BOOST_PP_LIST_FOLD_RIGHT_1(o,s,l) BOOST_PP_LIST_FOLD_LEFT_1(o, s, BOOST_PP_LIST_REVERSE_D(1, l))
#define BOOST_PP_LIST_FOLD_RIGHT_2(o,s,l) BOOST_PP_LIST_FOLD_LEFT_2(o, s, BOOST_PP_LIST_REVERSE_D(2, l))
#define BOOST_PP_LIST_FOLD_RIGHT_3(o,s,l) BOOST_PP_LIST_FOLD_LEFT_3(o, s, BOOST_PP_LIST_REVERSE_D(3, l))
#define BOOST_PP_LIST_FOLD_RIGHT_4(o,s,l) BOOST_PP_LIST_FOLD_LEFT_4(o, s, BOOST_PP_LIST_REVERSE_D(4, l))
#define BOOST_PP_LIST_FOLD_RIGHT_5(o,s,l) BOOST_PP_LIST_FOLD_LEFT_5(o, s, BOOST_PP_LIST_REVERSE_D(5, l))
#define BOOST_PP_LIST_FOLD_RIGHT_6(o,s,l) BOOST_PP_LIST_FOLD_LEFT_6(o, s, BOOST_PP_LIST_REVERSE_D(6, l))
#define BOOST_PP_LIST_FOLD_RIGHT_7(o,s,l) BOOST_PP_LIST_FOLD_LEFT_7(o, s, BOOST_PP_LIST_REVERSE_D(7, l))
#define BOOST_PP_LIST_FOLD_RIGHT_8(o,s,l) BOOST_PP_LIST_FOLD_LEFT_8(o, s, BOOST_PP_LIST_REVERSE_D(8, l))
#define BOOST_PP_LIST_FOLD_RIGHT_9(o,s,l) BOOST_PP_LIST_FOLD_LEFT_9(o, s, BOOST_PP_LIST_REVERSE_D(9, l))
#define BOOST_PP_LIST_FOLD_RIGHT_10(o,s,l) BOOST_PP_LIST_FOLD_LEFT_10(o, s, BOOST_PP_LIST_REVERSE_D(10, l))
#define BOOST_PP_LIST_FOLD_RIGHT_11(o,s,l) BOOST_PP_LIST_FOLD_LEFT_11(o, s, BOOST_PP_LIST_REVERSE_D(11, l))
#define BOOST_PP_LIST_FOLD_RIGHT_12(o,s,l) BOOST_PP_LIST_FOLD_LEFT_12(o, s, BOOST_PP_LIST_REVERSE_D(12, l))
#define BOOST_PP_LIST_FOLD_RIGHT_13(o,s,l) BOOST_PP_LIST_FOLD_LEFT_13(o, s, BOOST_PP_LIST_REVERSE_D(13, l))
#define BOOST_PP_LIST_FOLD_RIGHT_14(o,s,l) BOOST_PP_LIST_FOLD_LEFT_14(o, s, BOOST_PP_LIST_REVERSE_D(14, l))
#define BOOST_PP_LIST_FOLD_RIGHT_15(o,s,l) BOOST_PP_LIST_FOLD_LEFT_15(o, s, BOOST_PP_LIST_REVERSE_D(15, l))
#define BOOST_PP_LIST_FOLD_RIGHT_16(o,s,l) BOOST_PP_LIST_FOLD_LEFT_16(o, s, BOOST_PP_LIST_REVERSE_D(16, l))
#define BOOST_PP_LIST_FOLD_RIGHT_17(o,s,l) BOOST_PP_LIST_FOLD_LEFT_17(o, s, BOOST_PP_LIST_REVERSE_D(17, l))
#define BOOST_PP_LIST_FOLD_RIGHT_18(o,s,l) BOOST_PP_LIST_FOLD_LEFT_18(o, s, BOOST_PP_LIST_REVERSE_D(18, l))
#define BOOST_PP_LIST_FOLD_RIGHT_19(o,s,l) BOOST_PP_LIST_FOLD_LEFT_19(o, s, BOOST_PP_LIST_REVERSE_D(19, l))
#define BOOST_PP_LIST_FOLD_RIGHT_20(o,s,l) BOOST_PP_LIST_FOLD_LEFT_20(o, s, BOOST_PP_LIST_REVERSE_D(20, l))
#define BOOST_PP_LIST_FOLD_RIGHT_21(o,s,l) BOOST_PP_LIST_FOLD_LEFT_21(o, s, BOOST_PP_LIST_REVERSE_D(21, l))
#define BOOST_PP_LIST_FOLD_RIGHT_22(o,s,l) BOOST_PP_LIST_FOLD_LEFT_22(o, s, BOOST_PP_LIST_REVERSE_D(22, l))
#define BOOST_PP_LIST_FOLD_RIGHT_23(o,s,l) BOOST_PP_LIST_FOLD_LEFT_23(o, s, BOOST_PP_LIST_REVERSE_D(23, l))
#define BOOST_PP_LIST_FOLD_RIGHT_24(o,s,l) BOOST_PP_LIST_FOLD_LEFT_24(o, s, BOOST_PP_LIST_REVERSE_D(24, l))
#define BOOST_PP_LIST_FOLD_RIGHT_25(o,s,l) BOOST_PP_LIST_FOLD_LEFT_25(o, s, BOOST_PP_LIST_REVERSE_D(25, l))
#define BOOST_PP_LIST_FOLD_RIGHT_26(o,s,l) BOOST_PP_LIST_FOLD_LEFT_26(o, s, BOOST_PP_LIST_REVERSE_D(26, l))
#define BOOST_PP_LIST_FOLD_RIGHT_27(o,s,l) BOOST_PP_LIST_FOLD_LEFT_27(o, s, BOOST_PP_LIST_REVERSE_D(27, l))
#define BOOST_PP_LIST_FOLD_RIGHT_28(o,s,l) BOOST_PP_LIST_FOLD_LEFT_28(o, s, BOOST_PP_LIST_REVERSE_D(28, l))
#define BOOST_PP_LIST_FOLD_RIGHT_29(o,s,l) BOOST_PP_LIST_FOLD_LEFT_29(o, s, BOOST_PP_LIST_REVERSE_D(29, l))
#define BOOST_PP_LIST_FOLD_RIGHT_30(o,s,l) BOOST_PP_LIST_FOLD_LEFT_30(o, s, BOOST_PP_LIST_REVERSE_D(30, l))
#define BOOST_PP_LIST_FOLD_RIGHT_31(o,s,l) BOOST_PP_LIST_FOLD_LEFT_31(o, s, BOOST_PP_LIST_REVERSE_D(31, l))
#define BOOST_PP_LIST_FOLD_RIGHT_32(o,s,l) BOOST_PP_LIST_FOLD_LEFT_32(o, s, BOOST_PP_LIST_REVERSE_D(32, l))
#define BOOST_PP_LIST_FOLD_RIGHT_33(o,s,l) BOOST_PP_LIST_FOLD_LEFT_33(o, s, BOOST_PP_LIST_REVERSE_D(33, l))
#define BOOST_PP_LIST_FOLD_RIGHT_34(o,s,l) BOOST_PP_LIST_FOLD_LEFT_34(o, s, BOOST_PP_LIST_REVERSE_D(34, l))
#define BOOST_PP_LIST_FOLD_RIGHT_35(o,s,l) BOOST_PP_LIST_FOLD_LEFT_35(o, s, BOOST_PP_LIST_REVERSE_D(35, l))
#define BOOST_PP_LIST_FOLD_RIGHT_36(o,s,l) BOOST_PP_LIST_FOLD_LEFT_36(o, s, BOOST_PP_LIST_REVERSE_D(36, l))
#define BOOST_PP_LIST_FOLD_RIGHT_37(o,s,l) BOOST_PP_LIST_FOLD_LEFT_37(o, s, BOOST_PP_LIST_REVERSE_D(37, l))
#define BOOST_PP_LIST_FOLD_RIGHT_38(o,s,l) BOOST_PP_LIST_FOLD_LEFT_38(o, s, BOOST_PP_LIST_REVERSE_D(38, l))
#define BOOST_PP_LIST_FOLD_RIGHT_39(o,s,l) BOOST_PP_LIST_FOLD_LEFT_39(o, s, BOOST_PP_LIST_REVERSE_D(39, l))
#define BOOST_PP_LIST_FOLD_RIGHT_40(o,s,l) BOOST_PP_LIST_FOLD_LEFT_40(o, s, BOOST_PP_LIST_REVERSE_D(40, l))
#define BOOST_PP_LIST_FOLD_RIGHT_41(o,s,l) BOOST_PP_LIST_FOLD_LEFT_41(o, s, BOOST_PP_LIST_REVERSE_D(41, l))
#define BOOST_PP_LIST_FOLD_RIGHT_42(o,s,l) BOOST_PP_LIST_FOLD_LEFT_42(o, s, BOOST_PP_LIST_REVERSE_D(42, l))
#define BOOST_PP_LIST_FOLD_RIGHT_43(o,s,l) BOOST_PP_LIST_FOLD_LEFT_43(o, s, BOOST_PP_LIST_REVERSE_D(43, l))
#define BOOST_PP_LIST_FOLD_RIGHT_44(o,s,l) BOOST_PP_LIST_FOLD_LEFT_44(o, s, BOOST_PP_LIST_REVERSE_D(44, l))
#define BOOST_PP_LIST_FOLD_RIGHT_45(o,s,l) BOOST_PP_LIST_FOLD_LEFT_45(o, s, BOOST_PP_LIST_REVERSE_D(45, l))
#define BOOST_PP_LIST_FOLD_RIGHT_46(o,s,l) BOOST_PP_LIST_FOLD_LEFT_46(o, s, BOOST_PP_LIST_REVERSE_D(46, l))
#define BOOST_PP_LIST_FOLD_RIGHT_47(o,s,l) BOOST_PP_LIST_FOLD_LEFT_47(o, s, BOOST_PP_LIST_REVERSE_D(47, l))
#define BOOST_PP_LIST_FOLD_RIGHT_48(o,s,l) BOOST_PP_LIST_FOLD_LEFT_48(o, s, BOOST_PP_LIST_REVERSE_D(48, l))
#define BOOST_PP_LIST_FOLD_RIGHT_49(o,s,l) BOOST_PP_LIST_FOLD_LEFT_49(o, s, BOOST_PP_LIST_REVERSE_D(49, l))
#define BOOST_PP_LIST_FOLD_RIGHT_50(o,s,l) BOOST_PP_LIST_FOLD_LEFT_50(o, s, BOOST_PP_LIST_REVERSE_D(50, l))
#define BOOST_PP_LIST_FOLD_RIGHT_51(o,s,l) BOOST_PP_LIST_FOLD_LEFT_51(o, s, BOOST_PP_LIST_REVERSE_D(51, l))
#define BOOST_PP_LIST_FOLD_RIGHT_52(o,s,l) BOOST_PP_LIST_FOLD_LEFT_52(o, s, BOOST_PP_LIST_REVERSE_D(52, l))
#define BOOST_PP_LIST_FOLD_RIGHT_53(o,s,l) BOOST_PP_LIST_FOLD_LEFT_53(o, s, BOOST_PP_LIST_REVERSE_D(53, l))
#define BOOST_PP_LIST_FOLD_RIGHT_54(o,s,l) BOOST_PP_LIST_FOLD_LEFT_54(o, s, BOOST_PP_LIST_REVERSE_D(54, l))
#define BOOST_PP_LIST_FOLD_RIGHT_55(o,s,l) BOOST_PP_LIST_FOLD_LEFT_55(o, s, BOOST_PP_LIST_REVERSE_D(55, l))
#define BOOST_PP_LIST_FOLD_RIGHT_56(o,s,l) BOOST_PP_LIST_FOLD_LEFT_56(o, s, BOOST_PP_LIST_REVERSE_D(56, l))
#define BOOST_PP_LIST_FOLD_RIGHT_57(o,s,l) BOOST_PP_LIST_FOLD_LEFT_57(o, s, BOOST_PP_LIST_REVERSE_D(57, l))
#define BOOST_PP_LIST_FOLD_RIGHT_58(o,s,l) BOOST_PP_LIST_FOLD_LEFT_58(o, s, BOOST_PP_LIST_REVERSE_D(58, l))
#define BOOST_PP_LIST_FOLD_RIGHT_59(o,s,l) BOOST_PP_LIST_FOLD_LEFT_59(o, s, BOOST_PP_LIST_REVERSE_D(59, l))
#define BOOST_PP_LIST_FOLD_RIGHT_60(o,s,l) BOOST_PP_LIST_FOLD_LEFT_60(o, s, BOOST_PP_LIST_REVERSE_D(60, l))
#define BOOST_PP_LIST_FOLD_RIGHT_61(o,s,l) BOOST_PP_LIST_FOLD_LEFT_61(o, s, BOOST_PP_LIST_REVERSE_D(61, l))
#define BOOST_PP_LIST_FOLD_RIGHT_62(o,s,l) BOOST_PP_LIST_FOLD_LEFT_62(o, s, BOOST_PP_LIST_REVERSE_D(62, l))
#define BOOST_PP_LIST_FOLD_RIGHT_63(o,s,l) BOOST_PP_LIST_FOLD_LEFT_63(o, s, BOOST_PP_LIST_REVERSE_D(63, l))
#define BOOST_PP_LIST_FOLD_RIGHT_64(o,s,l) BOOST_PP_LIST_FOLD_LEFT_64(o, s, BOOST_PP_LIST_REVERSE_D(64, l))
#define BOOST_PP_LIST_FOLD_RIGHT_65(o,s,l) BOOST_PP_LIST_FOLD_LEFT_65(o, s, BOOST_PP_LIST_REVERSE_D(65, l))
#define BOOST_PP_LIST_FOLD_RIGHT_66(o,s,l) BOOST_PP_LIST_FOLD_LEFT_66(o, s, BOOST_PP_LIST_REVERSE_D(66, l))
#define BOOST_PP_LIST_FOLD_RIGHT_67(o,s,l) BOOST_PP_LIST_FOLD_LEFT_67(o, s, BOOST_PP_LIST_REVERSE_D(67, l))
#define BOOST_PP_LIST_FOLD_RIGHT_68(o,s,l) BOOST_PP_LIST_FOLD_LEFT_68(o, s, BOOST_PP_LIST_REVERSE_D(68, l))
#define BOOST_PP_LIST_FOLD_RIGHT_69(o,s,l) BOOST_PP_LIST_FOLD_LEFT_69(o, s, BOOST_PP_LIST_REVERSE_D(69, l))
#define BOOST_PP_LIST_FOLD_RIGHT_70(o,s,l) BOOST_PP_LIST_FOLD_LEFT_70(o, s, BOOST_PP_LIST_REVERSE_D(70, l))
#define BOOST_PP_LIST_FOLD_RIGHT_71(o,s,l) BOOST_PP_LIST_FOLD_LEFT_71(o, s, BOOST_PP_LIST_REVERSE_D(71, l))
#define BOOST_PP_LIST_FOLD_RIGHT_72(o,s,l) BOOST_PP_LIST_FOLD_LEFT_72(o, s, BOOST_PP_LIST_REVERSE_D(72, l))
#define BOOST_PP_LIST_FOLD_RIGHT_73(o,s,l) BOOST_PP_LIST_FOLD_LEFT_73(o, s, BOOST_PP_LIST_REVERSE_D(73, l))
#define BOOST_PP_LIST_FOLD_RIGHT_74(o,s,l) BOOST_PP_LIST_FOLD_LEFT_74(o, s, BOOST_PP_LIST_REVERSE_D(74, l))
#define BOOST_PP_LIST_FOLD_RIGHT_75(o,s,l) BOOST_PP_LIST_FOLD_LEFT_75(o, s, BOOST_PP_LIST_REVERSE_D(75, l))
#define BOOST_PP_LIST_FOLD_RIGHT_76(o,s,l) BOOST_PP_LIST_FOLD_LEFT_76(o, s, BOOST_PP_LIST_REVERSE_D(76, l))
#define BOOST_PP_LIST_FOLD_RIGHT_77(o,s,l) BOOST_PP_LIST_FOLD_LEFT_77(o, s, BOOST_PP_LIST_REVERSE_D(77, l))
#define BOOST_PP_LIST_FOLD_RIGHT_78(o,s,l) BOOST_PP_LIST_FOLD_LEFT_78(o, s, BOOST_PP_LIST_REVERSE_D(78, l))
#define BOOST_PP_LIST_FOLD_RIGHT_79(o,s,l) BOOST_PP_LIST_FOLD_LEFT_79(o, s, BOOST_PP_LIST_REVERSE_D(79, l))
#define BOOST_PP_LIST_FOLD_RIGHT_80(o,s,l) BOOST_PP_LIST_FOLD_LEFT_80(o, s, BOOST_PP_LIST_REVERSE_D(80, l))
#define BOOST_PP_LIST_FOLD_RIGHT_81(o,s,l) BOOST_PP_LIST_FOLD_LEFT_81(o, s, BOOST_PP_LIST_REVERSE_D(81, l))
#define BOOST_PP_LIST_FOLD_RIGHT_82(o,s,l) BOOST_PP_LIST_FOLD_LEFT_82(o, s, BOOST_PP_LIST_REVERSE_D(82, l))
#define BOOST_PP_LIST_FOLD_RIGHT_83(o,s,l) BOOST_PP_LIST_FOLD_LEFT_83(o, s, BOOST_PP_LIST_REVERSE_D(83, l))
#define BOOST_PP_LIST_FOLD_RIGHT_84(o,s,l) BOOST_PP_LIST_FOLD_LEFT_84(o, s, BOOST_PP_LIST_REVERSE_D(84, l))
#define BOOST_PP_LIST_FOLD_RIGHT_85(o,s,l) BOOST_PP_LIST_FOLD_LEFT_85(o, s, BOOST_PP_LIST_REVERSE_D(85, l))
#define BOOST_PP_LIST_FOLD_RIGHT_86(o,s,l) BOOST_PP_LIST_FOLD_LEFT_86(o, s, BOOST_PP_LIST_REVERSE_D(86, l))
#define BOOST_PP_LIST_FOLD_RIGHT_87(o,s,l) BOOST_PP_LIST_FOLD_LEFT_87(o, s, BOOST_PP_LIST_REVERSE_D(87, l))
#define BOOST_PP_LIST_FOLD_RIGHT_88(o,s,l) BOOST_PP_LIST_FOLD_LEFT_88(o, s, BOOST_PP_LIST_REVERSE_D(88, l))
#define BOOST_PP_LIST_FOLD_RIGHT_89(o,s,l) BOOST_PP_LIST_FOLD_LEFT_89(o, s, BOOST_PP_LIST_REVERSE_D(89, l))
#define BOOST_PP_LIST_FOLD_RIGHT_90(o,s,l) BOOST_PP_LIST_FOLD_LEFT_90(o, s, BOOST_PP_LIST_REVERSE_D(90, l))
#define BOOST_PP_LIST_FOLD_RIGHT_91(o,s,l) BOOST_PP_LIST_FOLD_LEFT_91(o, s, BOOST_PP_LIST_REVERSE_D(91, l))
#define BOOST_PP_LIST_FOLD_RIGHT_92(o,s,l) BOOST_PP_LIST_FOLD_LEFT_92(o, s, BOOST_PP_LIST_REVERSE_D(92, l))
#define BOOST_PP_LIST_FOLD_RIGHT_93(o,s,l) BOOST_PP_LIST_FOLD_LEFT_93(o, s, BOOST_PP_LIST_REVERSE_D(93, l))
#define BOOST_PP_LIST_FOLD_RIGHT_94(o,s,l) BOOST_PP_LIST_FOLD_LEFT_94(o, s, BOOST_PP_LIST_REVERSE_D(94, l))
#define BOOST_PP_LIST_FOLD_RIGHT_95(o,s,l) BOOST_PP_LIST_FOLD_LEFT_95(o, s, BOOST_PP_LIST_REVERSE_D(95, l))
#define BOOST_PP_LIST_FOLD_RIGHT_96(o,s,l) BOOST_PP_LIST_FOLD_LEFT_96(o, s, BOOST_PP_LIST_REVERSE_D(96, l))
#define BOOST_PP_LIST_FOLD_RIGHT_97(o,s,l) BOOST_PP_LIST_FOLD_LEFT_97(o, s, BOOST_PP_LIST_REVERSE_D(97, l))
#define BOOST_PP_LIST_FOLD_RIGHT_98(o,s,l) BOOST_PP_LIST_FOLD_LEFT_98(o, s, BOOST_PP_LIST_REVERSE_D(98, l))
#define BOOST_PP_LIST_FOLD_RIGHT_99(o,s,l) BOOST_PP_LIST_FOLD_LEFT_99(o, s, BOOST_PP_LIST_REVERSE_D(99, l))
#define BOOST_PP_LIST_FOLD_RIGHT_100(o,s,l) BOOST_PP_LIST_FOLD_LEFT_100(o, s, BOOST_PP_LIST_REVERSE_D(100, l))
#define BOOST_PP_LIST_FOLD_RIGHT_101(o,s,l) BOOST_PP_LIST_FOLD_LEFT_101(o, s, BOOST_PP_LIST_REVERSE_D(101, l))
#define BOOST_PP_LIST_FOLD_RIGHT_102(o,s,l) BOOST_PP_LIST_FOLD_LEFT_102(o, s, BOOST_PP_LIST_REVERSE_D(102, l))
#define BOOST_PP_LIST_FOLD_RIGHT_103(o,s,l) BOOST_PP_LIST_FOLD_LEFT_103(o, s, BOOST_PP_LIST_REVERSE_D(103, l))
#define BOOST_PP_LIST_FOLD_RIGHT_104(o,s,l) BOOST_PP_LIST_FOLD_LEFT_104(o, s, BOOST_PP_LIST_REVERSE_D(104, l))
#define BOOST_PP_LIST_FOLD_RIGHT_105(o,s,l) BOOST_PP_LIST_FOLD_LEFT_105(o, s, BOOST_PP_LIST_REVERSE_D(105, l))
#define BOOST_PP_LIST_FOLD_RIGHT_106(o,s,l) BOOST_PP_LIST_FOLD_LEFT_106(o, s, BOOST_PP_LIST_REVERSE_D(106, l))
#define BOOST_PP_LIST_FOLD_RIGHT_107(o,s,l) BOOST_PP_LIST_FOLD_LEFT_107(o, s, BOOST_PP_LIST_REVERSE_D(107, l))
#define BOOST_PP_LIST_FOLD_RIGHT_108(o,s,l) BOOST_PP_LIST_FOLD_LEFT_108(o, s, BOOST_PP_LIST_REVERSE_D(108, l))
#define BOOST_PP_LIST_FOLD_RIGHT_109(o,s,l) BOOST_PP_LIST_FOLD_LEFT_109(o, s, BOOST_PP_LIST_REVERSE_D(109, l))
#define BOOST_PP_LIST_FOLD_RIGHT_110(o,s,l) BOOST_PP_LIST_FOLD_LEFT_110(o, s, BOOST_PP_LIST_REVERSE_D(110, l))
#define BOOST_PP_LIST_FOLD_RIGHT_111(o,s,l) BOOST_PP_LIST_FOLD_LEFT_111(o, s, BOOST_PP_LIST_REVERSE_D(111, l))
#define BOOST_PP_LIST_FOLD_RIGHT_112(o,s,l) BOOST_PP_LIST_FOLD_LEFT_112(o, s, BOOST_PP_LIST_REVERSE_D(112, l))
#define BOOST_PP_LIST_FOLD_RIGHT_113(o,s,l) BOOST_PP_LIST_FOLD_LEFT_113(o, s, BOOST_PP_LIST_REVERSE_D(113, l))
#define BOOST_PP_LIST_FOLD_RIGHT_114(o,s,l) BOOST_PP_LIST_FOLD_LEFT_114(o, s, BOOST_PP_LIST_REVERSE_D(114, l))
#define BOOST_PP_LIST_FOLD_RIGHT_115(o,s,l) BOOST_PP_LIST_FOLD_LEFT_115(o, s, BOOST_PP_LIST_REVERSE_D(115, l))
#define BOOST_PP_LIST_FOLD_RIGHT_116(o,s,l) BOOST_PP_LIST_FOLD_LEFT_116(o, s, BOOST_PP_LIST_REVERSE_D(116, l))
#define BOOST_PP_LIST_FOLD_RIGHT_117(o,s,l) BOOST_PP_LIST_FOLD_LEFT_117(o, s, BOOST_PP_LIST_REVERSE_D(117, l))
#define BOOST_PP_LIST_FOLD_RIGHT_118(o,s,l) BOOST_PP_LIST_FOLD_LEFT_118(o, s, BOOST_PP_LIST_REVERSE_D(118, l))
#define BOOST_PP_LIST_FOLD_RIGHT_119(o,s,l) BOOST_PP_LIST_FOLD_LEFT_119(o, s, BOOST_PP_LIST_REVERSE_D(119, l))
#define BOOST_PP_LIST_FOLD_RIGHT_120(o,s,l) BOOST_PP_LIST_FOLD_LEFT_120(o, s, BOOST_PP_LIST_REVERSE_D(120, l))
#define BOOST_PP_LIST_FOLD_RIGHT_121(o,s,l) BOOST_PP_LIST_FOLD_LEFT_121(o, s, BOOST_PP_LIST_REVERSE_D(121, l))
#define BOOST_PP_LIST_FOLD_RIGHT_122(o,s,l) BOOST_PP_LIST_FOLD_LEFT_122(o, s, BOOST_PP_LIST_REVERSE_D(122, l))
#define BOOST_PP_LIST_FOLD_RIGHT_123(o,s,l) BOOST_PP_LIST_FOLD_LEFT_123(o, s, BOOST_PP_LIST_REVERSE_D(123, l))
#define BOOST_PP_LIST_FOLD_RIGHT_124(o,s,l) BOOST_PP_LIST_FOLD_LEFT_124(o, s, BOOST_PP_LIST_REVERSE_D(124, l))
#define BOOST_PP_LIST_FOLD_RIGHT_125(o,s,l) BOOST_PP_LIST_FOLD_LEFT_125(o, s, BOOST_PP_LIST_REVERSE_D(125, l))
#define BOOST_PP_LIST_FOLD_RIGHT_126(o,s,l) BOOST_PP_LIST_FOLD_LEFT_126(o, s, BOOST_PP_LIST_REVERSE_D(126, l))
#define BOOST_PP_LIST_FOLD_RIGHT_127(o,s,l) BOOST_PP_LIST_FOLD_LEFT_127(o, s, BOOST_PP_LIST_REVERSE_D(127, l))
#define BOOST_PP_LIST_FOLD_RIGHT_128(o,s,l) BOOST_PP_LIST_FOLD_LEFT_128(o, s, BOOST_PP_LIST_REVERSE_D(128, l))
#define BOOST_PP_LIST_FOLD_RIGHT_129(o,s,l) BOOST_PP_LIST_FOLD_LEFT_129(o, s, BOOST_PP_LIST_REVERSE_D(129, l))
#define BOOST_PP_LIST_FOLD_RIGHT_130(o,s,l) BOOST_PP_LIST_FOLD_LEFT_130(o, s, BOOST_PP_LIST_REVERSE_D(130, l))
#define BOOST_PP_LIST_FOLD_RIGHT_131(o,s,l) BOOST_PP_LIST_FOLD_LEFT_131(o, s, BOOST_PP_LIST_REVERSE_D(131, l))
#define BOOST_PP_LIST_FOLD_RIGHT_132(o,s,l) BOOST_PP_LIST_FOLD_LEFT_132(o, s, BOOST_PP_LIST_REVERSE_D(132, l))
#define BOOST_PP_LIST_FOLD_RIGHT_133(o,s,l) BOOST_PP_LIST_FOLD_LEFT_133(o, s, BOOST_PP_LIST_REVERSE_D(133, l))
#define BOOST_PP_LIST_FOLD_RIGHT_134(o,s,l) BOOST_PP_LIST_FOLD_LEFT_134(o, s, BOOST_PP_LIST_REVERSE_D(134, l))
#define BOOST_PP_LIST_FOLD_RIGHT_135(o,s,l) BOOST_PP_LIST_FOLD_LEFT_135(o, s, BOOST_PP_LIST_REVERSE_D(135, l))
#define BOOST_PP_LIST_FOLD_RIGHT_136(o,s,l) BOOST_PP_LIST_FOLD_LEFT_136(o, s, BOOST_PP_LIST_REVERSE_D(136, l))
#define BOOST_PP_LIST_FOLD_RIGHT_137(o,s,l) BOOST_PP_LIST_FOLD_LEFT_137(o, s, BOOST_PP_LIST_REVERSE_D(137, l))
#define BOOST_PP_LIST_FOLD_RIGHT_138(o,s,l) BOOST_PP_LIST_FOLD_LEFT_138(o, s, BOOST_PP_LIST_REVERSE_D(138, l))
#define BOOST_PP_LIST_FOLD_RIGHT_139(o,s,l) BOOST_PP_LIST_FOLD_LEFT_139(o, s, BOOST_PP_LIST_REVERSE_D(139, l))
#define BOOST_PP_LIST_FOLD_RIGHT_140(o,s,l) BOOST_PP_LIST_FOLD_LEFT_140(o, s, BOOST_PP_LIST_REVERSE_D(140, l))
#define BOOST_PP_LIST_FOLD_RIGHT_141(o,s,l) BOOST_PP_LIST_FOLD_LEFT_141(o, s, BOOST_PP_LIST_REVERSE_D(141, l))
#define BOOST_PP_LIST_FOLD_RIGHT_142(o,s,l) BOOST_PP_LIST_FOLD_LEFT_142(o, s, BOOST_PP_LIST_REVERSE_D(142, l))
#define BOOST_PP_LIST_FOLD_RIGHT_143(o,s,l) BOOST_PP_LIST_FOLD_LEFT_143(o, s, BOOST_PP_LIST_REVERSE_D(143, l))
#define BOOST_PP_LIST_FOLD_RIGHT_144(o,s,l) BOOST_PP_LIST_FOLD_LEFT_144(o, s, BOOST_PP_LIST_REVERSE_D(144, l))
#define BOOST_PP_LIST_FOLD_RIGHT_145(o,s,l) BOOST_PP_LIST_FOLD_LEFT_145(o, s, BOOST_PP_LIST_REVERSE_D(145, l))
#define BOOST_PP_LIST_FOLD_RIGHT_146(o,s,l) BOOST_PP_LIST_FOLD_LEFT_146(o, s, BOOST_PP_LIST_REVERSE_D(146, l))
#define BOOST_PP_LIST_FOLD_RIGHT_147(o,s,l) BOOST_PP_LIST_FOLD_LEFT_147(o, s, BOOST_PP_LIST_REVERSE_D(147, l))
#define BOOST_PP_LIST_FOLD_RIGHT_148(o,s,l) BOOST_PP_LIST_FOLD_LEFT_148(o, s, BOOST_PP_LIST_REVERSE_D(148, l))
#define BOOST_PP_LIST_FOLD_RIGHT_149(o,s,l) BOOST_PP_LIST_FOLD_LEFT_149(o, s, BOOST_PP_LIST_REVERSE_D(149, l))
#define BOOST_PP_LIST_FOLD_RIGHT_150(o,s,l) BOOST_PP_LIST_FOLD_LEFT_150(o, s, BOOST_PP_LIST_REVERSE_D(150, l))
#define BOOST_PP_LIST_FOLD_RIGHT_151(o,s,l) BOOST_PP_LIST_FOLD_LEFT_151(o, s, BOOST_PP_LIST_REVERSE_D(151, l))
#define BOOST_PP_LIST_FOLD_RIGHT_152(o,s,l) BOOST_PP_LIST_FOLD_LEFT_152(o, s, BOOST_PP_LIST_REVERSE_D(152, l))
#define BOOST_PP_LIST_FOLD_RIGHT_153(o,s,l) BOOST_PP_LIST_FOLD_LEFT_153(o, s, BOOST_PP_LIST_REVERSE_D(153, l))
#define BOOST_PP_LIST_FOLD_RIGHT_154(o,s,l) BOOST_PP_LIST_FOLD_LEFT_154(o, s, BOOST_PP_LIST_REVERSE_D(154, l))
#define BOOST_PP_LIST_FOLD_RIGHT_155(o,s,l) BOOST_PP_LIST_FOLD_LEFT_155(o, s, BOOST_PP_LIST_REVERSE_D(155, l))
#define BOOST_PP_LIST_FOLD_RIGHT_156(o,s,l) BOOST_PP_LIST_FOLD_LEFT_156(o, s, BOOST_PP_LIST_REVERSE_D(156, l))
#define BOOST_PP_LIST_FOLD_RIGHT_157(o,s,l) BOOST_PP_LIST_FOLD_LEFT_157(o, s, BOOST_PP_LIST_REVERSE_D(157, l))
#define BOOST_PP_LIST_FOLD_RIGHT_158(o,s,l) BOOST_PP_LIST_FOLD_LEFT_158(o, s, BOOST_PP_LIST_REVERSE_D(158, l))
#define BOOST_PP_LIST_FOLD_RIGHT_159(o,s,l) BOOST_PP_LIST_FOLD_LEFT_159(o, s, BOOST_PP_LIST_REVERSE_D(159, l))
#define BOOST_PP_LIST_FOLD_RIGHT_160(o,s,l) BOOST_PP_LIST_FOLD_LEFT_160(o, s, BOOST_PP_LIST_REVERSE_D(160, l))
#define BOOST_PP_LIST_FOLD_RIGHT_161(o,s,l) BOOST_PP_LIST_FOLD_LEFT_161(o, s, BOOST_PP_LIST_REVERSE_D(161, l))
#define BOOST_PP_LIST_FOLD_RIGHT_162(o,s,l) BOOST_PP_LIST_FOLD_LEFT_162(o, s, BOOST_PP_LIST_REVERSE_D(162, l))
#define BOOST_PP_LIST_FOLD_RIGHT_163(o,s,l) BOOST_PP_LIST_FOLD_LEFT_163(o, s, BOOST_PP_LIST_REVERSE_D(163, l))
#define BOOST_PP_LIST_FOLD_RIGHT_164(o,s,l) BOOST_PP_LIST_FOLD_LEFT_164(o, s, BOOST_PP_LIST_REVERSE_D(164, l))
#define BOOST_PP_LIST_FOLD_RIGHT_165(o,s,l) BOOST_PP_LIST_FOLD_LEFT_165(o, s, BOOST_PP_LIST_REVERSE_D(165, l))
#define BOOST_PP_LIST_FOLD_RIGHT_166(o,s,l) BOOST_PP_LIST_FOLD_LEFT_166(o, s, BOOST_PP_LIST_REVERSE_D(166, l))
#define BOOST_PP_LIST_FOLD_RIGHT_167(o,s,l) BOOST_PP_LIST_FOLD_LEFT_167(o, s, BOOST_PP_LIST_REVERSE_D(167, l))
#define BOOST_PP_LIST_FOLD_RIGHT_168(o,s,l) BOOST_PP_LIST_FOLD_LEFT_168(o, s, BOOST_PP_LIST_REVERSE_D(168, l))
#define BOOST_PP_LIST_FOLD_RIGHT_169(o,s,l) BOOST_PP_LIST_FOLD_LEFT_169(o, s, BOOST_PP_LIST_REVERSE_D(169, l))
#define BOOST_PP_LIST_FOLD_RIGHT_170(o,s,l) BOOST_PP_LIST_FOLD_LEFT_170(o, s, BOOST_PP_LIST_REVERSE_D(170, l))
#define BOOST_PP_LIST_FOLD_RIGHT_171(o,s,l) BOOST_PP_LIST_FOLD_LEFT_171(o, s, BOOST_PP_LIST_REVERSE_D(171, l))
#define BOOST_PP_LIST_FOLD_RIGHT_172(o,s,l) BOOST_PP_LIST_FOLD_LEFT_172(o, s, BOOST_PP_LIST_REVERSE_D(172, l))
#define BOOST_PP_LIST_FOLD_RIGHT_173(o,s,l) BOOST_PP_LIST_FOLD_LEFT_173(o, s, BOOST_PP_LIST_REVERSE_D(173, l))
#define BOOST_PP_LIST_FOLD_RIGHT_174(o,s,l) BOOST_PP_LIST_FOLD_LEFT_174(o, s, BOOST_PP_LIST_REVERSE_D(174, l))
#define BOOST_PP_LIST_FOLD_RIGHT_175(o,s,l) BOOST_PP_LIST_FOLD_LEFT_175(o, s, BOOST_PP_LIST_REVERSE_D(175, l))
#define BOOST_PP_LIST_FOLD_RIGHT_176(o,s,l) BOOST_PP_LIST_FOLD_LEFT_176(o, s, BOOST_PP_LIST_REVERSE_D(176, l))
#define BOOST_PP_LIST_FOLD_RIGHT_177(o,s,l) BOOST_PP_LIST_FOLD_LEFT_177(o, s, BOOST_PP_LIST_REVERSE_D(177, l))
#define BOOST_PP_LIST_FOLD_RIGHT_178(o,s,l) BOOST_PP_LIST_FOLD_LEFT_178(o, s, BOOST_PP_LIST_REVERSE_D(178, l))
#define BOOST_PP_LIST_FOLD_RIGHT_179(o,s,l) BOOST_PP_LIST_FOLD_LEFT_179(o, s, BOOST_PP_LIST_REVERSE_D(179, l))
#define BOOST_PP_LIST_FOLD_RIGHT_180(o,s,l) BOOST_PP_LIST_FOLD_LEFT_180(o, s, BOOST_PP_LIST_REVERSE_D(180, l))
#define BOOST_PP_LIST_FOLD_RIGHT_181(o,s,l) BOOST_PP_LIST_FOLD_LEFT_181(o, s, BOOST_PP_LIST_REVERSE_D(181, l))
#define BOOST_PP_LIST_FOLD_RIGHT_182(o,s,l) BOOST_PP_LIST_FOLD_LEFT_182(o, s, BOOST_PP_LIST_REVERSE_D(182, l))
#define BOOST_PP_LIST_FOLD_RIGHT_183(o,s,l) BOOST_PP_LIST_FOLD_LEFT_183(o, s, BOOST_PP_LIST_REVERSE_D(183, l))
#define BOOST_PP_LIST_FOLD_RIGHT_184(o,s,l) BOOST_PP_LIST_FOLD_LEFT_184(o, s, BOOST_PP_LIST_REVERSE_D(184, l))
#define BOOST_PP_LIST_FOLD_RIGHT_185(o,s,l) BOOST_PP_LIST_FOLD_LEFT_185(o, s, BOOST_PP_LIST_REVERSE_D(185, l))
#define BOOST_PP_LIST_FOLD_RIGHT_186(o,s,l) BOOST_PP_LIST_FOLD_LEFT_186(o, s, BOOST_PP_LIST_REVERSE_D(186, l))
#define BOOST_PP_LIST_FOLD_RIGHT_187(o,s,l) BOOST_PP_LIST_FOLD_LEFT_187(o, s, BOOST_PP_LIST_REVERSE_D(187, l))
#define BOOST_PP_LIST_FOLD_RIGHT_188(o,s,l) BOOST_PP_LIST_FOLD_LEFT_188(o, s, BOOST_PP_LIST_REVERSE_D(188, l))
#define BOOST_PP_LIST_FOLD_RIGHT_189(o,s,l) BOOST_PP_LIST_FOLD_LEFT_189(o, s, BOOST_PP_LIST_REVERSE_D(189, l))
#define BOOST_PP_LIST_FOLD_RIGHT_190(o,s,l) BOOST_PP_LIST_FOLD_LEFT_190(o, s, BOOST_PP_LIST_REVERSE_D(190, l))
#define BOOST_PP_LIST_FOLD_RIGHT_191(o,s,l) BOOST_PP_LIST_FOLD_LEFT_191(o, s, BOOST_PP_LIST_REVERSE_D(191, l))
#define BOOST_PP_LIST_FOLD_RIGHT_192(o,s,l) BOOST_PP_LIST_FOLD_LEFT_192(o, s, BOOST_PP_LIST_REVERSE_D(192, l))
#define BOOST_PP_LIST_FOLD_RIGHT_193(o,s,l) BOOST_PP_LIST_FOLD_LEFT_193(o, s, BOOST_PP_LIST_REVERSE_D(193, l))
#define BOOST_PP_LIST_FOLD_RIGHT_194(o,s,l) BOOST_PP_LIST_FOLD_LEFT_194(o, s, BOOST_PP_LIST_REVERSE_D(194, l))
#define BOOST_PP_LIST_FOLD_RIGHT_195(o,s,l) BOOST_PP_LIST_FOLD_LEFT_195(o, s, BOOST_PP_LIST_REVERSE_D(195, l))
#define BOOST_PP_LIST_FOLD_RIGHT_196(o,s,l) BOOST_PP_LIST_FOLD_LEFT_196(o, s, BOOST_PP_LIST_REVERSE_D(196, l))
#define BOOST_PP_LIST_FOLD_RIGHT_197(o,s,l) BOOST_PP_LIST_FOLD_LEFT_197(o, s, BOOST_PP_LIST_REVERSE_D(197, l))
#define BOOST_PP_LIST_FOLD_RIGHT_198(o,s,l) BOOST_PP_LIST_FOLD_LEFT_198(o, s, BOOST_PP_LIST_REVERSE_D(198, l))
#define BOOST_PP_LIST_FOLD_RIGHT_199(o,s,l) BOOST_PP_LIST_FOLD_LEFT_199(o, s, BOOST_PP_LIST_REVERSE_D(199, l))
#define BOOST_PP_LIST_FOLD_RIGHT_200(o,s,l) BOOST_PP_LIST_FOLD_LEFT_200(o, s, BOOST_PP_LIST_REVERSE_D(200, l))
#define BOOST_PP_LIST_FOLD_RIGHT_201(o,s,l) BOOST_PP_LIST_FOLD_LEFT_201(o, s, BOOST_PP_LIST_REVERSE_D(201, l))
#define BOOST_PP_LIST_FOLD_RIGHT_202(o,s,l) BOOST_PP_LIST_FOLD_LEFT_202(o, s, BOOST_PP_LIST_REVERSE_D(202, l))
#define BOOST_PP_LIST_FOLD_RIGHT_203(o,s,l) BOOST_PP_LIST_FOLD_LEFT_203(o, s, BOOST_PP_LIST_REVERSE_D(203, l))
#define BOOST_PP_LIST_FOLD_RIGHT_204(o,s,l) BOOST_PP_LIST_FOLD_LEFT_204(o, s, BOOST_PP_LIST_REVERSE_D(204, l))
#define BOOST_PP_LIST_FOLD_RIGHT_205(o,s,l) BOOST_PP_LIST_FOLD_LEFT_205(o, s, BOOST_PP_LIST_REVERSE_D(205, l))
#define BOOST_PP_LIST_FOLD_RIGHT_206(o,s,l) BOOST_PP_LIST_FOLD_LEFT_206(o, s, BOOST_PP_LIST_REVERSE_D(206, l))
#define BOOST_PP_LIST_FOLD_RIGHT_207(o,s,l) BOOST_PP_LIST_FOLD_LEFT_207(o, s, BOOST_PP_LIST_REVERSE_D(207, l))
#define BOOST_PP_LIST_FOLD_RIGHT_208(o,s,l) BOOST_PP_LIST_FOLD_LEFT_208(o, s, BOOST_PP_LIST_REVERSE_D(208, l))
#define BOOST_PP_LIST_FOLD_RIGHT_209(o,s,l) BOOST_PP_LIST_FOLD_LEFT_209(o, s, BOOST_PP_LIST_REVERSE_D(209, l))
#define BOOST_PP_LIST_FOLD_RIGHT_210(o,s,l) BOOST_PP_LIST_FOLD_LEFT_210(o, s, BOOST_PP_LIST_REVERSE_D(210, l))
#define BOOST_PP_LIST_FOLD_RIGHT_211(o,s,l) BOOST_PP_LIST_FOLD_LEFT_211(o, s, BOOST_PP_LIST_REVERSE_D(211, l))
#define BOOST_PP_LIST_FOLD_RIGHT_212(o,s,l) BOOST_PP_LIST_FOLD_LEFT_212(o, s, BOOST_PP_LIST_REVERSE_D(212, l))
#define BOOST_PP_LIST_FOLD_RIGHT_213(o,s,l) BOOST_PP_LIST_FOLD_LEFT_213(o, s, BOOST_PP_LIST_REVERSE_D(213, l))
#define BOOST_PP_LIST_FOLD_RIGHT_214(o,s,l) BOOST_PP_LIST_FOLD_LEFT_214(o, s, BOOST_PP_LIST_REVERSE_D(214, l))
#define BOOST_PP_LIST_FOLD_RIGHT_215(o,s,l) BOOST_PP_LIST_FOLD_LEFT_215(o, s, BOOST_PP_LIST_REVERSE_D(215, l))
#define BOOST_PP_LIST_FOLD_RIGHT_216(o,s,l) BOOST_PP_LIST_FOLD_LEFT_216(o, s, BOOST_PP_LIST_REVERSE_D(216, l))
#define BOOST_PP_LIST_FOLD_RIGHT_217(o,s,l) BOOST_PP_LIST_FOLD_LEFT_217(o, s, BOOST_PP_LIST_REVERSE_D(217, l))
#define BOOST_PP_LIST_FOLD_RIGHT_218(o,s,l) BOOST_PP_LIST_FOLD_LEFT_218(o, s, BOOST_PP_LIST_REVERSE_D(218, l))
#define BOOST_PP_LIST_FOLD_RIGHT_219(o,s,l) BOOST_PP_LIST_FOLD_LEFT_219(o, s, BOOST_PP_LIST_REVERSE_D(219, l))
#define BOOST_PP_LIST_FOLD_RIGHT_220(o,s,l) BOOST_PP_LIST_FOLD_LEFT_220(o, s, BOOST_PP_LIST_REVERSE_D(220, l))
#define BOOST_PP_LIST_FOLD_RIGHT_221(o,s,l) BOOST_PP_LIST_FOLD_LEFT_221(o, s, BOOST_PP_LIST_REVERSE_D(221, l))
#define BOOST_PP_LIST_FOLD_RIGHT_222(o,s,l) BOOST_PP_LIST_FOLD_LEFT_222(o, s, BOOST_PP_LIST_REVERSE_D(222, l))
#define BOOST_PP_LIST_FOLD_RIGHT_223(o,s,l) BOOST_PP_LIST_FOLD_LEFT_223(o, s, BOOST_PP_LIST_REVERSE_D(223, l))
#define BOOST_PP_LIST_FOLD_RIGHT_224(o,s,l) BOOST_PP_LIST_FOLD_LEFT_224(o, s, BOOST_PP_LIST_REVERSE_D(224, l))
#define BOOST_PP_LIST_FOLD_RIGHT_225(o,s,l) BOOST_PP_LIST_FOLD_LEFT_225(o, s, BOOST_PP_LIST_REVERSE_D(225, l))
#define BOOST_PP_LIST_FOLD_RIGHT_226(o,s,l) BOOST_PP_LIST_FOLD_LEFT_226(o, s, BOOST_PP_LIST_REVERSE_D(226, l))
#define BOOST_PP_LIST_FOLD_RIGHT_227(o,s,l) BOOST_PP_LIST_FOLD_LEFT_227(o, s, BOOST_PP_LIST_REVERSE_D(227, l))
#define BOOST_PP_LIST_FOLD_RIGHT_228(o,s,l) BOOST_PP_LIST_FOLD_LEFT_228(o, s, BOOST_PP_LIST_REVERSE_D(228, l))
#define BOOST_PP_LIST_FOLD_RIGHT_229(o,s,l) BOOST_PP_LIST_FOLD_LEFT_229(o, s, BOOST_PP_LIST_REVERSE_D(229, l))
#define BOOST_PP_LIST_FOLD_RIGHT_230(o,s,l) BOOST_PP_LIST_FOLD_LEFT_230(o, s, BOOST_PP_LIST_REVERSE_D(230, l))
#define BOOST_PP_LIST_FOLD_RIGHT_231(o,s,l) BOOST_PP_LIST_FOLD_LEFT_231(o, s, BOOST_PP_LIST_REVERSE_D(231, l))
#define BOOST_PP_LIST_FOLD_RIGHT_232(o,s,l) BOOST_PP_LIST_FOLD_LEFT_232(o, s, BOOST_PP_LIST_REVERSE_D(232, l))
#define BOOST_PP_LIST_FOLD_RIGHT_233(o,s,l) BOOST_PP_LIST_FOLD_LEFT_233(o, s, BOOST_PP_LIST_REVERSE_D(233, l))
#define BOOST_PP_LIST_FOLD_RIGHT_234(o,s,l) BOOST_PP_LIST_FOLD_LEFT_234(o, s, BOOST_PP_LIST_REVERSE_D(234, l))
#define BOOST_PP_LIST_FOLD_RIGHT_235(o,s,l) BOOST_PP_LIST_FOLD_LEFT_235(o, s, BOOST_PP_LIST_REVERSE_D(235, l))
#define BOOST_PP_LIST_FOLD_RIGHT_236(o,s,l) BOOST_PP_LIST_FOLD_LEFT_236(o, s, BOOST_PP_LIST_REVERSE_D(236, l))
#define BOOST_PP_LIST_FOLD_RIGHT_237(o,s,l) BOOST_PP_LIST_FOLD_LEFT_237(o, s, BOOST_PP_LIST_REVERSE_D(237, l))
#define BOOST_PP_LIST_FOLD_RIGHT_238(o,s,l) BOOST_PP_LIST_FOLD_LEFT_238(o, s, BOOST_PP_LIST_REVERSE_D(238, l))
#define BOOST_PP_LIST_FOLD_RIGHT_239(o,s,l) BOOST_PP_LIST_FOLD_LEFT_239(o, s, BOOST_PP_LIST_REVERSE_D(239, l))
#define BOOST_PP_LIST_FOLD_RIGHT_240(o,s,l) BOOST_PP_LIST_FOLD_LEFT_240(o, s, BOOST_PP_LIST_REVERSE_D(240, l))
#define BOOST_PP_LIST_FOLD_RIGHT_241(o,s,l) BOOST_PP_LIST_FOLD_LEFT_241(o, s, BOOST_PP_LIST_REVERSE_D(241, l))
#define BOOST_PP_LIST_FOLD_RIGHT_242(o,s,l) BOOST_PP_LIST_FOLD_LEFT_242(o, s, BOOST_PP_LIST_REVERSE_D(242, l))
#define BOOST_PP_LIST_FOLD_RIGHT_243(o,s,l) BOOST_PP_LIST_FOLD_LEFT_243(o, s, BOOST_PP_LIST_REVERSE_D(243, l))
#define BOOST_PP_LIST_FOLD_RIGHT_244(o,s,l) BOOST_PP_LIST_FOLD_LEFT_244(o, s, BOOST_PP_LIST_REVERSE_D(244, l))
#define BOOST_PP_LIST_FOLD_RIGHT_245(o,s,l) BOOST_PP_LIST_FOLD_LEFT_245(o, s, BOOST_PP_LIST_REVERSE_D(245, l))
#define BOOST_PP_LIST_FOLD_RIGHT_246(o,s,l) BOOST_PP_LIST_FOLD_LEFT_246(o, s, BOOST_PP_LIST_REVERSE_D(246, l))
#define BOOST_PP_LIST_FOLD_RIGHT_247(o,s,l) BOOST_PP_LIST_FOLD_LEFT_247(o, s, BOOST_PP_LIST_REVERSE_D(247, l))
#define BOOST_PP_LIST_FOLD_RIGHT_248(o,s,l) BOOST_PP_LIST_FOLD_LEFT_248(o, s, BOOST_PP_LIST_REVERSE_D(248, l))
#define BOOST_PP_LIST_FOLD_RIGHT_249(o,s,l) BOOST_PP_LIST_FOLD_LEFT_249(o, s, BOOST_PP_LIST_REVERSE_D(249, l))
#define BOOST_PP_LIST_FOLD_RIGHT_250(o,s,l) BOOST_PP_LIST_FOLD_LEFT_250(o, s, BOOST_PP_LIST_REVERSE_D(250, l))
#define BOOST_PP_LIST_FOLD_RIGHT_251(o,s,l) BOOST_PP_LIST_FOLD_LEFT_251(o, s, BOOST_PP_LIST_REVERSE_D(251, l))
#define BOOST_PP_LIST_FOLD_RIGHT_252(o,s,l) BOOST_PP_LIST_FOLD_LEFT_252(o, s, BOOST_PP_LIST_REVERSE_D(252, l))
#define BOOST_PP_LIST_FOLD_RIGHT_253(o,s,l) BOOST_PP_LIST_FOLD_LEFT_253(o, s, BOOST_PP_LIST_REVERSE_D(253, l))
#define BOOST_PP_LIST_FOLD_RIGHT_254(o,s,l) BOOST_PP_LIST_FOLD_LEFT_254(o, s, BOOST_PP_LIST_REVERSE_D(254, l))
#define BOOST_PP_LIST_FOLD_RIGHT_255(o,s,l) BOOST_PP_LIST_FOLD_LEFT_255(o, s, BOOST_PP_LIST_REVERSE_D(255, l))
#define BOOST_PP_LIST_FOLD_RIGHT_256(o,s,l) BOOST_PP_LIST_FOLD_LEFT_256(o, s, BOOST_PP_LIST_REVERSE_D(256, l))
#define BOOST_PP_WHILE BOOST_PP_CAT(BOOST_PP_WHILE_, BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256))
#define BOOST_PP_WHILE_P(n) BOOST_PP_BITAND(BOOST_PP_CAT(BOOST_PP_WHILE_CHECK_, BOOST_PP_WHILE_ ## n(BOOST_PP_WHILE_F, BOOST_PP_NIL, BOOST_PP_NIL)), BOOST_PP_CAT(BOOST_PP_LIST_FOLD_LEFT_CHECK_, BOOST_PP_LIST_FOLD_LEFT_ ## n(BOOST_PP_NIL, BOOST_PP_NIL, BOOST_PP_NIL)))
#define BOOST_PP_WHILE_F(d,_) 0
#define BOOST_PREPROCESSOR_CONTROL_DETAIL_WHILE_HPP
#define BOOST_PP_WHILE_1(p,o,s) BOOST_PP_WHILE_1_C(BOOST_PP_BOOL(p(2, s)), p, o, s)
#define BOOST_PP_WHILE_2(p,o,s) BOOST_PP_WHILE_2_C(BOOST_PP_BOOL(p(3, s)), p, o, s)
#define BOOST_PP_WHILE_3(p,o,s) BOOST_PP_WHILE_3_C(BOOST_PP_BOOL(p(4, s)), p, o, s)
#define BOOST_PP_WHILE_4(p,o,s) BOOST_PP_WHILE_4_C(BOOST_PP_BOOL(p(5, s)), p, o, s)
#define BOOST_PP_WHILE_5(p,o,s) BOOST_PP_WHILE_5_C(BOOST_PP_BOOL(p(6, s)), p, o, s)
#define BOOST_PP_WHILE_6(p,o,s) BOOST_PP_WHILE_6_C(BOOST_PP_BOOL(p(7, s)), p, o, s)
#define BOOST_PP_WHILE_7(p,o,s) BOOST_PP_WHILE_7_C(BOOST_PP_BOOL(p(8, s)), p, o, s)
#define BOOST_PP_WHILE_8(p,o,s) BOOST_PP_WHILE_8_C(BOOST_PP_BOOL(p(9, s)), p, o, s)
#define BOOST_PP_WHILE_9(p,o,s) BOOST_PP_WHILE_9_C(BOOST_PP_BOOL(p(10, s)), p, o, s)
#define BOOST_PP_WHILE_10(p,o,s) BOOST_PP_WHILE_10_C(BOOST_PP_BOOL(p(11, s)), p, o, s)
#define BOOST_PP_WHILE_11(p,o,s) BOOST_PP_WHILE_11_C(BOOST_PP_BOOL(p(12, s)), p, o, s)
#define BOOST_PP_WHILE_12(p,o,s) BOOST_PP_WHILE_12_C(BOOST_PP_BOOL(p(13, s)), p, o, s)
#define BOOST_PP_WHILE_13(p,o,s) BOOST_PP_WHILE_13_C(BOOST_PP_BOOL(p(14, s)), p, o, s)
#define BOOST_PP_WHILE_14(p,o,s) BOOST_PP_WHILE_14_C(BOOST_PP_BOOL(p(15, s)), p, o, s)
#define BOOST_PP_WHILE_15(p,o,s) BOOST_PP_WHILE_15_C(BOOST_PP_BOOL(p(16, s)), p, o, s)
#define BOOST_PP_WHILE_16(p,o,s) BOOST_PP_WHILE_16_C(BOOST_PP_BOOL(p(17, s)), p, o, s)
#define BOOST_PP_WHILE_17(p,o,s) BOOST_PP_WHILE_17_C(BOOST_PP_BOOL(p(18, s)), p, o, s)
#define BOOST_PP_WHILE_18(p,o,s) BOOST_PP_WHILE_18_C(BOOST_PP_BOOL(p(19, s)), p, o, s)
#define BOOST_PP_WHILE_19(p,o,s) BOOST_PP_WHILE_19_C(BOOST_PP_BOOL(p(20, s)), p, o, s)
#define BOOST_PP_WHILE_20(p,o,s) BOOST_PP_WHILE_20_C(BOOST_PP_BOOL(p(21, s)), p, o, s)
#define BOOST_PP_WHILE_21(p,o,s) BOOST_PP_WHILE_21_C(BOOST_PP_BOOL(p(22, s)), p, o, s)
#define BOOST_PP_WHILE_22(p,o,s) BOOST_PP_WHILE_22_C(BOOST_PP_BOOL(p(23, s)), p, o, s)
#define BOOST_PP_WHILE_23(p,o,s) BOOST_PP_WHILE_23_C(BOOST_PP_BOOL(p(24, s)), p, o, s)
#define BOOST_PP_WHILE_24(p,o,s) BOOST_PP_WHILE_24_C(BOOST_PP_BOOL(p(25, s)), p, o, s)
#define BOOST_PP_WHILE_25(p,o,s) BOOST_PP_WHILE_25_C(BOOST_PP_BOOL(p(26, s)), p, o, s)
#define BOOST_PP_WHILE_26(p,o,s) BOOST_PP_WHILE_26_C(BOOST_PP_BOOL(p(27, s)), p, o, s)
#define BOOST_PP_WHILE_27(p,o,s) BOOST_PP_WHILE_27_C(BOOST_PP_BOOL(p(28, s)), p, o, s)
#define BOOST_PP_WHILE_28(p,o,s) BOOST_PP_WHILE_28_C(BOOST_PP_BOOL(p(29, s)), p, o, s)
#define BOOST_PP_WHILE_29(p,o,s) BOOST_PP_WHILE_29_C(BOOST_PP_BOOL(p(30, s)), p, o, s)
#define BOOST_PP_WHILE_30(p,o,s) BOOST_PP_WHILE_30_C(BOOST_PP_BOOL(p(31, s)), p, o, s)
#define BOOST_PP_WHILE_31(p,o,s) BOOST_PP_WHILE_31_C(BOOST_PP_BOOL(p(32, s)), p, o, s)
#define BOOST_PP_WHILE_32(p,o,s) BOOST_PP_WHILE_32_C(BOOST_PP_BOOL(p(33, s)), p, o, s)
#define BOOST_PP_WHILE_33(p,o,s) BOOST_PP_WHILE_33_C(BOOST_PP_BOOL(p(34, s)), p, o, s)
#define BOOST_PP_WHILE_34(p,o,s) BOOST_PP_WHILE_34_C(BOOST_PP_BOOL(p(35, s)), p, o, s)
#define BOOST_PP_WHILE_35(p,o,s) BOOST_PP_WHILE_35_C(BOOST_PP_BOOL(p(36, s)), p, o, s)
#define BOOST_PP_WHILE_36(p,o,s) BOOST_PP_WHILE_36_C(BOOST_PP_BOOL(p(37, s)), p, o, s)
#define BOOST_PP_WHILE_37(p,o,s) BOOST_PP_WHILE_37_C(BOOST_PP_BOOL(p(38, s)), p, o, s)
#define BOOST_PP_WHILE_38(p,o,s) BOOST_PP_WHILE_38_C(BOOST_PP_BOOL(p(39, s)), p, o, s)
#define BOOST_PP_WHILE_39(p,o,s) BOOST_PP_WHILE_39_C(BOOST_PP_BOOL(p(40, s)), p, o, s)
#define BOOST_PP_WHILE_40(p,o,s) BOOST_PP_WHILE_40_C(BOOST_PP_BOOL(p(41, s)), p, o, s)
#define BOOST_PP_WHILE_41(p,o,s) BOOST_PP_WHILE_41_C(BOOST_PP_BOOL(p(42, s)), p, o, s)
#define BOOST_PP_WHILE_42(p,o,s) BOOST_PP_WHILE_42_C(BOOST_PP_BOOL(p(43, s)), p, o, s)
#define BOOST_PP_WHILE_43(p,o,s) BOOST_PP_WHILE_43_C(BOOST_PP_BOOL(p(44, s)), p, o, s)
#define BOOST_PP_WHILE_44(p,o,s) BOOST_PP_WHILE_44_C(BOOST_PP_BOOL(p(45, s)), p, o, s)
#define BOOST_PP_WHILE_45(p,o,s) BOOST_PP_WHILE_45_C(BOOST_PP_BOOL(p(46, s)), p, o, s)
#define BOOST_PP_WHILE_46(p,o,s) BOOST_PP_WHILE_46_C(BOOST_PP_BOOL(p(47, s)), p, o, s)
#define BOOST_PP_WHILE_47(p,o,s) BOOST_PP_WHILE_47_C(BOOST_PP_BOOL(p(48, s)), p, o, s)
#define BOOST_PP_WHILE_48(p,o,s) BOOST_PP_WHILE_48_C(BOOST_PP_BOOL(p(49, s)), p, o, s)
#define BOOST_PP_WHILE_49(p,o,s) BOOST_PP_WHILE_49_C(BOOST_PP_BOOL(p(50, s)), p, o, s)
#define BOOST_PP_WHILE_50(p,o,s) BOOST_PP_WHILE_50_C(BOOST_PP_BOOL(p(51, s)), p, o, s)
#define BOOST_PP_WHILE_51(p,o,s) BOOST_PP_WHILE_51_C(BOOST_PP_BOOL(p(52, s)), p, o, s)
#define BOOST_PP_WHILE_52(p,o,s) BOOST_PP_WHILE_52_C(BOOST_PP_BOOL(p(53, s)), p, o, s)
#define BOOST_PP_WHILE_53(p,o,s) BOOST_PP_WHILE_53_C(BOOST_PP_BOOL(p(54, s)), p, o, s)
#define BOOST_PP_WHILE_54(p,o,s) BOOST_PP_WHILE_54_C(BOOST_PP_BOOL(p(55, s)), p, o, s)
#define BOOST_PP_WHILE_55(p,o,s) BOOST_PP_WHILE_55_C(BOOST_PP_BOOL(p(56, s)), p, o, s)
#define BOOST_PP_WHILE_56(p,o,s) BOOST_PP_WHILE_56_C(BOOST_PP_BOOL(p(57, s)), p, o, s)
#define BOOST_PP_WHILE_57(p,o,s) BOOST_PP_WHILE_57_C(BOOST_PP_BOOL(p(58, s)), p, o, s)
#define BOOST_PP_WHILE_58(p,o,s) BOOST_PP_WHILE_58_C(BOOST_PP_BOOL(p(59, s)), p, o, s)
#define BOOST_PP_WHILE_59(p,o,s) BOOST_PP_WHILE_59_C(BOOST_PP_BOOL(p(60, s)), p, o, s)
#define BOOST_PP_WHILE_60(p,o,s) BOOST_PP_WHILE_60_C(BOOST_PP_BOOL(p(61, s)), p, o, s)
#define BOOST_PP_WHILE_61(p,o,s) BOOST_PP_WHILE_61_C(BOOST_PP_BOOL(p(62, s)), p, o, s)
#define BOOST_PP_WHILE_62(p,o,s) BOOST_PP_WHILE_62_C(BOOST_PP_BOOL(p(63, s)), p, o, s)
#define BOOST_PP_WHILE_63(p,o,s) BOOST_PP_WHILE_63_C(BOOST_PP_BOOL(p(64, s)), p, o, s)
#define BOOST_PP_WHILE_64(p,o,s) BOOST_PP_WHILE_64_C(BOOST_PP_BOOL(p(65, s)), p, o, s)
#define BOOST_PP_WHILE_65(p,o,s) BOOST_PP_WHILE_65_C(BOOST_PP_BOOL(p(66, s)), p, o, s)
#define BOOST_PP_WHILE_66(p,o,s) BOOST_PP_WHILE_66_C(BOOST_PP_BOOL(p(67, s)), p, o, s)
#define BOOST_PP_WHILE_67(p,o,s) BOOST_PP_WHILE_67_C(BOOST_PP_BOOL(p(68, s)), p, o, s)
#define BOOST_PP_WHILE_68(p,o,s) BOOST_PP_WHILE_68_C(BOOST_PP_BOOL(p(69, s)), p, o, s)
#define BOOST_PP_WHILE_69(p,o,s) BOOST_PP_WHILE_69_C(BOOST_PP_BOOL(p(70, s)), p, o, s)
#define BOOST_PP_WHILE_70(p,o,s) BOOST_PP_WHILE_70_C(BOOST_PP_BOOL(p(71, s)), p, o, s)
#define BOOST_PP_WHILE_71(p,o,s) BOOST_PP_WHILE_71_C(BOOST_PP_BOOL(p(72, s)), p, o, s)
#define BOOST_PP_WHILE_72(p,o,s) BOOST_PP_WHILE_72_C(BOOST_PP_BOOL(p(73, s)), p, o, s)
#define BOOST_PP_WHILE_73(p,o,s) BOOST_PP_WHILE_73_C(BOOST_PP_BOOL(p(74, s)), p, o, s)
#define BOOST_PP_WHILE_74(p,o,s) BOOST_PP_WHILE_74_C(BOOST_PP_BOOL(p(75, s)), p, o, s)
#define BOOST_PP_WHILE_75(p,o,s) BOOST_PP_WHILE_75_C(BOOST_PP_BOOL(p(76, s)), p, o, s)
#define BOOST_PP_WHILE_76(p,o,s) BOOST_PP_WHILE_76_C(BOOST_PP_BOOL(p(77, s)), p, o, s)
#define BOOST_PP_WHILE_77(p,o,s) BOOST_PP_WHILE_77_C(BOOST_PP_BOOL(p(78, s)), p, o, s)
#define BOOST_PP_WHILE_78(p,o,s) BOOST_PP_WHILE_78_C(BOOST_PP_BOOL(p(79, s)), p, o, s)
#define BOOST_PP_WHILE_79(p,o,s) BOOST_PP_WHILE_79_C(BOOST_PP_BOOL(p(80, s)), p, o, s)
#define BOOST_PP_WHILE_80(p,o,s) BOOST_PP_WHILE_80_C(BOOST_PP_BOOL(p(81, s)), p, o, s)
#define BOOST_PP_WHILE_81(p,o,s) BOOST_PP_WHILE_81_C(BOOST_PP_BOOL(p(82, s)), p, o, s)
#define BOOST_PP_WHILE_82(p,o,s) BOOST_PP_WHILE_82_C(BOOST_PP_BOOL(p(83, s)), p, o, s)
#define BOOST_PP_WHILE_83(p,o,s) BOOST_PP_WHILE_83_C(BOOST_PP_BOOL(p(84, s)), p, o, s)
#define BOOST_PP_WHILE_84(p,o,s) BOOST_PP_WHILE_84_C(BOOST_PP_BOOL(p(85, s)), p, o, s)
#define BOOST_PP_WHILE_85(p,o,s) BOOST_PP_WHILE_85_C(BOOST_PP_BOOL(p(86, s)), p, o, s)
#define BOOST_PP_WHILE_86(p,o,s) BOOST_PP_WHILE_86_C(BOOST_PP_BOOL(p(87, s)), p, o, s)
#define BOOST_PP_WHILE_87(p,o,s) BOOST_PP_WHILE_87_C(BOOST_PP_BOOL(p(88, s)), p, o, s)
#define BOOST_PP_WHILE_88(p,o,s) BOOST_PP_WHILE_88_C(BOOST_PP_BOOL(p(89, s)), p, o, s)
#define BOOST_PP_WHILE_89(p,o,s) BOOST_PP_WHILE_89_C(BOOST_PP_BOOL(p(90, s)), p, o, s)
#define BOOST_PP_WHILE_90(p,o,s) BOOST_PP_WHILE_90_C(BOOST_PP_BOOL(p(91, s)), p, o, s)
#define BOOST_PP_WHILE_91(p,o,s) BOOST_PP_WHILE_91_C(BOOST_PP_BOOL(p(92, s)), p, o, s)
#define BOOST_PP_WHILE_92(p,o,s) BOOST_PP_WHILE_92_C(BOOST_PP_BOOL(p(93, s)), p, o, s)
#define BOOST_PP_WHILE_93(p,o,s) BOOST_PP_WHILE_93_C(BOOST_PP_BOOL(p(94, s)), p, o, s)
#define BOOST_PP_WHILE_94(p,o,s) BOOST_PP_WHILE_94_C(BOOST_PP_BOOL(p(95, s)), p, o, s)
#define BOOST_PP_WHILE_95(p,o,s) BOOST_PP_WHILE_95_C(BOOST_PP_BOOL(p(96, s)), p, o, s)
#define BOOST_PP_WHILE_96(p,o,s) BOOST_PP_WHILE_96_C(BOOST_PP_BOOL(p(97, s)), p, o, s)
#define BOOST_PP_WHILE_97(p,o,s) BOOST_PP_WHILE_97_C(BOOST_PP_BOOL(p(98, s)), p, o, s)
#define BOOST_PP_WHILE_98(p,o,s) BOOST_PP_WHILE_98_C(BOOST_PP_BOOL(p(99, s)), p, o, s)
#define BOOST_PP_WHILE_99(p,o,s) BOOST_PP_WHILE_99_C(BOOST_PP_BOOL(p(100, s)), p, o, s)
#define BOOST_PP_WHILE_100(p,o,s) BOOST_PP_WHILE_100_C(BOOST_PP_BOOL(p(101, s)), p, o, s)
#define BOOST_PP_WHILE_101(p,o,s) BOOST_PP_WHILE_101_C(BOOST_PP_BOOL(p(102, s)), p, o, s)
#define BOOST_PP_WHILE_102(p,o,s) BOOST_PP_WHILE_102_C(BOOST_PP_BOOL(p(103, s)), p, o, s)
#define BOOST_PP_WHILE_103(p,o,s) BOOST_PP_WHILE_103_C(BOOST_PP_BOOL(p(104, s)), p, o, s)
#define BOOST_PP_WHILE_104(p,o,s) BOOST_PP_WHILE_104_C(BOOST_PP_BOOL(p(105, s)), p, o, s)
#define BOOST_PP_WHILE_105(p,o,s) BOOST_PP_WHILE_105_C(BOOST_PP_BOOL(p(106, s)), p, o, s)
#define BOOST_PP_WHILE_106(p,o,s) BOOST_PP_WHILE_106_C(BOOST_PP_BOOL(p(107, s)), p, o, s)
#define BOOST_PP_WHILE_107(p,o,s) BOOST_PP_WHILE_107_C(BOOST_PP_BOOL(p(108, s)), p, o, s)
#define BOOST_PP_WHILE_108(p,o,s) BOOST_PP_WHILE_108_C(BOOST_PP_BOOL(p(109, s)), p, o, s)
#define BOOST_PP_WHILE_109(p,o,s) BOOST_PP_WHILE_109_C(BOOST_PP_BOOL(p(110, s)), p, o, s)
#define BOOST_PP_WHILE_110(p,o,s) BOOST_PP_WHILE_110_C(BOOST_PP_BOOL(p(111, s)), p, o, s)
#define BOOST_PP_WHILE_111(p,o,s) BOOST_PP_WHILE_111_C(BOOST_PP_BOOL(p(112, s)), p, o, s)
#define BOOST_PP_WHILE_112(p,o,s) BOOST_PP_WHILE_112_C(BOOST_PP_BOOL(p(113, s)), p, o, s)
#define BOOST_PP_WHILE_113(p,o,s) BOOST_PP_WHILE_113_C(BOOST_PP_BOOL(p(114, s)), p, o, s)
#define BOOST_PP_WHILE_114(p,o,s) BOOST_PP_WHILE_114_C(BOOST_PP_BOOL(p(115, s)), p, o, s)
#define BOOST_PP_WHILE_115(p,o,s) BOOST_PP_WHILE_115_C(BOOST_PP_BOOL(p(116, s)), p, o, s)
#define BOOST_PP_WHILE_116(p,o,s) BOOST_PP_WHILE_116_C(BOOST_PP_BOOL(p(117, s)), p, o, s)
#define BOOST_PP_WHILE_117(p,o,s) BOOST_PP_WHILE_117_C(BOOST_PP_BOOL(p(118, s)), p, o, s)
#define BOOST_PP_WHILE_118(p,o,s) BOOST_PP_WHILE_118_C(BOOST_PP_BOOL(p(119, s)), p, o, s)
#define BOOST_PP_WHILE_119(p,o,s) BOOST_PP_WHILE_119_C(BOOST_PP_BOOL(p(120, s)), p, o, s)
#define BOOST_PP_WHILE_120(p,o,s) BOOST_PP_WHILE_120_C(BOOST_PP_BOOL(p(121, s)), p, o, s)
#define BOOST_PP_WHILE_121(p,o,s) BOOST_PP_WHILE_121_C(BOOST_PP_BOOL(p(122, s)), p, o, s)
#define BOOST_PP_WHILE_122(p,o,s) BOOST_PP_WHILE_122_C(BOOST_PP_BOOL(p(123, s)), p, o, s)
#define BOOST_PP_WHILE_123(p,o,s) BOOST_PP_WHILE_123_C(BOOST_PP_BOOL(p(124, s)), p, o, s)
#define BOOST_PP_WHILE_124(p,o,s) BOOST_PP_WHILE_124_C(BOOST_PP_BOOL(p(125, s)), p, o, s)
#define BOOST_PP_WHILE_125(p,o,s) BOOST_PP_WHILE_125_C(BOOST_PP_BOOL(p(126, s)), p, o, s)
#define BOOST_PP_WHILE_126(p,o,s) BOOST_PP_WHILE_126_C(BOOST_PP_BOOL(p(127, s)), p, o, s)
#define BOOST_PP_WHILE_127(p,o,s) BOOST_PP_WHILE_127_C(BOOST_PP_BOOL(p(128, s)), p, o, s)
#define BOOST_PP_WHILE_128(p,o,s) BOOST_PP_WHILE_128_C(BOOST_PP_BOOL(p(129, s)), p, o, s)
#define BOOST_PP_WHILE_129(p,o,s) BOOST_PP_WHILE_129_C(BOOST_PP_BOOL(p(130, s)), p, o, s)
#define BOOST_PP_WHILE_130(p,o,s) BOOST_PP_WHILE_130_C(BOOST_PP_BOOL(p(131, s)), p, o, s)
#define BOOST_PP_WHILE_131(p,o,s) BOOST_PP_WHILE_131_C(BOOST_PP_BOOL(p(132, s)), p, o, s)
#define BOOST_PP_WHILE_132(p,o,s) BOOST_PP_WHILE_132_C(BOOST_PP_BOOL(p(133, s)), p, o, s)
#define BOOST_PP_WHILE_133(p,o,s) BOOST_PP_WHILE_133_C(BOOST_PP_BOOL(p(134, s)), p, o, s)
#define BOOST_PP_WHILE_134(p,o,s) BOOST_PP_WHILE_134_C(BOOST_PP_BOOL(p(135, s)), p, o, s)
#define BOOST_PP_WHILE_135(p,o,s) BOOST_PP_WHILE_135_C(BOOST_PP_BOOL(p(136, s)), p, o, s)
#define BOOST_PP_WHILE_136(p,o,s) BOOST_PP_WHILE_136_C(BOOST_PP_BOOL(p(137, s)), p, o, s)
#define BOOST_PP_WHILE_137(p,o,s) BOOST_PP_WHILE_137_C(BOOST_PP_BOOL(p(138, s)), p, o, s)
#define BOOST_PP_WHILE_138(p,o,s) BOOST_PP_WHILE_138_C(BOOST_PP_BOOL(p(139, s)), p, o, s)
#define BOOST_PP_WHILE_139(p,o,s) BOOST_PP_WHILE_139_C(BOOST_PP_BOOL(p(140, s)), p, o, s)
#define BOOST_PP_WHILE_140(p,o,s) BOOST_PP_WHILE_140_C(BOOST_PP_BOOL(p(141, s)), p, o, s)
#define BOOST_PP_WHILE_141(p,o,s) BOOST_PP_WHILE_141_C(BOOST_PP_BOOL(p(142, s)), p, o, s)
#define BOOST_PP_WHILE_142(p,o,s) BOOST_PP_WHILE_142_C(BOOST_PP_BOOL(p(143, s)), p, o, s)
#define BOOST_PP_WHILE_143(p,o,s) BOOST_PP_WHILE_143_C(BOOST_PP_BOOL(p(144, s)), p, o, s)
#define BOOST_PP_WHILE_144(p,o,s) BOOST_PP_WHILE_144_C(BOOST_PP_BOOL(p(145, s)), p, o, s)
#define BOOST_PP_WHILE_145(p,o,s) BOOST_PP_WHILE_145_C(BOOST_PP_BOOL(p(146, s)), p, o, s)
#define BOOST_PP_WHILE_146(p,o,s) BOOST_PP_WHILE_146_C(BOOST_PP_BOOL(p(147, s)), p, o, s)
#define BOOST_PP_WHILE_147(p,o,s) BOOST_PP_WHILE_147_C(BOOST_PP_BOOL(p(148, s)), p, o, s)
#define BOOST_PP_WHILE_148(p,o,s) BOOST_PP_WHILE_148_C(BOOST_PP_BOOL(p(149, s)), p, o, s)
#define BOOST_PP_WHILE_149(p,o,s) BOOST_PP_WHILE_149_C(BOOST_PP_BOOL(p(150, s)), p, o, s)
#define BOOST_PP_WHILE_150(p,o,s) BOOST_PP_WHILE_150_C(BOOST_PP_BOOL(p(151, s)), p, o, s)
#define BOOST_PP_WHILE_151(p,o,s) BOOST_PP_WHILE_151_C(BOOST_PP_BOOL(p(152, s)), p, o, s)
#define BOOST_PP_WHILE_152(p,o,s) BOOST_PP_WHILE_152_C(BOOST_PP_BOOL(p(153, s)), p, o, s)
#define BOOST_PP_WHILE_153(p,o,s) BOOST_PP_WHILE_153_C(BOOST_PP_BOOL(p(154, s)), p, o, s)
#define BOOST_PP_WHILE_154(p,o,s) BOOST_PP_WHILE_154_C(BOOST_PP_BOOL(p(155, s)), p, o, s)
#define BOOST_PP_WHILE_155(p,o,s) BOOST_PP_WHILE_155_C(BOOST_PP_BOOL(p(156, s)), p, o, s)
#define BOOST_PP_WHILE_156(p,o,s) BOOST_PP_WHILE_156_C(BOOST_PP_BOOL(p(157, s)), p, o, s)
#define BOOST_PP_WHILE_157(p,o,s) BOOST_PP_WHILE_157_C(BOOST_PP_BOOL(p(158, s)), p, o, s)
#define BOOST_PP_WHILE_158(p,o,s) BOOST_PP_WHILE_158_C(BOOST_PP_BOOL(p(159, s)), p, o, s)
#define BOOST_PP_WHILE_159(p,o,s) BOOST_PP_WHILE_159_C(BOOST_PP_BOOL(p(160, s)), p, o, s)
#define BOOST_PP_WHILE_160(p,o,s) BOOST_PP_WHILE_160_C(BOOST_PP_BOOL(p(161, s)), p, o, s)
#define BOOST_PP_WHILE_161(p,o,s) BOOST_PP_WHILE_161_C(BOOST_PP_BOOL(p(162, s)), p, o, s)
#define BOOST_PP_WHILE_162(p,o,s) BOOST_PP_WHILE_162_C(BOOST_PP_BOOL(p(163, s)), p, o, s)
#define BOOST_PP_WHILE_163(p,o,s) BOOST_PP_WHILE_163_C(BOOST_PP_BOOL(p(164, s)), p, o, s)
#define BOOST_PP_WHILE_164(p,o,s) BOOST_PP_WHILE_164_C(BOOST_PP_BOOL(p(165, s)), p, o, s)
#define BOOST_PP_WHILE_165(p,o,s) BOOST_PP_WHILE_165_C(BOOST_PP_BOOL(p(166, s)), p, o, s)
#define BOOST_PP_WHILE_166(p,o,s) BOOST_PP_WHILE_166_C(BOOST_PP_BOOL(p(167, s)), p, o, s)
#define BOOST_PP_WHILE_167(p,o,s) BOOST_PP_WHILE_167_C(BOOST_PP_BOOL(p(168, s)), p, o, s)
#define BOOST_PP_WHILE_168(p,o,s) BOOST_PP_WHILE_168_C(BOOST_PP_BOOL(p(169, s)), p, o, s)
#define BOOST_PP_WHILE_169(p,o,s) BOOST_PP_WHILE_169_C(BOOST_PP_BOOL(p(170, s)), p, o, s)
#define BOOST_PP_WHILE_170(p,o,s) BOOST_PP_WHILE_170_C(BOOST_PP_BOOL(p(171, s)), p, o, s)
#define BOOST_PP_WHILE_171(p,o,s) BOOST_PP_WHILE_171_C(BOOST_PP_BOOL(p(172, s)), p, o, s)
#define BOOST_PP_WHILE_172(p,o,s) BOOST_PP_WHILE_172_C(BOOST_PP_BOOL(p(173, s)), p, o, s)
#define BOOST_PP_WHILE_173(p,o,s) BOOST_PP_WHILE_173_C(BOOST_PP_BOOL(p(174, s)), p, o, s)
#define BOOST_PP_WHILE_174(p,o,s) BOOST_PP_WHILE_174_C(BOOST_PP_BOOL(p(175, s)), p, o, s)
#define BOOST_PP_WHILE_175(p,o,s) BOOST_PP_WHILE_175_C(BOOST_PP_BOOL(p(176, s)), p, o, s)
#define BOOST_PP_WHILE_176(p,o,s) BOOST_PP_WHILE_176_C(BOOST_PP_BOOL(p(177, s)), p, o, s)
#define BOOST_PP_WHILE_177(p,o,s) BOOST_PP_WHILE_177_C(BOOST_PP_BOOL(p(178, s)), p, o, s)
#define BOOST_PP_WHILE_178(p,o,s) BOOST_PP_WHILE_178_C(BOOST_PP_BOOL(p(179, s)), p, o, s)
#define BOOST_PP_WHILE_179(p,o,s) BOOST_PP_WHILE_179_C(BOOST_PP_BOOL(p(180, s)), p, o, s)
#define BOOST_PP_WHILE_180(p,o,s) BOOST_PP_WHILE_180_C(BOOST_PP_BOOL(p(181, s)), p, o, s)
#define BOOST_PP_WHILE_181(p,o,s) BOOST_PP_WHILE_181_C(BOOST_PP_BOOL(p(182, s)), p, o, s)
#define BOOST_PP_WHILE_182(p,o,s) BOOST_PP_WHILE_182_C(BOOST_PP_BOOL(p(183, s)), p, o, s)
#define BOOST_PP_WHILE_183(p,o,s) BOOST_PP_WHILE_183_C(BOOST_PP_BOOL(p(184, s)), p, o, s)
#define BOOST_PP_WHILE_184(p,o,s) BOOST_PP_WHILE_184_C(BOOST_PP_BOOL(p(185, s)), p, o, s)
#define BOOST_PP_WHILE_185(p,o,s) BOOST_PP_WHILE_185_C(BOOST_PP_BOOL(p(186, s)), p, o, s)
#define BOOST_PP_WHILE_186(p,o,s) BOOST_PP_WHILE_186_C(BOOST_PP_BOOL(p(187, s)), p, o, s)
#define BOOST_PP_WHILE_187(p,o,s) BOOST_PP_WHILE_187_C(BOOST_PP_BOOL(p(188, s)), p, o, s)
#define BOOST_PP_WHILE_188(p,o,s) BOOST_PP_WHILE_188_C(BOOST_PP_BOOL(p(189, s)), p, o, s)
#define BOOST_PP_WHILE_189(p,o,s) BOOST_PP_WHILE_189_C(BOOST_PP_BOOL(p(190, s)), p, o, s)
#define BOOST_PP_WHILE_190(p,o,s) BOOST_PP_WHILE_190_C(BOOST_PP_BOOL(p(191, s)), p, o, s)
#define BOOST_PP_WHILE_191(p,o,s) BOOST_PP_WHILE_191_C(BOOST_PP_BOOL(p(192, s)), p, o, s)
#define BOOST_PP_WHILE_192(p,o,s) BOOST_PP_WHILE_192_C(BOOST_PP_BOOL(p(193, s)), p, o, s)
#define BOOST_PP_WHILE_193(p,o,s) BOOST_PP_WHILE_193_C(BOOST_PP_BOOL(p(194, s)), p, o, s)
#define BOOST_PP_WHILE_194(p,o,s) BOOST_PP_WHILE_194_C(BOOST_PP_BOOL(p(195, s)), p, o, s)
#define BOOST_PP_WHILE_195(p,o,s) BOOST_PP_WHILE_195_C(BOOST_PP_BOOL(p(196, s)), p, o, s)
#define BOOST_PP_WHILE_196(p,o,s) BOOST_PP_WHILE_196_C(BOOST_PP_BOOL(p(197, s)), p, o, s)
#define BOOST_PP_WHILE_197(p,o,s) BOOST_PP_WHILE_197_C(BOOST_PP_BOOL(p(198, s)), p, o, s)
#define BOOST_PP_WHILE_198(p,o,s) BOOST_PP_WHILE_198_C(BOOST_PP_BOOL(p(199, s)), p, o, s)
#define BOOST_PP_WHILE_199(p,o,s) BOOST_PP_WHILE_199_C(BOOST_PP_BOOL(p(200, s)), p, o, s)
#define BOOST_PP_WHILE_200(p,o,s) BOOST_PP_WHILE_200_C(BOOST_PP_BOOL(p(201, s)), p, o, s)
#define BOOST_PP_WHILE_201(p,o,s) BOOST_PP_WHILE_201_C(BOOST_PP_BOOL(p(202, s)), p, o, s)
#define BOOST_PP_WHILE_202(p,o,s) BOOST_PP_WHILE_202_C(BOOST_PP_BOOL(p(203, s)), p, o, s)
#define BOOST_PP_WHILE_203(p,o,s) BOOST_PP_WHILE_203_C(BOOST_PP_BOOL(p(204, s)), p, o, s)
#define BOOST_PP_WHILE_204(p,o,s) BOOST_PP_WHILE_204_C(BOOST_PP_BOOL(p(205, s)), p, o, s)
#define BOOST_PP_WHILE_205(p,o,s) BOOST_PP_WHILE_205_C(BOOST_PP_BOOL(p(206, s)), p, o, s)
#define BOOST_PP_WHILE_206(p,o,s) BOOST_PP_WHILE_206_C(BOOST_PP_BOOL(p(207, s)), p, o, s)
#define BOOST_PP_WHILE_207(p,o,s) BOOST_PP_WHILE_207_C(BOOST_PP_BOOL(p(208, s)), p, o, s)
#define BOOST_PP_WHILE_208(p,o,s) BOOST_PP_WHILE_208_C(BOOST_PP_BOOL(p(209, s)), p, o, s)
#define BOOST_PP_WHILE_209(p,o,s) BOOST_PP_WHILE_209_C(BOOST_PP_BOOL(p(210, s)), p, o, s)
#define BOOST_PP_WHILE_210(p,o,s) BOOST_PP_WHILE_210_C(BOOST_PP_BOOL(p(211, s)), p, o, s)
#define BOOST_PP_WHILE_211(p,o,s) BOOST_PP_WHILE_211_C(BOOST_PP_BOOL(p(212, s)), p, o, s)
#define BOOST_PP_WHILE_212(p,o,s) BOOST_PP_WHILE_212_C(BOOST_PP_BOOL(p(213, s)), p, o, s)
#define BOOST_PP_WHILE_213(p,o,s) BOOST_PP_WHILE_213_C(BOOST_PP_BOOL(p(214, s)), p, o, s)
#define BOOST_PP_WHILE_214(p,o,s) BOOST_PP_WHILE_214_C(BOOST_PP_BOOL(p(215, s)), p, o, s)
#define BOOST_PP_WHILE_215(p,o,s) BOOST_PP_WHILE_215_C(BOOST_PP_BOOL(p(216, s)), p, o, s)
#define BOOST_PP_WHILE_216(p,o,s) BOOST_PP_WHILE_216_C(BOOST_PP_BOOL(p(217, s)), p, o, s)
#define BOOST_PP_WHILE_217(p,o,s) BOOST_PP_WHILE_217_C(BOOST_PP_BOOL(p(218, s)), p, o, s)
#define BOOST_PP_WHILE_218(p,o,s) BOOST_PP_WHILE_218_C(BOOST_PP_BOOL(p(219, s)), p, o, s)
#define BOOST_PP_WHILE_219(p,o,s) BOOST_PP_WHILE_219_C(BOOST_PP_BOOL(p(220, s)), p, o, s)
#define BOOST_PP_WHILE_220(p,o,s) BOOST_PP_WHILE_220_C(BOOST_PP_BOOL(p(221, s)), p, o, s)
#define BOOST_PP_WHILE_221(p,o,s) BOOST_PP_WHILE_221_C(BOOST_PP_BOOL(p(222, s)), p, o, s)
#define BOOST_PP_WHILE_222(p,o,s) BOOST_PP_WHILE_222_C(BOOST_PP_BOOL(p(223, s)), p, o, s)
#define BOOST_PP_WHILE_223(p,o,s) BOOST_PP_WHILE_223_C(BOOST_PP_BOOL(p(224, s)), p, o, s)
#define BOOST_PP_WHILE_224(p,o,s) BOOST_PP_WHILE_224_C(BOOST_PP_BOOL(p(225, s)), p, o, s)
#define BOOST_PP_WHILE_225(p,o,s) BOOST_PP_WHILE_225_C(BOOST_PP_BOOL(p(226, s)), p, o, s)
#define BOOST_PP_WHILE_226(p,o,s) BOOST_PP_WHILE_226_C(BOOST_PP_BOOL(p(227, s)), p, o, s)
#define BOOST_PP_WHILE_227(p,o,s) BOOST_PP_WHILE_227_C(BOOST_PP_BOOL(p(228, s)), p, o, s)
#define BOOST_PP_WHILE_228(p,o,s) BOOST_PP_WHILE_228_C(BOOST_PP_BOOL(p(229, s)), p, o, s)
#define BOOST_PP_WHILE_229(p,o,s) BOOST_PP_WHILE_229_C(BOOST_PP_BOOL(p(230, s)), p, o, s)
#define BOOST_PP_WHILE_230(p,o,s) BOOST_PP_WHILE_230_C(BOOST_PP_BOOL(p(231, s)), p, o, s)
#define BOOST_PP_WHILE_231(p,o,s) BOOST_PP_WHILE_231_C(BOOST_PP_BOOL(p(232, s)), p, o, s)
#define BOOST_PP_WHILE_232(p,o,s) BOOST_PP_WHILE_232_C(BOOST_PP_BOOL(p(233, s)), p, o, s)
#define BOOST_PP_WHILE_233(p,o,s) BOOST_PP_WHILE_233_C(BOOST_PP_BOOL(p(234, s)), p, o, s)
#define BOOST_PP_WHILE_234(p,o,s) BOOST_PP_WHILE_234_C(BOOST_PP_BOOL(p(235, s)), p, o, s)
#define BOOST_PP_WHILE_235(p,o,s) BOOST_PP_WHILE_235_C(BOOST_PP_BOOL(p(236, s)), p, o, s)
#define BOOST_PP_WHILE_236(p,o,s) BOOST_PP_WHILE_236_C(BOOST_PP_BOOL(p(237, s)), p, o, s)
#define BOOST_PP_WHILE_237(p,o,s) BOOST_PP_WHILE_237_C(BOOST_PP_BOOL(p(238, s)), p, o, s)
#define BOOST_PP_WHILE_238(p,o,s) BOOST_PP_WHILE_238_C(BOOST_PP_BOOL(p(239, s)), p, o, s)
#define BOOST_PP_WHILE_239(p,o,s) BOOST_PP_WHILE_239_C(BOOST_PP_BOOL(p(240, s)), p, o, s)
#define BOOST_PP_WHILE_240(p,o,s) BOOST_PP_WHILE_240_C(BOOST_PP_BOOL(p(241, s)), p, o, s)
#define BOOST_PP_WHILE_241(p,o,s) BOOST_PP_WHILE_241_C(BOOST_PP_BOOL(p(242, s)), p, o, s)
#define BOOST_PP_WHILE_242(p,o,s) BOOST_PP_WHILE_242_C(BOOST_PP_BOOL(p(243, s)), p, o, s)
#define BOOST_PP_WHILE_243(p,o,s) BOOST_PP_WHILE_243_C(BOOST_PP_BOOL(p(244, s)), p, o, s)
#define BOOST_PP_WHILE_244(p,o,s) BOOST_PP_WHILE_244_C(BOOST_PP_BOOL(p(245, s)), p, o, s)
#define BOOST_PP_WHILE_245(p,o,s) BOOST_PP_WHILE_245_C(BOOST_PP_BOOL(p(246, s)), p, o, s)
#define BOOST_PP_WHILE_246(p,o,s) BOOST_PP_WHILE_246_C(BOOST_PP_BOOL(p(247, s)), p, o, s)
#define BOOST_PP_WHILE_247(p,o,s) BOOST_PP_WHILE_247_C(BOOST_PP_BOOL(p(248, s)), p, o, s)
#define BOOST_PP_WHILE_248(p,o,s) BOOST_PP_WHILE_248_C(BOOST_PP_BOOL(p(249, s)), p, o, s)
#define BOOST_PP_WHILE_249(p,o,s) BOOST_PP_WHILE_249_C(BOOST_PP_BOOL(p(250, s)), p, o, s)
#define BOOST_PP_WHILE_250(p,o,s) BOOST_PP_WHILE_250_C(BOOST_PP_BOOL(p(251, s)), p, o, s)
#define BOOST_PP_WHILE_251(p,o,s) BOOST_PP_WHILE_251_C(BOOST_PP_BOOL(p(252, s)), p, o, s)
#define BOOST_PP_WHILE_252(p,o,s) BOOST_PP_WHILE_252_C(BOOST_PP_BOOL(p(253, s)), p, o, s)
#define BOOST_PP_WHILE_253(p,o,s) BOOST_PP_WHILE_253_C(BOOST_PP_BOOL(p(254, s)), p, o, s)
#define BOOST_PP_WHILE_254(p,o,s) BOOST_PP_WHILE_254_C(BOOST_PP_BOOL(p(255, s)), p, o, s)
#define BOOST_PP_WHILE_255(p,o,s) BOOST_PP_WHILE_255_C(BOOST_PP_BOOL(p(256, s)), p, o, s)
#define BOOST_PP_WHILE_256(p,o,s) BOOST_PP_WHILE_256_C(BOOST_PP_BOOL(p(257, s)), p, o, s)
#define BOOST_PP_WHILE_1_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_2, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(2, s))
#define BOOST_PP_WHILE_2_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_3, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(3, s))
#define BOOST_PP_WHILE_3_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_4, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(4, s))
#define BOOST_PP_WHILE_4_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_5, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(5, s))
#define BOOST_PP_WHILE_5_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_6, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(6, s))
#define BOOST_PP_WHILE_6_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_7, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(7, s))
#define BOOST_PP_WHILE_7_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_8, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(8, s))
#define BOOST_PP_WHILE_8_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_9, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(9, s))
#define BOOST_PP_WHILE_9_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_10, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(10, s))
#define BOOST_PP_WHILE_10_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_11, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(11, s))
#define BOOST_PP_WHILE_11_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_12, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(12, s))
#define BOOST_PP_WHILE_12_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_13, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(13, s))
#define BOOST_PP_WHILE_13_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_14, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(14, s))
#define BOOST_PP_WHILE_14_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_15, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(15, s))
#define BOOST_PP_WHILE_15_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_16, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(16, s))
#define BOOST_PP_WHILE_16_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_17, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(17, s))
#define BOOST_PP_WHILE_17_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_18, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(18, s))
#define BOOST_PP_WHILE_18_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_19, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(19, s))
#define BOOST_PP_WHILE_19_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_20, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(20, s))
#define BOOST_PP_WHILE_20_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_21, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(21, s))
#define BOOST_PP_WHILE_21_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_22, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(22, s))
#define BOOST_PP_WHILE_22_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_23, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(23, s))
#define BOOST_PP_WHILE_23_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_24, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(24, s))
#define BOOST_PP_WHILE_24_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_25, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(25, s))
#define BOOST_PP_WHILE_25_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_26, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(26, s))
#define BOOST_PP_WHILE_26_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_27, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(27, s))
#define BOOST_PP_WHILE_27_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_28, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(28, s))
#define BOOST_PP_WHILE_28_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_29, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(29, s))
#define BOOST_PP_WHILE_29_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_30, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(30, s))
#define BOOST_PP_WHILE_30_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_31, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(31, s))
#define BOOST_PP_WHILE_31_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_32, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(32, s))
#define BOOST_PP_WHILE_32_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_33, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(33, s))
#define BOOST_PP_WHILE_33_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_34, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(34, s))
#define BOOST_PP_WHILE_34_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_35, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(35, s))
#define BOOST_PP_WHILE_35_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_36, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(36, s))
#define BOOST_PP_WHILE_36_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_37, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(37, s))
#define BOOST_PP_WHILE_37_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_38, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(38, s))
#define BOOST_PP_WHILE_38_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_39, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(39, s))
#define BOOST_PP_WHILE_39_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_40, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(40, s))
#define BOOST_PP_WHILE_40_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_41, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(41, s))
#define BOOST_PP_WHILE_41_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_42, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(42, s))
#define BOOST_PP_WHILE_42_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_43, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(43, s))
#define BOOST_PP_WHILE_43_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_44, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(44, s))
#define BOOST_PP_WHILE_44_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_45, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(45, s))
#define BOOST_PP_WHILE_45_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_46, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(46, s))
#define BOOST_PP_WHILE_46_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_47, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(47, s))
#define BOOST_PP_WHILE_47_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_48, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(48, s))
#define BOOST_PP_WHILE_48_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_49, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(49, s))
#define BOOST_PP_WHILE_49_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_50, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(50, s))
#define BOOST_PP_WHILE_50_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_51, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(51, s))
#define BOOST_PP_WHILE_51_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_52, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(52, s))
#define BOOST_PP_WHILE_52_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_53, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(53, s))
#define BOOST_PP_WHILE_53_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_54, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(54, s))
#define BOOST_PP_WHILE_54_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_55, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(55, s))
#define BOOST_PP_WHILE_55_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_56, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(56, s))
#define BOOST_PP_WHILE_56_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_57, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(57, s))
#define BOOST_PP_WHILE_57_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_58, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(58, s))
#define BOOST_PP_WHILE_58_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_59, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(59, s))
#define BOOST_PP_WHILE_59_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_60, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(60, s))
#define BOOST_PP_WHILE_60_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_61, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(61, s))
#define BOOST_PP_WHILE_61_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_62, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(62, s))
#define BOOST_PP_WHILE_62_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_63, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(63, s))
#define BOOST_PP_WHILE_63_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_64, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(64, s))
#define BOOST_PP_WHILE_64_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_65, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(65, s))
#define BOOST_PP_WHILE_65_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_66, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(66, s))
#define BOOST_PP_WHILE_66_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_67, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(67, s))
#define BOOST_PP_WHILE_67_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_68, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(68, s))
#define BOOST_PP_WHILE_68_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_69, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(69, s))
#define BOOST_PP_WHILE_69_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_70, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(70, s))
#define BOOST_PP_WHILE_70_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_71, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(71, s))
#define BOOST_PP_WHILE_71_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_72, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(72, s))
#define BOOST_PP_WHILE_72_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_73, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(73, s))
#define BOOST_PP_WHILE_73_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_74, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(74, s))
#define BOOST_PP_WHILE_74_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_75, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(75, s))
#define BOOST_PP_WHILE_75_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_76, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(76, s))
#define BOOST_PP_WHILE_76_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_77, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(77, s))
#define BOOST_PP_WHILE_77_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_78, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(78, s))
#define BOOST_PP_WHILE_78_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_79, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(79, s))
#define BOOST_PP_WHILE_79_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_80, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(80, s))
#define BOOST_PP_WHILE_80_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_81, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(81, s))
#define BOOST_PP_WHILE_81_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_82, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(82, s))
#define BOOST_PP_WHILE_82_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_83, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(83, s))
#define BOOST_PP_WHILE_83_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_84, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(84, s))
#define BOOST_PP_WHILE_84_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_85, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(85, s))
#define BOOST_PP_WHILE_85_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_86, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(86, s))
#define BOOST_PP_WHILE_86_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_87, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(87, s))
#define BOOST_PP_WHILE_87_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_88, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(88, s))
#define BOOST_PP_WHILE_88_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_89, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(89, s))
#define BOOST_PP_WHILE_89_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_90, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(90, s))
#define BOOST_PP_WHILE_90_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_91, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(91, s))
#define BOOST_PP_WHILE_91_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_92, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(92, s))
#define BOOST_PP_WHILE_92_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_93, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(93, s))
#define BOOST_PP_WHILE_93_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_94, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(94, s))
#define BOOST_PP_WHILE_94_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_95, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(95, s))
#define BOOST_PP_WHILE_95_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_96, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(96, s))
#define BOOST_PP_WHILE_96_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_97, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(97, s))
#define BOOST_PP_WHILE_97_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_98, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(98, s))
#define BOOST_PP_WHILE_98_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_99, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(99, s))
#define BOOST_PP_WHILE_99_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_100, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(100, s))
#define BOOST_PP_WHILE_100_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_101, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(101, s))
#define BOOST_PP_WHILE_101_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_102, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(102, s))
#define BOOST_PP_WHILE_102_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_103, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(103, s))
#define BOOST_PP_WHILE_103_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_104, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(104, s))
#define BOOST_PP_WHILE_104_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_105, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(105, s))
#define BOOST_PP_WHILE_105_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_106, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(106, s))
#define BOOST_PP_WHILE_106_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_107, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(107, s))
#define BOOST_PP_WHILE_107_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_108, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(108, s))
#define BOOST_PP_WHILE_108_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_109, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(109, s))
#define BOOST_PP_WHILE_109_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_110, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(110, s))
#define BOOST_PP_WHILE_110_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_111, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(111, s))
#define BOOST_PP_WHILE_111_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_112, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(112, s))
#define BOOST_PP_WHILE_112_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_113, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(113, s))
#define BOOST_PP_WHILE_113_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_114, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(114, s))
#define BOOST_PP_WHILE_114_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_115, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(115, s))
#define BOOST_PP_WHILE_115_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_116, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(116, s))
#define BOOST_PP_WHILE_116_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_117, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(117, s))
#define BOOST_PP_WHILE_117_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_118, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(118, s))
#define BOOST_PP_WHILE_118_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_119, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(119, s))
#define BOOST_PP_WHILE_119_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_120, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(120, s))
#define BOOST_PP_WHILE_120_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_121, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(121, s))
#define BOOST_PP_WHILE_121_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_122, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(122, s))
#define BOOST_PP_WHILE_122_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_123, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(123, s))
#define BOOST_PP_WHILE_123_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_124, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(124, s))
#define BOOST_PP_WHILE_124_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_125, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(125, s))
#define BOOST_PP_WHILE_125_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_126, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(126, s))
#define BOOST_PP_WHILE_126_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_127, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(127, s))
#define BOOST_PP_WHILE_127_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_128, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(128, s))
#define BOOST_PP_WHILE_128_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_129, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(129, s))
#define BOOST_PP_WHILE_129_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_130, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(130, s))
#define BOOST_PP_WHILE_130_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_131, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(131, s))
#define BOOST_PP_WHILE_131_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_132, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(132, s))
#define BOOST_PP_WHILE_132_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_133, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(133, s))
#define BOOST_PP_WHILE_133_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_134, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(134, s))
#define BOOST_PP_WHILE_134_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_135, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(135, s))
#define BOOST_PP_WHILE_135_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_136, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(136, s))
#define BOOST_PP_WHILE_136_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_137, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(137, s))
#define BOOST_PP_WHILE_137_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_138, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(138, s))
#define BOOST_PP_WHILE_138_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_139, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(139, s))
#define BOOST_PP_WHILE_139_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_140, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(140, s))
#define BOOST_PP_WHILE_140_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_141, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(141, s))
#define BOOST_PP_WHILE_141_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_142, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(142, s))
#define BOOST_PP_WHILE_142_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_143, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(143, s))
#define BOOST_PP_WHILE_143_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_144, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(144, s))
#define BOOST_PP_WHILE_144_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_145, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(145, s))
#define BOOST_PP_WHILE_145_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_146, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(146, s))
#define BOOST_PP_WHILE_146_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_147, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(147, s))
#define BOOST_PP_WHILE_147_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_148, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(148, s))
#define BOOST_PP_WHILE_148_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_149, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(149, s))
#define BOOST_PP_WHILE_149_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_150, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(150, s))
#define BOOST_PP_WHILE_150_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_151, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(151, s))
#define BOOST_PP_WHILE_151_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_152, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(152, s))
#define BOOST_PP_WHILE_152_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_153, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(153, s))
#define BOOST_PP_WHILE_153_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_154, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(154, s))
#define BOOST_PP_WHILE_154_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_155, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(155, s))
#define BOOST_PP_WHILE_155_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_156, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(156, s))
#define BOOST_PP_WHILE_156_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_157, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(157, s))
#define BOOST_PP_WHILE_157_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_158, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(158, s))
#define BOOST_PP_WHILE_158_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_159, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(159, s))
#define BOOST_PP_WHILE_159_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_160, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(160, s))
#define BOOST_PP_WHILE_160_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_161, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(161, s))
#define BOOST_PP_WHILE_161_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_162, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(162, s))
#define BOOST_PP_WHILE_162_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_163, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(163, s))
#define BOOST_PP_WHILE_163_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_164, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(164, s))
#define BOOST_PP_WHILE_164_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_165, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(165, s))
#define BOOST_PP_WHILE_165_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_166, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(166, s))
#define BOOST_PP_WHILE_166_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_167, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(167, s))
#define BOOST_PP_WHILE_167_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_168, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(168, s))
#define BOOST_PP_WHILE_168_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_169, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(169, s))
#define BOOST_PP_WHILE_169_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_170, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(170, s))
#define BOOST_PP_WHILE_170_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_171, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(171, s))
#define BOOST_PP_WHILE_171_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_172, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(172, s))
#define BOOST_PP_WHILE_172_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_173, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(173, s))
#define BOOST_PP_WHILE_173_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_174, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(174, s))
#define BOOST_PP_WHILE_174_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_175, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(175, s))
#define BOOST_PP_WHILE_175_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_176, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(176, s))
#define BOOST_PP_WHILE_176_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_177, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(177, s))
#define BOOST_PP_WHILE_177_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_178, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(178, s))
#define BOOST_PP_WHILE_178_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_179, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(179, s))
#define BOOST_PP_WHILE_179_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_180, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(180, s))
#define BOOST_PP_WHILE_180_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_181, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(181, s))
#define BOOST_PP_WHILE_181_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_182, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(182, s))
#define BOOST_PP_WHILE_182_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_183, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(183, s))
#define BOOST_PP_WHILE_183_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_184, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(184, s))
#define BOOST_PP_WHILE_184_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_185, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(185, s))
#define BOOST_PP_WHILE_185_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_186, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(186, s))
#define BOOST_PP_WHILE_186_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_187, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(187, s))
#define BOOST_PP_WHILE_187_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_188, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(188, s))
#define BOOST_PP_WHILE_188_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_189, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(189, s))
#define BOOST_PP_WHILE_189_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_190, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(190, s))
#define BOOST_PP_WHILE_190_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_191, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(191, s))
#define BOOST_PP_WHILE_191_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_192, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(192, s))
#define BOOST_PP_WHILE_192_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_193, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(193, s))
#define BOOST_PP_WHILE_193_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_194, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(194, s))
#define BOOST_PP_WHILE_194_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_195, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(195, s))
#define BOOST_PP_WHILE_195_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_196, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(196, s))
#define BOOST_PP_WHILE_196_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_197, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(197, s))
#define BOOST_PP_WHILE_197_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_198, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(198, s))
#define BOOST_PP_WHILE_198_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_199, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(199, s))
#define BOOST_PP_WHILE_199_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_200, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(200, s))
#define BOOST_PP_WHILE_200_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_201, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(201, s))
#define BOOST_PP_WHILE_201_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_202, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(202, s))
#define BOOST_PP_WHILE_202_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_203, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(203, s))
#define BOOST_PP_WHILE_203_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_204, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(204, s))
#define BOOST_PP_WHILE_204_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_205, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(205, s))
#define BOOST_PP_WHILE_205_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_206, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(206, s))
#define BOOST_PP_WHILE_206_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_207, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(207, s))
#define BOOST_PP_WHILE_207_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_208, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(208, s))
#define BOOST_PP_WHILE_208_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_209, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(209, s))
#define BOOST_PP_WHILE_209_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_210, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(210, s))
#define BOOST_PP_WHILE_210_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_211, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(211, s))
#define BOOST_PP_WHILE_211_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_212, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(212, s))
#define BOOST_PP_WHILE_212_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_213, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(213, s))
#define BOOST_PP_WHILE_213_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_214, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(214, s))
#define BOOST_PP_WHILE_214_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_215, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(215, s))
#define BOOST_PP_WHILE_215_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_216, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(216, s))
#define BOOST_PP_WHILE_216_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_217, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(217, s))
#define BOOST_PP_WHILE_217_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_218, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(218, s))
#define BOOST_PP_WHILE_218_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_219, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(219, s))
#define BOOST_PP_WHILE_219_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_220, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(220, s))
#define BOOST_PP_WHILE_220_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_221, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(221, s))
#define BOOST_PP_WHILE_221_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_222, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(222, s))
#define BOOST_PP_WHILE_222_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_223, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(223, s))
#define BOOST_PP_WHILE_223_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_224, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(224, s))
#define BOOST_PP_WHILE_224_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_225, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(225, s))
#define BOOST_PP_WHILE_225_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_226, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(226, s))
#define BOOST_PP_WHILE_226_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_227, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(227, s))
#define BOOST_PP_WHILE_227_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_228, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(228, s))
#define BOOST_PP_WHILE_228_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_229, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(229, s))
#define BOOST_PP_WHILE_229_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_230, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(230, s))
#define BOOST_PP_WHILE_230_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_231, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(231, s))
#define BOOST_PP_WHILE_231_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_232, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(232, s))
#define BOOST_PP_WHILE_232_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_233, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(233, s))
#define BOOST_PP_WHILE_233_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_234, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(234, s))
#define BOOST_PP_WHILE_234_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_235, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(235, s))
#define BOOST_PP_WHILE_235_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_236, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(236, s))
#define BOOST_PP_WHILE_236_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_237, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(237, s))
#define BOOST_PP_WHILE_237_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_238, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(238, s))
#define BOOST_PP_WHILE_238_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_239, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(239, s))
#define BOOST_PP_WHILE_239_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_240, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(240, s))
#define BOOST_PP_WHILE_240_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_241, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(241, s))
#define BOOST_PP_WHILE_241_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_242, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(242, s))
#define BOOST_PP_WHILE_242_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_243, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(243, s))
#define BOOST_PP_WHILE_243_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_244, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(244, s))
#define BOOST_PP_WHILE_244_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_245, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(245, s))
#define BOOST_PP_WHILE_245_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_246, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(246, s))
#define BOOST_PP_WHILE_246_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_247, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(247, s))
#define BOOST_PP_WHILE_247_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_248, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(248, s))
#define BOOST_PP_WHILE_248_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_249, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(249, s))
#define BOOST_PP_WHILE_249_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_250, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(250, s))
#define BOOST_PP_WHILE_250_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_251, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(251, s))
#define BOOST_PP_WHILE_251_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_252, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(252, s))
#define BOOST_PP_WHILE_252_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_253, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(253, s))
#define BOOST_PP_WHILE_253_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_254, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(254, s))
#define BOOST_PP_WHILE_254_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_255, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(255, s))
#define BOOST_PP_WHILE_255_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_256, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(256, s))
#define BOOST_PP_WHILE_256_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_257, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(257, s))
#define BOOST_PP_WHILE_257(p,o,s) BOOST_PP_ERROR(0x0001)
#define BOOST_PP_WHILE_CHECK_BOOST_PP_NIL 1
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_1(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_2(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_3(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_4(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_5(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_6(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_7(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_8(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_9(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_10(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_11(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_12(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_13(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_14(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_15(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_16(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_17(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_18(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_19(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_20(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_21(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_22(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_23(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_24(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_25(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_26(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_27(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_28(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_29(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_30(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_31(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_32(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_33(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_34(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_35(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_36(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_37(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_38(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_39(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_40(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_41(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_42(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_43(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_44(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_45(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_46(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_47(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_48(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_49(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_50(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_51(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_52(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_53(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_54(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_55(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_56(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_57(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_58(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_59(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_60(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_61(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_62(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_63(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_64(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_65(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_66(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_67(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_68(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_69(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_70(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_71(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_72(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_73(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_74(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_75(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_76(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_77(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_78(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_79(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_80(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_81(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_82(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_83(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_84(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_85(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_86(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_87(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_88(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_89(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_90(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_91(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_92(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_93(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_94(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_95(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_96(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_97(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_98(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_99(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_100(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_101(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_102(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_103(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_104(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_105(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_106(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_107(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_108(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_109(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_110(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_111(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_112(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_113(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_114(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_115(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_116(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_117(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_118(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_119(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_120(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_121(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_122(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_123(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_124(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_125(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_126(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_127(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_128(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_129(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_130(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_131(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_132(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_133(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_134(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_135(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_136(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_137(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_138(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_139(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_140(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_141(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_142(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_143(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_144(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_145(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_146(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_147(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_148(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_149(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_150(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_151(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_152(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_153(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_154(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_155(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_156(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_157(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_158(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_159(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_160(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_161(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_162(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_163(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_164(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_165(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_166(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_167(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_168(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_169(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_170(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_171(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_172(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_173(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_174(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_175(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_176(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_177(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_178(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_179(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_180(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_181(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_182(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_183(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_184(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_185(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_186(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_187(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_188(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_189(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_190(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_191(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_192(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_193(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_194(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_195(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_196(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_197(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_198(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_199(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_200(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_201(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_202(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_203(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_204(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_205(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_206(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_207(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_208(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_209(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_210(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_211(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_212(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_213(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_214(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_215(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_216(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_217(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_218(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_219(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_220(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_221(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_222(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_223(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_224(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_225(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_226(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_227(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_228(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_229(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_230(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_231(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_232(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_233(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_234(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_235(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_236(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_237(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_238(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_239(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_240(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_241(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_242(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_243(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_244(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_245(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_246(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_247(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_248(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_249(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_250(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_251(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_252(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_253(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_254(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_255(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_256(p,o,s) 0
#define BOOST_PREPROCESSOR_TUPLE_ELEM_HPP
#define BOOST_PREPROCESSOR_FACILITIES_OVERLOAD_HPP
#define BOOST_PREPROCESSOR_VARIADIC_SIZE_HPP
#define BOOST_PP_VARIADIC_SIZE(...) BOOST_PP_VARIADIC_SIZE_I(__VA_ARGS__, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,)
#define BOOST_PP_VARIADIC_SIZE_I(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62,e63,size,...) size
#define BOOST_PP_OVERLOAD(prefix,...) BOOST_PP_CAT(prefix, BOOST_PP_VARIADIC_SIZE(__VA_ARGS__))
#define BOOST_PREPROCESSOR_TUPLE_REM_HPP
#define BOOST_PP_REM(...) __VA_ARGS__
#define BOOST_PP_TUPLE_REM(size) BOOST_PP_REM
#define BOOST_PP_TUPLE_REM_0()
#define BOOST_PP_TUPLE_REM_1(e0) e0
#define BOOST_PP_TUPLE_REM_2(e0,e1) e0, e1
#define BOOST_PP_TUPLE_REM_3(e0,e1,e2) e0, e1, e2
#define BOOST_PP_TUPLE_REM_4(e0,e1,e2,e3) e0, e1, e2, e3
#define BOOST_PP_TUPLE_REM_5(e0,e1,e2,e3,e4) e0, e1, e2, e3, e4
#define BOOST_PP_TUPLE_REM_6(e0,e1,e2,e3,e4,e5) e0, e1, e2, e3, e4, e5
#define BOOST_PP_TUPLE_REM_7(e0,e1,e2,e3,e4,e5,e6) e0, e1, e2, e3, e4, e5, e6
#define BOOST_PP_TUPLE_REM_8(e0,e1,e2,e3,e4,e5,e6,e7) e0, e1, e2, e3, e4, e5, e6, e7
#define BOOST_PP_TUPLE_REM_9(e0,e1,e2,e3,e4,e5,e6,e7,e8) e0, e1, e2, e3, e4, e5, e6, e7, e8
#define BOOST_PP_TUPLE_REM_10(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9
#define BOOST_PP_TUPLE_REM_11(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10
#define BOOST_PP_TUPLE_REM_12(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11
#define BOOST_PP_TUPLE_REM_13(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12
#define BOOST_PP_TUPLE_REM_14(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13
#define BOOST_PP_TUPLE_REM_15(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14
#define BOOST_PP_TUPLE_REM_16(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15
#define BOOST_PP_TUPLE_REM_17(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16
#define BOOST_PP_TUPLE_REM_18(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17
#define BOOST_PP_TUPLE_REM_19(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18
#define BOOST_PP_TUPLE_REM_20(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19
#define BOOST_PP_TUPLE_REM_21(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20
#define BOOST_PP_TUPLE_REM_22(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21
#define BOOST_PP_TUPLE_REM_23(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22
#define BOOST_PP_TUPLE_REM_24(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23
#define BOOST_PP_TUPLE_REM_25(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24
#define BOOST_PP_TUPLE_REM_26(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25
#define BOOST_PP_TUPLE_REM_27(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26
#define BOOST_PP_TUPLE_REM_28(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27
#define BOOST_PP_TUPLE_REM_29(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28
#define BOOST_PP_TUPLE_REM_30(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29
#define BOOST_PP_TUPLE_REM_31(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30
#define BOOST_PP_TUPLE_REM_32(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31
#define BOOST_PP_TUPLE_REM_33(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32
#define BOOST_PP_TUPLE_REM_34(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33
#define BOOST_PP_TUPLE_REM_35(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34
#define BOOST_PP_TUPLE_REM_36(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35
#define BOOST_PP_TUPLE_REM_37(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36
#define BOOST_PP_TUPLE_REM_38(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37
#define BOOST_PP_TUPLE_REM_39(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38
#define BOOST_PP_TUPLE_REM_40(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39
#define BOOST_PP_TUPLE_REM_41(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40
#define BOOST_PP_TUPLE_REM_42(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41
#define BOOST_PP_TUPLE_REM_43(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42
#define BOOST_PP_TUPLE_REM_44(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43
#define BOOST_PP_TUPLE_REM_45(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44
#define BOOST_PP_TUPLE_REM_46(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45
#define BOOST_PP_TUPLE_REM_47(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46
#define BOOST_PP_TUPLE_REM_48(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47
#define BOOST_PP_TUPLE_REM_49(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48
#define BOOST_PP_TUPLE_REM_50(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49
#define BOOST_PP_TUPLE_REM_51(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50
#define BOOST_PP_TUPLE_REM_52(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51
#define BOOST_PP_TUPLE_REM_53(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52
#define BOOST_PP_TUPLE_REM_54(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53
#define BOOST_PP_TUPLE_REM_55(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54
#define BOOST_PP_TUPLE_REM_56(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55
#define BOOST_PP_TUPLE_REM_57(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56
#define BOOST_PP_TUPLE_REM_58(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57
#define BOOST_PP_TUPLE_REM_59(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58
#define BOOST_PP_TUPLE_REM_60(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59
#define BOOST_PP_TUPLE_REM_61(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60
#define BOOST_PP_TUPLE_REM_62(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61
#define BOOST_PP_TUPLE_REM_63(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62
#define BOOST_PP_TUPLE_REM_64(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62,e63) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63
#define BOOST_PP_TUPLE_REM_CTOR(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_REM_CTOR_O_, __VA_ARGS__)(__VA_ARGS__)
#define BOOST_PP_TUPLE_REM_CTOR_O_1(tuple) BOOST_PP_REM tuple
#define BOOST_PP_TUPLE_REM_CTOR_O_2(size,tuple) BOOST_PP_TUPLE_REM_CTOR_O_1(tuple)
#define BOOST_PREPROCESSOR_VARIADIC_ELEM_HPP
#define BOOST_PP_VARIADIC_ELEM(n,...) BOOST_PP_CAT(BOOST_PP_VARIADIC_ELEM_, n)(__VA_ARGS__,)
#define BOOST_PP_VARIADIC_ELEM_0(e0,...) e0
#define BOOST_PP_VARIADIC_ELEM_1(e0,e1,...) e1
#define BOOST_PP_VARIADIC_ELEM_2(e0,e1,e2,...) e2
#define BOOST_PP_VARIADIC_ELEM_3(e0,e1,e2,e3,...) e3
#define BOOST_PP_VARIADIC_ELEM_4(e0,e1,e2,e3,e4,...) e4
#define BOOST_PP_VARIADIC_ELEM_5(e0,e1,e2,e3,e4,e5,...) e5
#define BOOST_PP_VARIADIC_ELEM_6(e0,e1,e2,e3,e4,e5,e6,...) e6
#define BOOST_PP_VARIADIC_ELEM_7(e0,e1,e2,e3,e4,e5,e6,e7,...) e7
#define BOOST_PP_VARIADIC_ELEM_8(e0,e1,e2,e3,e4,e5,e6,e7,e8,...) e8
#define BOOST_PP_VARIADIC_ELEM_9(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,...) e9
#define BOOST_PP_VARIADIC_ELEM_10(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,...) e10
#define BOOST_PP_VARIADIC_ELEM_11(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,...) e11
#define BOOST_PP_VARIADIC_ELEM_12(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,...) e12
#define BOOST_PP_VARIADIC_ELEM_13(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,...) e13
#define BOOST_PP_VARIADIC_ELEM_14(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,...) e14
#define BOOST_PP_VARIADIC_ELEM_15(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,...) e15
#define BOOST_PP_VARIADIC_ELEM_16(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,...) e16
#define BOOST_PP_VARIADIC_ELEM_17(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,...) e17
#define BOOST_PP_VARIADIC_ELEM_18(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,...) e18
#define BOOST_PP_VARIADIC_ELEM_19(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,...) e19
#define BOOST_PP_VARIADIC_ELEM_20(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,...) e20
#define BOOST_PP_VARIADIC_ELEM_21(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,...) e21
#define BOOST_PP_VARIADIC_ELEM_22(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,...) e22
#define BOOST_PP_VARIADIC_ELEM_23(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,...) e23
#define BOOST_PP_VARIADIC_ELEM_24(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,...) e24
#define BOOST_PP_VARIADIC_ELEM_25(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,...) e25
#define BOOST_PP_VARIADIC_ELEM_26(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,...) e26
#define BOOST_PP_VARIADIC_ELEM_27(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,...) e27
#define BOOST_PP_VARIADIC_ELEM_28(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,...) e28
#define BOOST_PP_VARIADIC_ELEM_29(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,...) e29
#define BOOST_PP_VARIADIC_ELEM_30(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,...) e30
#define BOOST_PP_VARIADIC_ELEM_31(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,...) e31
#define BOOST_PP_VARIADIC_ELEM_32(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,...) e32
#define BOOST_PP_VARIADIC_ELEM_33(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,...) e33
#define BOOST_PP_VARIADIC_ELEM_34(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,...) e34
#define BOOST_PP_VARIADIC_ELEM_35(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,...) e35
#define BOOST_PP_VARIADIC_ELEM_36(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,...) e36
#define BOOST_PP_VARIADIC_ELEM_37(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,...) e37
#define BOOST_PP_VARIADIC_ELEM_38(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,...) e38
#define BOOST_PP_VARIADIC_ELEM_39(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,...) e39
#define BOOST_PP_VARIADIC_ELEM_40(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,...) e40
#define BOOST_PP_VARIADIC_ELEM_41(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,...) e41
#define BOOST_PP_VARIADIC_ELEM_42(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,...) e42
#define BOOST_PP_VARIADIC_ELEM_43(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,...) e43
#define BOOST_PP_VARIADIC_ELEM_44(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,...) e44
#define BOOST_PP_VARIADIC_ELEM_45(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,...) e45
#define BOOST_PP_VARIADIC_ELEM_46(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,...) e46
#define BOOST_PP_VARIADIC_ELEM_47(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,...) e47
#define BOOST_PP_VARIADIC_ELEM_48(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,...) e48
#define BOOST_PP_VARIADIC_ELEM_49(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,...) e49
#define BOOST_PP_VARIADIC_ELEM_50(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,...) e50
#define BOOST_PP_VARIADIC_ELEM_51(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,...) e51
#define BOOST_PP_VARIADIC_ELEM_52(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,...) e52
#define BOOST_PP_VARIADIC_ELEM_53(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,...) e53
#define BOOST_PP_VARIADIC_ELEM_54(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,...) e54
#define BOOST_PP_VARIADIC_ELEM_55(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,...) e55
#define BOOST_PP_VARIADIC_ELEM_56(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,...) e56
#define BOOST_PP_VARIADIC_ELEM_57(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,...) e57
#define BOOST_PP_VARIADIC_ELEM_58(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,...) e58
#define BOOST_PP_VARIADIC_ELEM_59(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,...) e59
#define BOOST_PP_VARIADIC_ELEM_60(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,...) e60
#define BOOST_PP_VARIADIC_ELEM_61(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,...) e61
#define BOOST_PP_VARIADIC_ELEM_62(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62,...) e62
#define BOOST_PP_VARIADIC_ELEM_63(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62,e63,...) e63
#define BOOST_PP_TUPLE_ELEM(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_ELEM_O_, __VA_ARGS__)(__VA_ARGS__)
#define BOOST_PP_TUPLE_ELEM_O_2(n,tuple) BOOST_PP_VARIADIC_ELEM(n, BOOST_PP_REM tuple)
#define BOOST_PP_TUPLE_ELEM_O_3(size,n,tuple) BOOST_PP_TUPLE_ELEM_O_2(n, tuple)
#define BOOST_PP_TUPLE_ELEM_1_0(a) a
#define BOOST_PP_TUPLE_ELEM_2_0(a,b) a
#define BOOST_PP_TUPLE_ELEM_2_1(a,b) b
#define BOOST_PP_TUPLE_ELEM_3_0(a,b,c) a
#define BOOST_PP_TUPLE_ELEM_3_1(a,b,c) b
#define BOOST_PP_TUPLE_ELEM_3_2(a,b,c) c
#define BOOST_PP_ADD(x,y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_ADD_P, BOOST_PP_ADD_O, (x, y)))
#define BOOST_PP_ADD_P(d,xy) BOOST_PP_TUPLE_ELEM(2, 1, xy)
#define BOOST_PP_ADD_O(d,xy) BOOST_PP_ADD_O_I xy
#define BOOST_PP_ADD_O_I(x,y) (BOOST_PP_INC(x), BOOST_PP_DEC(y))
#define BOOST_PP_ADD_D(d,x,y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_ADD_P, BOOST_PP_ADD_O, (x, y)))
#define BOOST_PREPROCESSOR_ARITHMETIC_SUB_HPP
#define BOOST_PP_SUB(x,y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_SUB_P, BOOST_PP_SUB_O, (x, y)))
#define BOOST_PP_SUB_P(d,xy) BOOST_PP_TUPLE_ELEM(2, 1, xy)
#define BOOST_PP_SUB_O(d,xy) BOOST_PP_SUB_O_I xy
#define BOOST_PP_SUB_O_I(x,y) (BOOST_PP_DEC(x), BOOST_PP_DEC(y))
#define BOOST_PP_SUB_D(d,x,y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_SUB_P, BOOST_PP_SUB_O, (x, y)))
#define BOOST_MPL_PP_AUX_TAIL_PARAM_FUNC(unused,i,op) , BOOST_PP_CAT( BOOST_PP_TUPLE_ELEM(3, 1, op) , BOOST_PP_ADD_D(1, i, BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(3, 0, op))) ) BOOST_PP_TUPLE_ELEM(3, 2, op)()
#define BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i,param,value_func) BOOST_PP_REPEAT( BOOST_PP_SUB_D(1, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, i) , BOOST_MPL_PP_AUX_TAIL_PARAM_FUNC , (i, param, value_func) )
#define BOOST_MPL_PP_DEF_PARAMS_TAIL(i,param,value) BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, BOOST_PP_IDENTITY(=value))
#define BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(i,param,value) BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, BOOST_PP_IDENTITY(=value))
#define BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED
#define BOOST_MPL_AUX_NA_PARAMS(i) BOOST_MPL_PP_ENUM(i, na)
#define BOOST_MPL_AUX_NA_SPEC_ARITY(i,name)
#define BOOST_MPL_AUX_NA_SPEC_MAIN(i,name) template<> struct name< BOOST_MPL_AUX_NA_PARAMS(i) > { template< BOOST_MPL_PP_PARAMS(i, typename T) BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(i, typename T, na) > struct apply : name< BOOST_MPL_PP_PARAMS(i, T) > { }; };
#define BOOST_MPL_AUX_NA_SPEC_LAMBDA(i,name) template< typename Tag > struct lambda< name< BOOST_MPL_AUX_NA_PARAMS(i) > , Tag BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(int_<-1>) > { typedef false_ is_le; typedef name< BOOST_MPL_AUX_NA_PARAMS(i) > result_; typedef name< BOOST_MPL_AUX_NA_PARAMS(i) > type; };
#define BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i,j,name) namespace aux { template< BOOST_MPL_PP_PARAMS(j, typename T) > struct template_arity< name< BOOST_MPL_PP_PARAMS(j, T) > > : int_<j> { }; template<> struct template_arity< name< BOOST_MPL_PP_ENUM(i, na) > > : int_<-1> { }; }
#define BOOST_MPL_AUX_NA_SPEC_ETI(i,name)
#define BOOST_MPL_AUX_NA_PARAM(param) param = na
#define BOOST_MPL_AUX_NA_SPEC_NO_ETI(i,name) BOOST_MPL_AUX_NA_SPEC_MAIN(i, name) BOOST_MPL_AUX_NA_SPEC_LAMBDA(i, name) BOOST_MPL_AUX_NA_SPEC_ARITY(i, name) BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i, i, name)
#define BOOST_MPL_AUX_NA_SPEC(i,name) BOOST_MPL_AUX_NA_SPEC_NO_ETI(i, name) BOOST_MPL_AUX_NA_SPEC_ETI(i, name)
#define BOOST_MPL_AUX_NA_SPEC2(i,j,name) BOOST_MPL_AUX_NA_SPEC_MAIN(i, name) BOOST_MPL_AUX_NA_SPEC_ETI(i, name) BOOST_MPL_AUX_NA_SPEC_LAMBDA(i, name) BOOST_MPL_AUX_NA_SPEC_ARITY(i, name) BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i, j, name)
#define BOOST_MPL_AUX_LAMBDA_SUPPORT_HPP_INCLUDED
#define BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i,name,params)
#define BOOST_MPL_AUX_LAMBDA_SUPPORT(i,name,params)
namespace boost { namespace mpl {
template<
bool C
, typename T1
, typename T2
>
struct if_c
{
typedef T1 type;
};
template<
typename T1
, typename T2
>
struct if_c<false,T1,T2>
{
typedef T2 type;
};
template<
typename T1 = na
, typename T2 = na
, typename T3 = na
>
struct if_
{
private:
typedef if_c<
static_cast<bool>(T1::value)
, T2
, T3
> almost_type_;
public:
typedef typename almost_type_::type type;
};
template<> struct if_< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : if_< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< if_< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef if_< na , na , na > result_; typedef if_< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< if_< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< if_< na , na , na > > : int_<-1> { }; }
}}
#define BOOST_TT_IS_BASE_OF_HPP_INCLUDED
#define BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED
#define BOOST_TT_INTRINSICS_HPP_INCLUDED
#define BOOST_TT_CONFIG_HPP_INCLUDED
#define BOOST_TT_DECL
#define BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION 1
#define BOOST_TT_IS_SAME_HPP_INCLUDED
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TYPE_TRAITS_INTEGRAL_CONSTANT_HPP
#define BOOST_MPL_INTEGRAL_C_HPP_INCLUDED
#define BOOST_MPL_INTEGRAL_C_FWD_HPP_INCLUDED
namespace mpl_ {
template< typename T, T N > struct integral_c;
}
namespace boost { namespace mpl { using ::mpl_::integral_c; } }
#define AUX_WRAPPER_PARAMS(N) typename T, T N
#define AUX_WRAPPER_NAME integral_c
#define AUX_WRAPPER_VALUE_TYPE T
#define AUX_WRAPPER_INST(value) AUX_WRAPPER_NAME< T, value >
namespace mpl_ {
template< typename T, T N >
struct integral_c
{
static const T value = N;
typedef integral_c type;
typedef T value_type;
typedef integral_c_tag tag;
typedef integral_c< T, static_cast<T>((value + 1)) > next;
typedef integral_c< T, static_cast<T>((value - 1)) > prior;
operator T() const ;
};
template< typename T, T N >
T const integral_c< T, N >::value;
}
#undef AUX_WRAPPER_NAME
#undef AUX_WRAPPER_PARAMS
#undef AUX_WRAPPER_INST
#undef AUX_WRAPPER_VALUE_TYPE
namespace mpl_ {
template< bool C >
struct integral_c<bool, C>
{
static const bool value = C;
typedef integral_c_tag tag;
typedef integral_c type;
typedef bool value_type;
operator bool() const ;
};
}
namespace boost{
template <class T, T val>
struct integral_constant : public mpl::integral_c<T, val>
{
typedef integral_constant<T,val> type;
};
template<> struct integral_constant<bool,true> : public mpl::true_
{
typedef integral_constant<bool,true> type;
};
template<> struct integral_constant<bool,false> : public mpl::false_
{
typedef integral_constant<bool,false> type;
};
typedef integral_constant<bool,true> true_type;
typedef integral_constant<bool,false> false_type;
}
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
template< typename T, typename U > struct is_same : public ::boost::integral_constant<bool,false> { public: };
template< typename T > struct is_same< T,T > : public ::boost::integral_constant<bool,true> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
#define BOOST_TT_IS_REFERENCE_HPP_INCLUDED
#define BOOST_TT_IS_LVALUE_REFERENCE_HPP_INCLUDED
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
template< typename T > struct is_lvalue_reference : public ::boost::integral_constant<bool,false> { public: };
template< typename T > struct is_lvalue_reference< T& > : public ::boost::integral_constant<bool,true> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
#define BOOST_TT_IS_RVALUE_REFERENCE_HPP_INCLUDED
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
template< typename T > struct is_rvalue_reference : public ::boost::integral_constant<bool,false> { public: };
template< typename T > struct is_rvalue_reference< T&& > : public ::boost::integral_constant<bool,true> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
#define BOOST_TT_ICE_HPP_INCLUDED
#define BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED
namespace boost {
namespace type_traits {
typedef char yes_type;
struct no_type
{
char padding[8];
};
}
}
#define BOOST_TT_DETAIL_ICE_OR_HPP_INCLUDED
namespace boost {
namespace type_traits {
template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false>
struct ice_or;
template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
struct ice_or
{
static const bool value = true;
};
template <>
struct ice_or<false, false, false, false, false, false, false>
{
static const bool value = false;
};
}
}
#define BOOST_TT_DETAIL_ICE_AND_HPP_INCLUDED
namespace boost {
namespace type_traits {
template <bool b1, bool b2, bool b3 = true, bool b4 = true, bool b5 = true, bool b6 = true, bool b7 = true>
struct ice_and;
template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
struct ice_and
{
static const bool value = false;
};
template <>
struct ice_and<true, true, true, true, true, true, true>
{
static const bool value = true;
};
}
}
#define BOOST_TT_DETAIL_ICE_NOT_HPP_INCLUDED
namespace boost {
namespace type_traits {
template <bool b>
struct ice_not
{
static const bool value = true;
};
template <>
struct ice_not<true>
{
static const bool value = false;
};
}
}
#define BOOST_TT_DETAIL_ICE_EQ_HPP_INCLUDED
namespace boost {
namespace type_traits {
template <int b1, int b2>
struct ice_eq
{
static const bool value = (b1 == b2);
};
template <int b1, int b2>
struct ice_ne
{
static const bool value = (b1 != b2);
};
template <int b1, int b2> bool const ice_eq<b1,b2>::value;
template <int b1, int b2> bool const ice_ne<b1,b2>::value;
}
}
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
namespace detail {
template <typename T>
struct is_reference_impl
{
static const bool value = (::boost::type_traits::ice_or< ::boost::is_lvalue_reference<T>::value, ::boost::is_rvalue_reference<T>::value >::value);
};
}
template< typename T > struct is_reference : public ::boost::integral_constant<bool,::boost::detail::is_reference_impl<T>::value> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
#define BOOST_TT_IS_VOLATILE_HPP_INCLUDED
#define BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED
namespace boost {
namespace detail {
template <typename T> struct cv_traits_imp {};
template <typename T>
struct cv_traits_imp<T*>
{
static const bool is_const = false;
static const bool is_volatile = false;
typedef T unqualified_type;
};
template <typename T>
struct cv_traits_imp<const T*>
{
static const bool is_const = true;
static const bool is_volatile = false;
typedef T unqualified_type;
};
template <typename T>
struct cv_traits_imp<volatile T*>
{
static const bool is_const = false;
static const bool is_volatile = true;
typedef T unqualified_type;
};
template <typename T>
struct cv_traits_imp<const volatile T*>
{
static const bool is_const = true;
static const bool is_volatile = true;
typedef T unqualified_type;
};
}
}
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
namespace detail{
template <class T>
struct is_volatile_rval_filter
{
static const bool value = ::boost::detail::cv_traits_imp<T*>::is_volatile;
};
template <class T>
struct is_volatile_rval_filter<T&&>
{
static const bool value = false;
};
}
template< typename T > struct is_volatile : public ::boost::integral_constant<bool,::boost::detail::is_volatile_rval_filter<T>::value> { public: };
template< typename T > struct is_volatile< T& > : public ::boost::integral_constant<bool,false> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
#define BOOST_INTEL_TT_OPTS
#define BOOST_IS_UNION(T) __is_union(T)
#define BOOST_IS_POD(T) __is_pod(T)
#define BOOST_IS_EMPTY(T) __is_empty(T)
#define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) ((__has_trivial_constructor(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile<T>::value)
#define BOOST_HAS_TRIVIAL_COPY(T) ((__has_trivial_copy(T) BOOST_INTEL_TT_OPTS) && !is_reference<T>::value && ! ::boost::is_volatile<T>::value)
#define BOOST_HAS_TRIVIAL_ASSIGN(T) ((__has_trivial_assign(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile<T>::value && ! ::boost::is_const<T>::value)
#define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) BOOST_INTEL_TT_OPTS)
#define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) BOOST_INTEL_TT_OPTS)
#define BOOST_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) BOOST_INTEL_TT_OPTS) && !is_volatile<T>::value && !is_reference<T>::value)
#define BOOST_HAS_NOTHROW_ASSIGN(T) ((__has_nothrow_assign(T) BOOST_INTEL_TT_OPTS) && !is_volatile<T>::value && !is_const<T>::value)
#define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T)
#define BOOST_IS_ABSTRACT(T) __is_abstract(T)
#define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same<T,U>::value)
#define BOOST_IS_CLASS(T) __is_class(T)
#define BOOST_IS_ENUM(T) __is_enum(T)
#define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T)
#define BOOST_ALIGNMENT_OF(T) __alignof__(T)
#define BOOST_HAS_TYPE_TRAITS_INTRINSICS
#define BOOST_TT_REMOVE_CV_HPP_INCLUDED
#define BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED
#define BOOST_TT_BROKEN_COMPILER_SPEC(T)
#define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(T) BOOST_TT_BROKEN_COMPILER_SPEC(T)
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) template< typename T > struct trait { public: typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) template<> struct trait<spec> { public: typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };
#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) template<> struct trait ##_impl<spec> { public: typedef result type; };
#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait<spec> { public: typedef result type; };
#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) template< param1, param2 > struct trait<spec> { public: typedef result; };
#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait ##_impl<spec> { public: typedef result type; };
namespace boost {
namespace detail{
template <class T>
struct rvalue_ref_filter_rem_cv
{
typedef typename boost::detail::cv_traits_imp<T*>::unqualified_type type;
};
template <class T>
struct rvalue_ref_filter_rem_cv<T&&>
{
typedef T&& type;
};
}
template< typename T > struct remove_cv { public: typedef typename boost::detail::rvalue_ref_filter_rem_cv<T>::type type; };
template< typename T > struct remove_cv<T&> { public: typedef T& type; };
template< typename T, std::size_t N > struct remove_cv<T const[N]> { public: typedef T type[N]; };
template< typename T, std::size_t N > struct remove_cv<T volatile[N]> { public: typedef T type[N]; };
template< typename T, std::size_t N > struct remove_cv<T const volatile[N]> { public: typedef T type[N]; };
}
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
namespace detail {
template <typename B, typename D>
struct is_base_and_derived_impl
{
typedef typename remove_cv<B>::type ncvB;
typedef typename remove_cv<D>::type ncvD;
static const bool value = ((__is_base_of(B,D) && !is_same<B,D>::value) && ! ::boost::is_same<ncvB,ncvD>::value);
};
}
template< typename Base, typename Derived > struct is_base_and_derived : public ::boost::integral_constant<bool,(::boost::detail::is_base_and_derived_impl<Base,Derived>::value)> { public: };
template< typename Base, typename Derived > struct is_base_and_derived< Base&,Derived > : public ::boost::integral_constant<bool,false> { public: };
template< typename Base, typename Derived > struct is_base_and_derived< Base,Derived& > : public ::boost::integral_constant<bool,false> { public: };
template< typename Base, typename Derived > struct is_base_and_derived< Base&,Derived& > : public ::boost::integral_constant<bool,false> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
#define BOOST_TT_IS_CLASS_HPP_INCLUDED
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
namespace detail {
template <typename T>
struct is_class_impl
{
static const bool value = __is_class(T);
};
}
template< typename T > struct is_class : public ::boost::integral_constant<bool,::boost::detail::is_class_impl<T>::value> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
namespace detail{
template <class B, class D>
struct is_base_of_imp
{
typedef typename remove_cv<B>::type ncvB;
typedef typename remove_cv<D>::type ncvD;
static const bool value = (::boost::type_traits::ice_or< (::boost::detail::is_base_and_derived_impl<ncvB,ncvD>::value), (::boost::type_traits::ice_and< ::boost::is_same<ncvB,ncvD>::value, ::boost::is_class<ncvB>::value>::value)>::value);
};
}
template< typename Base, typename Derived > struct is_base_of : public ::boost::integral_constant<bool,(::boost::detail::is_base_of_imp<Base, Derived>::value)> { public: };
template< typename Base, typename Derived > struct is_base_of< Base&,Derived > : public ::boost::integral_constant<bool,false> { public: };
template< typename Base, typename Derived > struct is_base_of< Base,Derived& > : public ::boost::integral_constant<bool,false> { public: };
template< typename Base, typename Derived > struct is_base_of< Base&,Derived& > : public ::boost::integral_constant<bool,false> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
namespace boost {
namespace CV {
enum violation_enum {min_violation, max_violation};
template<class value_policies>
class constrained_value {
public:
typedef typename value_policies::value_type value_type;
constrained_value(value_type value)
;
constrained_value& operator=(value_type v)
;
static value_type max () ;
static value_type min () ;
operator value_type() const ;
protected:
value_type value_;
private:
void assign(value_type value)
;
};
template<typename rep_type, rep_type min_value,
rep_type max_value, class exception_type>
class simple_exception_policy
{
struct exception_wrapper : public exception_type
{
operator std::out_of_range () const
;
};
typedef typename mpl::if_<
is_base_of< std::exception, exception_type >,
exception_type,
exception_wrapper
>::type actual_exception_type;
public:
typedef rep_type value_type;
static rep_type min () ;
static rep_type max () ;
static void on_error(rep_type, rep_type, violation_enum)
;
};
} }
#define DATE_TIME_DATE_DEFS_HPP
namespace boost {
namespace date_time {
enum weekdays {Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday};
enum months_of_year {Jan=1,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec,NotAMonth,NumMonths};
} }
namespace boost {
namespace gregorian {
using date_time::Sunday;
using date_time::Monday;
using date_time::Tuesday;
using date_time::Wednesday;
using date_time::Thursday;
using date_time::Friday;
using date_time::Saturday;
struct bad_weekday : public std::out_of_range
{
bad_weekday() ;
};
typedef CV::simple_exception_policy<unsigned short, 0, 6, bad_weekday> greg_weekday_policies;
typedef CV::constrained_value<greg_weekday_policies> greg_weekday_rep;
class greg_weekday : public greg_weekday_rep {
public:
typedef boost::date_time::weekdays weekday_enum;
greg_weekday(unsigned short day_of_week_num)
;
unsigned short as_number() const ;
const char* as_short_string() const;
const char* as_long_string() const;
const wchar_t* as_short_wstring() const;
const wchar_t* as_long_wstring() const;
weekday_enum as_enum() const ;
};
} }
#define GREG_DAY_OF_YEAR_HPP___
namespace boost {
namespace gregorian {
struct bad_day_of_year : public std::out_of_range
{
bad_day_of_year()
;
};
typedef CV::simple_exception_policy<unsigned short,1,366,bad_day_of_year> greg_day_of_year_policies;
typedef CV::constrained_value<greg_day_of_year_policies> greg_day_of_year_rep;
} }
#define DATE_TIME_GREGORIAN_CALENDAR_HPP__
namespace boost {
namespace date_time {
template<typename ymd_type_, typename date_int_type_>
class gregorian_calendar_base {
public:
typedef ymd_type_ ymd_type;
typedef typename ymd_type::month_type month_type;
typedef typename ymd_type::day_type day_type;
typedef typename ymd_type::year_type year_type;
typedef date_int_type_ date_int_type;
static unsigned short day_of_week(const ymd_type& ymd);
static int week_number(const ymd_type&ymd);
static date_int_type day_number(const ymd_type& ymd);
static date_int_type julian_day_number(const ymd_type& ymd);
static date_int_type modjulian_day_number(const ymd_type& ymd);
static ymd_type from_day_number(date_int_type);
static ymd_type from_julian_day_number(date_int_type);
static ymd_type from_modjulian_day_number(date_int_type);
static bool is_leap_year(year_type);
static unsigned short end_of_month_day(year_type y, month_type m);
static ymd_type epoch();
static unsigned short days_in_week();
};
} }
#undef BOOST_DATE_TIME_INLINE
#define BOOST_DATE_TIME_INLINE inline
namespace boost {
namespace date_time {
} }
#define DATE_TIME_GREG_YMD_HPP__
#define GREG_DAY_HPP___
namespace boost {
namespace gregorian {
struct bad_day_of_month : public std::out_of_range
{
bad_day_of_month()
;
bad_day_of_month(const std::string& s)
;
};
typedef CV::simple_exception_policy<unsigned short, 1, 31, bad_day_of_month> greg_day_policies;
typedef CV::constrained_value<greg_day_policies> greg_day_rep;
class greg_day : public greg_day_rep {
public:
greg_day(unsigned short day_of_month) ;
unsigned short as_number() const ;
operator unsigned short() const ;
private:
};
} }
#define GREG_YEAR_HPP___
namespace boost {
namespace gregorian {
struct bad_year : public std::out_of_range
{
bad_year()
;
};
typedef CV::simple_exception_policy<unsigned short, 1400, 10000, bad_year> greg_year_policies;
typedef CV::constrained_value<greg_year_policies> greg_year_rep;
class greg_year : public greg_year_rep {
public:
greg_year(unsigned short year) ;
operator unsigned short() const ;
private:
};
} }
#define GREG_MONTH_HPP___
#define _GLIBCXX_MAP 1
#define _STL_TREE_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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 _Val>
struct _Rb_tree_node : public _Rb_tree_node_base
{
typedef _Rb_tree_node<_Val>* _Link_type;
__gnu_cxx::__aligned_buffer<_Val> _M_storage;
_Val*
_M_valptr()
;
const _Val*
_M_valptr() const
;
};
__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(_Link_type __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(_Link_type __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(static_cast<typename iterator::_Link_type>
(const_cast<typename iterator::_Base_ptr>(_M_node))); }
reference
operator*() const noexcept
{ return *static_cast<_Link_type>(_M_node)->_M_valptr(); }
pointer
operator->() const noexcept
{ return static_cast<_Link_type>(_M_node)->_M_valptr(); }
_Self&
operator++() noexcept
{
_M_node = _Rb_tree_increment(_M_node);
return *this;
}
_Self
operator++(int) noexcept
{
_Self __tmp = *this;
_M_node = _Rb_tree_increment(_M_node);
return __tmp;
}
_Self&
operator--() noexcept
{
_M_node = _Rb_tree_decrement(_M_node);
return *this;
}
_Self
operator--(int) noexcept
{
_Self __tmp = *this;
_M_node = _Rb_tree_decrement(_M_node);
return __tmp;
}
bool
operator==(const _Self& __x) const noexcept
{ return _M_node == __x._M_node; }
bool
operator!=(const _Self& __x) const noexcept
{ return _M_node != __x._M_node; }
_Base_ptr _M_node;
};
template<typename _Val>
inline bool
operator==(const _Rb_tree_iterator<_Val>& __x,
const _Rb_tree_const_iterator<_Val>& __y) noexcept
{ return __x._M_node == __y._M_node; }
template<typename _Val>
inline bool
operator!=(const _Rb_tree_iterator<_Val>& __x,
const _Rb_tree_const_iterator<_Val>& __y) noexcept
{ return __x._M_node != __y._M_node; }
void
_Rb_tree_insert_and_rebalance(const bool __insert_left,
_Rb_tree_node_base* __x,
_Rb_tree_node_base* __p,
_Rb_tree_node_base& __header) throw ();
_Rb_tree_node_base*
_Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z,
_Rb_tree_node_base& __header) throw ();
template<typename _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(const _Rb_tree_node_base& __header,
_Rb_tree& __t)
;
_Reuse_or_alloc_node(const _Reuse_or_alloc_node&) = delete;
~_Reuse_or_alloc_node()
;
template<typename _Arg>
_Link_type
operator()(_Arg&& __arg)
;
private:
_Base_ptr
_M_extract()
;
_Base_ptr _M_root;
_Base_ptr _M_nodes;
_Rb_tree& _M_t;
};
struct _Alloc_node
{
_Alloc_node(_Rb_tree& __t) ;
template<typename _Arg>
_Link_type
operator()(_Arg&& __arg) const
;
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); }
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
{
_Key_compare _M_key_compare;
_Rb_tree_node_base _M_header;
size_type _M_node_count;
_Rb_tree_impl()
: _Node_allocator(), _M_key_compare(), _M_header(),
_M_node_count(0)
{ _M_initialize(); }
_Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a)
: _Node_allocator(__a), _M_key_compare(__comp), _M_header(),
_M_node_count(0)
{ _M_initialize(); }
_Rb_tree_impl(const _Key_compare& __comp, _Node_allocator&& __a)
: _Node_allocator(std::move(__a)), _M_key_compare(__comp),
_M_header(), _M_node_count(0)
{ _M_initialize(); }
void
_M_reset()
{
this->_M_header._M_parent = 0;
this->_M_header._M_left = &this->_M_header;
this->_M_header._M_right = &this->_M_header;
this->_M_node_count = 0;
}
private:
void
_M_initialize()
{
this->_M_header._M_color = _S_red;
this->_M_header._M_parent = 0;
this->_M_header._M_left = &this->_M_header;
this->_M_header._M_right = &this->_M_header;
}
};
_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);
}
_Link_type
_M_end() noexcept
{ return reinterpret_cast<_Link_type>(&this->_M_impl._M_header); }
_Const_Link_type
_M_end() const noexcept
{ return reinterpret_cast<_Const_Link_type>(&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;
private:
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);
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);
template<typename _NodeGen>
_Link_type
_M_copy(_Const_Link_type __x, _Link_type __p, _NodeGen&);
_Link_type
_M_copy(_Const_Link_type __x, _Link_type __p)
;
void
_M_erase(_Link_type __x);
iterator
_M_lower_bound(_Link_type __x, _Link_type __y,
const _Key& __k);
const_iterator
_M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
const _Key& __k) const;
iterator
_M_upper_bound(_Link_type __x, _Link_type __y,
const _Key& __k);
const_iterator
_M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
const _Key& __k) const;
public:
_Rb_tree() ;
_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._M_key_compare,
_Alloc_traits::_S_select_on_copy(__x._M_get_Node_allocator()))
{
if (__x._M_root() != 0)
{
_M_root() = _M_copy(__x._M_begin(), _M_end());
_M_leftmost() = _S_minimum(_M_root());
_M_rightmost() = _S_maximum(_M_root());
_M_impl._M_node_count = __x._M_impl._M_node_count;
}
}
_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._M_begin(), _M_end());
_M_leftmost() = _S_minimum(_M_root());
_M_rightmost() = _S_maximum(_M_root());
_M_impl._M_node_count = __x._M_impl._M_node_count;
}
}
_Rb_tree(_Rb_tree&& __x)
: _M_impl(__x._M_impl._M_key_compare, __x._M_get_Node_allocator())
{
if (__x._M_root() != 0)
_M_move_data(__x, std::true_type());
}
_Rb_tree(_Rb_tree&& __x, const allocator_type& __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
;
iterator
begin() noexcept
{
return iterator(static_cast<_Link_type>
(this->_M_impl._M_header._M_left));
}
const_iterator
begin() const noexcept
{
return const_iterator(static_cast<_Const_Link_type>
(this->_M_impl._M_header._M_left));
}
iterator
end() noexcept
{ return iterator(static_cast<_Link_type>(&this->_M_impl._M_header)); }
const_iterator
end() const noexcept
{
return const_iterator(static_cast<_Const_Link_type>
(&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(_Alloc_traits::_S_nothrow_swap());
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)
;
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)
;
template<typename... _Args>
pair<iterator, bool>
_M_emplace_unique(_Args&&... __args);
template<typename... _Args>
iterator
_M_emplace_equal(_Args&&... __args);
template<typename... _Args>
iterator
_M_emplace_hint_unique(const_iterator __pos, _Args&&... __args);
template<typename... _Args>
iterator
_M_emplace_hint_equal(const_iterator __pos, _Args&&... __args);
template<typename _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)
;
__attribute ((__abi_tag__ ("cxx11")))
iterator
erase(iterator __position)
;
size_type
erase(const key_type& __x);
__attribute ((__abi_tag__ ("cxx11")))
iterator
erase(const_iterator __first, const_iterator __last)
;
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)
;
const_iterator
lower_bound(const key_type& __k) const
;
iterator
upper_bound(const key_type& __k)
;
const_iterator
upper_bound(const key_type& __k) const
;
pair<iterator, iterator>
equal_range(const key_type& __k);
pair<const_iterator, const_iterator>
equal_range(const key_type& __k) const;
bool
__rb_verify() const;
_Rb_tree&
operator=(_Rb_tree&&) noexcept(_Alloc_traits::_S_nothrow_move());
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&, std::true_type);
void
_M_move_data(_Rb_tree&, std::false_type);
};
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
bool
operator==(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
bool
operator<(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
bool
operator!=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
bool
operator>(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
bool
operator<=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
bool
operator>=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
void
swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
;
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=(_Rb_tree&& __x)
noexcept(_Alloc_traits::_S_nothrow_move())
{
_M_impl._M_key_compare = __x._M_impl._M_key_compare;
if (_Alloc_traits::_S_propagate_on_move_assign()
|| _Alloc_traits::_S_always_equal()
|| _M_get_Node_allocator() == __x._M_get_Node_allocator())
{
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());
return *this;
}
_Reuse_or_alloc_node __roan(_M_impl._M_header, *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._M_begin(), _M_end(), __lbd);
_M_leftmost() = _S_minimum(_M_root());
_M_rightmost() = _S_maximum(_M_root());
_M_impl._M_node_count = __x._M_impl._M_node_count;
__x.clear();
}
return *this;
}
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
void
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t)
noexcept(_Alloc_traits::_S_nothrow_swap())
{
if (_M_root() == 0)
{
if (__t._M_root() != 0)
{
_M_root() = __t._M_root();
_M_leftmost() = __t._M_leftmost();
_M_rightmost() = __t._M_rightmost();
_M_root()->_M_parent = _M_end();
_M_impl._M_node_count = __t._M_impl._M_node_count;
__t._M_impl._M_reset();
}
}
else if (__t._M_root() == 0)
{
__t._M_root() = _M_root();
__t._M_leftmost() = _M_leftmost();
__t._M_rightmost() = _M_rightmost();
__t._M_root()->_M_parent = __t._M_end();
__t._M_impl._M_node_count = _M_impl._M_node_count;
_M_impl._M_reset();
}
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());
}
__attribute__ ((__pure__)) unsigned int
_Rb_tree_black_count(const _Rb_tree_node_base* __node,
const _Rb_tree_node_base* __root) throw ();
}
#define _STL_MAP_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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:
typedef typename _Alloc::value_type _Alloc_value_type;
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) ;
public:
bool operator()(const value_type& __x, const value_type& __y) const
;
};
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;
map() ;
explicit
map(const _Compare& __comp,
const allocator_type& __a = allocator_type()) ;
map(const map& __x) ;
map(map&& __x)
noexcept(is_nothrow_copy_constructible<_Compare>::value)
: _M_t(std::move(__x._M_t)) { }
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); }
template<typename _InputIterator>
map(_InputIterator __first, _InputIterator __last)
: _M_t()
{ _M_t._M_insert_unique(__first, __last); }
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&
operator=(const map& __x)
{
_M_t = __x._M_t;
return *this;
}
map&
operator=(map&&) = default;
map&
operator=(initializer_list<value_type> __l)
;
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(); }
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;
}
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;
}
template<typename... _Args>
std::pair<iterator, bool>
emplace(_Args&&... __args)
{ return _M_t._M_emplace_unique(std::forward<_Args>(__args)...); }
template<typename... _Args>
iterator
emplace_hint(const_iterator __pos, _Args&&... __args)
{
return _M_t._M_emplace_hint_unique(__pos,
std::forward<_Args>(__args)...);
}
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)); }
void
insert(std::initializer_list<value_type> __list)
{ insert(__list.begin(), __list.end()); }
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)); }
template<typename _InputIterator>
void
insert(_InputIterator __first, _InputIterator __last)
{ _M_t._M_insert_unique(__first, __last); }
iterator
erase(const_iterator __position)
{ return _M_t.erase(__position); }
__attribute ((__abi_tag__ ("cxx11")))
iterator
erase(iterator __position)
{ return _M_t.erase(__position); }
size_type
erase(const key_type& __x)
{ return _M_t.erase(__x); }
iterator
erase(const_iterator __first, const_iterator __last)
{ return _M_t.erase(__first, __last); }
void
swap(map& __x)
noexcept(_Alloc_traits::_S_nothrow_swap())
{ _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()); }
iterator
find(const key_type& __x)
{ return _M_t.find(__x); }
const_iterator
find(const key_type& __x) const
{ return _M_t.find(__x); }
size_type
count(const key_type& __x) const
{ return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
iterator
lower_bound(const key_type& __x)
{ return _M_t.lower_bound(__x); }
const_iterator
lower_bound(const key_type& __x) const
{ return _M_t.lower_bound(__x); }
iterator
upper_bound(const key_type& __x)
{ return _M_t.upper_bound(__x); }
const_iterator
upper_bound(const key_type& __x) const
{ return _M_t.upper_bound(__x); }
std::pair<iterator, iterator>
equal_range(const key_type& __x)
{ return _M_t.equal_range(__x); }
std::pair<const_iterator, const_iterator>
equal_range(const key_type& __x) const
{ return _M_t.equal_range(__x); }
template<typename _K1, typename _T1, typename _C1, typename _A1>
friend bool
operator==(const map<_K1, _T1, _C1, _A1>&,
const map<_K1, _T1, _C1, _A1>&);
template<typename _K1, typename _T1, typename _C1, typename _A1>
friend bool
operator<(const map<_K1, _T1, _C1, _A1>&,
const map<_K1, _T1, _C1, _A1>&);
};
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator==(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator<(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator!=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator>(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator<=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator>=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
void
swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
map<_Key, _Tp, _Compare, _Alloc>& __y)
;
}
#define _STL_MULTIMAP_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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:
typedef typename _Alloc::value_type _Alloc_value_type;
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) ;
public:
bool operator()(const value_type& __x, const value_type& __y) const
;
};
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;
multimap() ;
explicit
multimap(const _Compare& __comp,
const allocator_type& __a = allocator_type()) ;
multimap(const multimap& __x) ;
multimap(multimap&& __x)
noexcept(is_nothrow_copy_constructible<_Compare>::value)
: _M_t(std::move(__x._M_t)) { }
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); }
template<typename _InputIterator>
multimap(_InputIterator __first, _InputIterator __last)
: _M_t()
{ _M_t._M_insert_equal(__first, __last); }
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&
operator=(const multimap& __x)
{
_M_t = __x._M_t;
return *this;
}
multimap&
operator=(multimap&&) = default;
multimap&
operator=(initializer_list<value_type> __l)
;
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(); }
template<typename... _Args>
iterator
emplace(_Args&&... __args)
{ return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); }
template<typename... _Args>
iterator
emplace_hint(const_iterator __pos, _Args&&... __args)
{
return _M_t._M_emplace_hint_equal(__pos,
std::forward<_Args>(__args)...);
}
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)); }
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)); }
template<typename _InputIterator>
void
insert(_InputIterator __first, _InputIterator __last)
{ _M_t._M_insert_equal(__first, __last); }
void
insert(initializer_list<value_type> __l)
{ this->insert(__l.begin(), __l.end()); }
iterator
erase(const_iterator __position)
{ return _M_t.erase(__position); }
__attribute ((__abi_tag__ ("cxx11")))
iterator
erase(iterator __position)
{ return _M_t.erase(__position); }
size_type
erase(const key_type& __x)
{ return _M_t.erase(__x); }
iterator
erase(const_iterator __first, const_iterator __last)
{ return _M_t.erase(__first, __last); }
void
swap(multimap& __x)
noexcept(_Alloc_traits::_S_nothrow_swap())
{ _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()); }
iterator
find(const key_type& __x)
{ return _M_t.find(__x); }
const_iterator
find(const key_type& __x) const
{ return _M_t.find(__x); }
size_type
count(const key_type& __x) const
{ return _M_t.count(__x); }
iterator
lower_bound(const key_type& __x)
{ return _M_t.lower_bound(__x); }
const_iterator
lower_bound(const key_type& __x) const
{ return _M_t.lower_bound(__x); }
iterator
upper_bound(const key_type& __x)
{ return _M_t.upper_bound(__x); }
const_iterator
upper_bound(const key_type& __x) const
{ return _M_t.upper_bound(__x); }
std::pair<iterator, iterator>
equal_range(const key_type& __x)
{ return _M_t.equal_range(__x); }
std::pair<const_iterator, const_iterator>
equal_range(const key_type& __x) const
{ return _M_t.equal_range(__x); }
template<typename _K1, typename _T1, typename _C1, typename _A1>
friend bool
operator==(const multimap<_K1, _T1, _C1, _A1>&,
const multimap<_K1, _T1, _C1, _A1>&);
template<typename _K1, typename _T1, typename _C1, typename _A1>
friend bool
operator<(const multimap<_K1, _T1, _C1, _A1>&,
const multimap<_K1, _T1, _C1, _A1>&);
};
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator==(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator<(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator!=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator<=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator>=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
void
swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
multimap<_Key, _Tp, _Compare, _Alloc>& __y)
;
}
namespace boost {
namespace gregorian {
typedef date_time::months_of_year months_of_year;
using date_time::Jan;
using date_time::Feb;
using date_time::Mar;
using date_time::Apr;
using date_time::May;
using date_time::Jun;
using date_time::Jul;
using date_time::Aug;
using date_time::Sep;
using date_time::Oct;
using date_time::Nov;
using date_time::Dec;
using date_time::NotAMonth;
using date_time::NumMonths;
struct bad_month : public std::out_of_range
{
bad_month() ;
};
typedef CV::simple_exception_policy<unsigned short, 1, 12, bad_month> greg_month_policies;
typedef CV::constrained_value<greg_month_policies> greg_month_rep;
class greg_month : public greg_month_rep {
public:
typedef date_time::months_of_year month_enum;
typedef std::map<std::string, unsigned short> month_map_type;
typedef boost::shared_ptr<month_map_type> month_map_ptr_type;
greg_month(month_enum theMonth) ;
greg_month(unsigned short theMonth) ;
operator unsigned short() const ;
unsigned short as_number() const ;
month_enum as_enum() const ;
const char* as_short_string() const;
const char* as_long_string() const;
const wchar_t* as_short_wstring() const;
const wchar_t* as_long_wstring() const;
static month_map_ptr_type get_month_map_ptr();
const char* as_short_string(char) const
;
const char* as_long_string(char) const
;
const wchar_t* as_short_string(wchar_t) const
;
const wchar_t* as_long_string(wchar_t) const
;
};
} }
namespace boost {
namespace gregorian {
typedef date_time::year_month_day_base<greg_year,
greg_month,
greg_day> greg_year_month_day;
} }
namespace boost {
namespace gregorian {
typedef date_time::int_adapter<uint32_t> fancy_date_rep;
class gregorian_calendar :
public date_time::gregorian_calendar_base<greg_year_month_day, fancy_date_rep::int_type> {
public:
typedef greg_weekday day_of_week_type;
typedef greg_day_of_year_rep day_of_year_type;
typedef fancy_date_rep date_rep_type;
typedef fancy_date_rep date_traits_type;
private:
};
} }
#define GREG_DURATION_HPP___
#define DATE_TIME_DATE_DURATION__
namespace boost {
namespace date_time {
template<class duration_rep_traits>
class date_duration : private
boost::less_than_comparable1< date_duration< duration_rep_traits >
, boost::equality_comparable1< date_duration< duration_rep_traits >
, boost::addable1< date_duration< duration_rep_traits >
, boost::subtractable1< date_duration< duration_rep_traits >
, boost::dividable2< date_duration< duration_rep_traits >, int
> > > > >
{
public:
typedef typename duration_rep_traits::int_type duration_rep_type;
typedef typename duration_rep_traits::impl_type duration_rep;
explicit date_duration(duration_rep day_count) ;
date_duration(special_values sv)
;
date_duration(const date_duration<duration_rep_traits>& other)
;
duration_rep get_rep()const
;
bool is_special()const
;
duration_rep_type days() const
;
static date_duration unit()
;
bool operator==(const date_duration& rhs) const
;
bool operator<(const date_duration& rhs) const
;
date_duration& operator-=(const date_duration& rhs)
;
date_duration& operator+=(const date_duration& rhs)
;
date_duration operator-() const
;
date_duration& operator/=(int divisor)
;
bool is_negative() const
;
private:
duration_rep days_;
};
struct duration_traits_long
{
typedef long int_type;
typedef long impl_type;
static int_type as_number(impl_type i) ;
};
struct duration_traits_adapted
{
typedef long int_type;
typedef boost::date_time::int_adapter<long> impl_type;
static int_type as_number(impl_type i) ;
};
} }
namespace boost {
namespace gregorian {
typedef boost::date_time::duration_traits_adapted date_duration_rep;
class date_duration :
public boost::date_time::date_duration< date_duration_rep >
{
typedef boost::date_time::date_duration< date_duration_rep > base_type;
public:
typedef base_type::duration_rep duration_rep;
explicit date_duration(duration_rep day_count = 0) ;
date_duration(date_time::special_values sv) ;
date_duration(const date_duration& other)
;
date_duration(const base_type& other)
;
bool operator== (const date_duration& rhs) const
;
bool operator!= (const date_duration& rhs) const
;
bool operator< (const date_duration& rhs) const
;
bool operator> (const date_duration& rhs) const
;
bool operator<= (const date_duration& rhs) const
;
bool operator>= (const date_duration& rhs) const
;
date_duration& operator-= (const date_duration& rhs)
;
friend date_duration operator- (date_duration rhs, date_duration const& lhs)
;
date_duration& operator+= (const date_duration& rhs)
;
friend date_duration operator+ (date_duration rhs, date_duration const& lhs)
;
date_duration operator- ()const
;
date_duration& operator/= (int divisor)
;
friend date_duration operator/ (date_duration rhs, int lhs)
;
static date_duration unit()
;
};
typedef date_duration days;
} }
#define DATE_DURATION_TYPES_HPP___
namespace boost {
namespace date_time {
template <class duration_config>
class weeks_duration : public date_duration<duration_config> {
public:
weeks_duration(typename duration_config::impl_type w) ;
weeks_duration(special_values sv) ;
};
template<class t>
class years_duration;
template<class base_config>
class months_duration
{
private:
typedef typename base_config::int_rep int_rep;
typedef typename int_rep::int_type int_type;
typedef typename base_config::date_type date_type;
typedef typename date_type::duration_type duration_type;
typedef typename base_config::month_adjustor_type month_adjustor_type;
typedef months_duration<base_config> months_type;
typedef years_duration<base_config> years_type;
public:
months_duration(int_rep num) ;
months_duration(special_values sv)
;
int_rep number_of_months() const ;
duration_type get_neg_offset(const date_type& d) const
;
duration_type get_offset(const date_type& d) const
;
bool operator==(const months_type& rhs) const
;
bool operator!=(const months_type& rhs) const
;
months_type operator+(const months_type& rhs)const
;
months_type& operator+=(const months_type& rhs)
;
months_type operator-(const months_type& rhs)const
;
months_type& operator-=(const months_type& rhs)
;
months_type operator*(const int_type rhs)const
;
months_type& operator*=(const int_type rhs)
;
months_type operator/(const int_type rhs)const
;
months_type& operator/=(const int_type rhs)
;
months_type operator+(const years_type& y)const
;
months_type& operator+=(const years_type& y)
;
months_type operator-(const years_type& y) const
;
months_type& operator-=(const years_type& y)
;
friend date_type operator+(const date_type& d, const months_type& m)
;
friend date_type operator+=(date_type& d, const months_type& m)
;
friend date_type operator-(const date_type& d, const months_type& m)
;
friend date_type operator-=(date_type& d, const months_type& m)
;
private:
int_rep _m;
};
template<class base_config>
class years_duration
{
private:
typedef typename base_config::int_rep int_rep;
typedef typename int_rep::int_type int_type;
typedef typename base_config::date_type date_type;
typedef typename date_type::duration_type duration_type;
typedef typename base_config::month_adjustor_type month_adjustor_type;
typedef years_duration<base_config> years_type;
typedef months_duration<base_config> months_type;
public:
years_duration(int_rep num) ;
years_duration(special_values sv)
;
int_rep number_of_years() const ;
duration_type get_neg_offset(const date_type& d) const
;
duration_type get_offset(const date_type& d) const
;
bool operator==(const years_type& rhs) const
;
bool operator!=(const years_type& rhs) const
;
years_type operator+(const years_type& rhs)const
;
years_type& operator+=(const years_type& rhs)
;
years_type operator-(const years_type& rhs)const
;
years_type& operator-=(const years_type& rhs)
;
years_type operator*(const int_type rhs)const
;
years_type& operator*=(const int_type rhs)
;
years_type operator/(const int_type rhs)const
;
years_type& operator/=(const int_type rhs)
;
months_type operator+(const months_type& m) const
;
months_type operator-(const months_type& m) const
;
friend date_type operator+(const date_type& d, const years_type& y)
;
friend date_type operator+=(date_type& d, const years_type& y)
;
friend date_type operator-(const date_type& d, const years_type& y)
;
friend date_type operator-=(date_type& d, const years_type& y)
;
private:
int_rep _y;
};
}}
#define GREG_DURATION_TYPES_HPP___
#define GREG_DATE_HPP___
namespace boost {
namespace gregorian {
using date_time::special_values;
using date_time::not_special;
using date_time::neg_infin;
using date_time::pos_infin;
using date_time::not_a_date_time;
using date_time::max_date_time;
using date_time::min_date_time;
class date : public date_time::date<date, gregorian_calendar, date_duration>
{
public:
typedef gregorian_calendar::year_type year_type;
typedef gregorian_calendar::month_type month_type;
typedef gregorian_calendar::day_type day_type;
typedef gregorian_calendar::day_of_year_type day_of_year_type;
typedef gregorian_calendar::ymd_type ymd_type;
typedef gregorian_calendar::date_rep_type date_rep_type;
typedef gregorian_calendar::date_int_type date_int_type;
typedef date_duration duration_type;
date()
;
date(year_type y, month_type m, day_type d)
;
explicit date(const ymd_type& ymd)
;
explicit date(const date_int_type& rhs)
;
explicit date(date_rep_type rhs)
;
explicit date(special_values sv)
;
date_int_type julian_day() const
;
day_of_year_type day_of_year() const
;
date_int_type modjulian_day() const
;
int week_number() const
;
date_int_type day_number() const
;
date end_of_month() const
;
private:
};
} }
#define _DATE_TIME_ADJUST_FUNCTORS_HPP___
#define _DATE_TIME_WRAPPING_INT_HPP__
namespace boost {
namespace date_time {
template<typename int_type_, int_type_ wrap_val>
class wrapping_int {
public:
typedef int_type_ int_type;
static int_type wrap_value() ;
wrapping_int(int_type v) ;
int_type as_int() const ;
operator int_type() const ;
template< typename IntT >
IntT add(IntT v)
;
template< typename IntT >
IntT subtract(IntT v)
;
private:
int_type value_;
template< typename IntT >
IntT calculate_wrap(IntT wrap)
;
};
template<typename int_type_, int_type_ wrap_min, int_type_ wrap_max>
class wrapping_int2 {
public:
typedef int_type_ int_type;
static int_type wrap_value() ;
static int_type min_value() ;
wrapping_int2(int_type v) ;
int_type as_int() const ;
operator int_type() const ;
template< typename IntT >
IntT add(IntT v)
;
template< typename IntT >
IntT subtract(IntT v)
;
private:
int_type value_;
template< typename IntT >
IntT calculate_wrap(IntT wrap)
;
};
} }
namespace boost {
namespace date_time {
template<class date_type>
class day_functor
{
public:
typedef typename date_type::duration_type duration_type;
day_functor(int f) ;
duration_type get_offset(const date_type& d) const
;
duration_type get_neg_offset(const date_type& d) const
;
private:
int f_;
};
template<class date_type>
class month_functor
{
public:
typedef typename date_type::duration_type duration_type;
typedef typename date_type::calendar_type cal_type;
typedef typename cal_type::ymd_type ymd_type;
typedef typename cal_type::day_type day_type;
month_functor(int f) ;
duration_type get_offset(const date_type& d) const
;
duration_type get_neg_offset(const date_type& d) const
;
private:
int f_;
mutable short origDayOfMonth_;
};
template<class date_type>
class week_functor
{
public:
typedef typename date_type::duration_type duration_type;
typedef typename date_type::calendar_type calendar_type;
week_functor(int f) ;
duration_type get_offset(const date_type& d) const
;
duration_type get_neg_offset(const date_type& d) const
;
private:
int f_;
};
template<class date_type>
class year_functor
{
public:
typedef typename date_type::duration_type duration_type;
year_functor(int f) ;
duration_type get_offset(const date_type& d) const
;
duration_type get_neg_offset(const date_type& d) const
;
private:
month_functor<date_type> _mf;
};
} }
namespace boost {
namespace gregorian {
struct greg_durations_config {
typedef date date_type;
typedef date_time::int_adapter<int> int_rep;
typedef date_time::month_functor<date_type> month_adjustor_type;
};
typedef date_time::months_duration<greg_durations_config> months;
typedef date_time::years_duration<greg_durations_config> years;
class weeks_duration : public date_duration {
public:
weeks_duration(duration_rep w) ;
weeks_duration(date_time::special_values sv) ;
};
typedef weeks_duration weeks;
}}
#define DATE_TIME_DATE_GENERATORS_HPP__
#define _GLIBCXX_SSTREAM 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits, typename _Alloc>
class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef _Alloc allocator_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef basic_streambuf<char_type, traits_type> __streambuf_type;
typedef basic_string<char_type, _Traits, _Alloc> __string_type;
typedef typename __string_type::size_type __size_type;
protected:
ios_base::openmode _M_mode;
__string_type _M_string;
public:
explicit
basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
;
explicit
basic_stringbuf(const __string_type& __str,
ios_base::openmode __mode = ios_base::in | ios_base::out)
;
basic_stringbuf(const basic_stringbuf&) = delete;
basic_stringbuf(basic_stringbuf&& __rhs)
;
basic_stringbuf&
operator=(const basic_stringbuf&) = delete;
basic_stringbuf&
operator=(basic_stringbuf&& __rhs)
;
void
swap(basic_stringbuf& __rhs)
;
__string_type
str() const
;
void
str(const __string_type& __s)
;
protected:
void
_M_stringbuf_init(ios_base::openmode __mode)
;
virtual streamsize
showmanyc()
;
virtual int_type
underflow();
virtual int_type
pbackfail(int_type __c = traits_type::eof());
virtual int_type
overflow(int_type __c = traits_type::eof());
virtual __streambuf_type*
setbuf(char_type* __s, streamsize __n)
;
virtual pos_type
seekoff(off_type __off, ios_base::seekdir __way,
ios_base::openmode __mode = ios_base::in | ios_base::out);
virtual pos_type
seekpos(pos_type __sp,
ios_base::openmode __mode = ios_base::in | ios_base::out);
void
_M_sync(char_type* __base, __size_type __i, __size_type __o);
void
_M_update_egptr()
;
void
_M_pbump(char_type* __pbeg, char_type* __pend, off_type __off);
};
template<typename _CharT, typename _Traits, typename _Alloc>
class basic_istringstream : public basic_istream<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef _Alloc allocator_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
typedef basic_istream<char_type, traits_type> __istream_type;
private:
__stringbuf_type _M_stringbuf;
public:
explicit
basic_istringstream(ios_base::openmode __mode = ios_base::in)
;
explicit
basic_istringstream(const __string_type& __str,
ios_base::openmode __mode = ios_base::in)
;
~basic_istringstream()
;
basic_istringstream(const basic_istringstream&) = delete;
basic_istringstream(basic_istringstream&& __rhs)
;
basic_istringstream&
operator=(const basic_istringstream&) = delete;
basic_istringstream&
operator=(basic_istringstream&& __rhs)
;
void
swap(basic_istringstream& __rhs)
;
__stringbuf_type*
rdbuf() const
;
__string_type
str() const
;
void
str(const __string_type& __s)
;
};
template <typename _CharT, typename _Traits, typename _Alloc>
class basic_ostringstream : public basic_ostream<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef _Alloc allocator_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
typedef basic_ostream<char_type, traits_type> __ostream_type;
private:
__stringbuf_type _M_stringbuf;
public:
explicit
basic_ostringstream(ios_base::openmode __mode = ios_base::out)
;
explicit
basic_ostringstream(const __string_type& __str,
ios_base::openmode __mode = ios_base::out)
;
~basic_ostringstream()
;
basic_ostringstream(const basic_ostringstream&) = delete;
basic_ostringstream(basic_ostringstream&& __rhs)
;
basic_ostringstream&
operator=(const basic_ostringstream&) = delete;
basic_ostringstream&
operator=(basic_ostringstream&& __rhs)
;
void
swap(basic_ostringstream& __rhs)
;
__stringbuf_type*
rdbuf() const
;
__string_type
str() const
;
void
str(const __string_type& __s)
;
};
template <typename _CharT, typename _Traits, typename _Alloc>
class basic_stringstream : public basic_iostream<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef _Alloc allocator_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
typedef basic_iostream<char_type, traits_type> __iostream_type;
private:
__stringbuf_type _M_stringbuf;
public:
explicit
basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
;
explicit
basic_stringstream(const __string_type& __str,
ios_base::openmode __m = ios_base::out | ios_base::in)
;
~basic_stringstream()
;
basic_stringstream(const basic_stringstream&) = delete;
basic_stringstream(basic_stringstream&& __rhs)
;
basic_stringstream&
operator=(const basic_stringstream&) = delete;
basic_stringstream&
operator=(basic_stringstream&& __rhs)
;
void
swap(basic_stringstream& __rhs)
;
__stringbuf_type*
rdbuf() const
;
__string_type
str() const
;
void
str(const __string_type& __s)
;
};
template <class _CharT, class _Traits, class _Allocator>
void
swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x,
basic_stringbuf<_CharT, _Traits, _Allocator>& __y)
;
template <class _CharT, class _Traits, class _Allocator>
void
swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x,
basic_istringstream<_CharT, _Traits, _Allocator>& __y)
;
template <class _CharT, class _Traits, class _Allocator>
void
swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x,
basic_ostringstream<_CharT, _Traits, _Allocator>& __y)
;
template <class _CharT, class _Traits, class _Allocator>
void
swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x,
basic_stringstream<_CharT, _Traits, _Allocator>& __y)
;
}
#define _SSTREAM_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
extern template class basic_stringbuf<char>;
extern template class basic_istringstream<char>;
extern template class basic_ostringstream<char>;
extern template class basic_stringstream<char>;
extern template class basic_stringbuf<wchar_t>;
extern template class basic_istringstream<wchar_t>;
extern template class basic_ostringstream<wchar_t>;
extern template class basic_stringstream<wchar_t>;
}
namespace boost {
namespace date_time {
template<class date_type>
class year_based_generator
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::year_type year_type;
year_based_generator() ;
virtual ~year_based_generator() ;
virtual date_type get_date(year_type y) const = 0;
virtual std::string to_string() const =0;
};
template<class date_type>
class partial_date : public year_based_generator<date_type>
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_type day_type;
typedef typename calendar_type::month_type month_type;
typedef typename calendar_type::year_type year_type;
typedef typename date_type::duration_type duration_type;
typedef typename duration_type::duration_rep duration_rep;
partial_date(day_type d, month_type m)
;
partial_date(duration_rep days)
;
date_type get_date(year_type y) const
;
date_type operator()(year_type y) const
;
bool operator==(const partial_date& rhs) const
;
bool operator<(const partial_date& rhs) const
;
month_type month() const
;
day_type day() const
;
virtual std::string to_string() const
;
private:
day_type day_;
month_type month_;
};
const char* nth_as_str(int n);
template<class date_type>
class nth_kday_of_month : public year_based_generator<date_type>
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_of_week_type day_of_week_type;
typedef typename calendar_type::month_type month_type;
typedef typename calendar_type::year_type year_type;
typedef typename date_type::duration_type duration_type;
enum week_num {first=1, second, third, fourth, fifth};
nth_kday_of_month(week_num week_no,
day_of_week_type dow,
month_type m)
;
date_type get_date(year_type y) const
;
month_type month() const
;
week_num nth_week() const
;
day_of_week_type day_of_week() const
;
const char* nth_week_as_str() const
;
virtual std::string to_string() const
;
private:
month_type month_;
week_num wn_;
day_of_week_type dow_;
};
template<class date_type>
class first_kday_of_month : public year_based_generator<date_type>
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_of_week_type day_of_week_type;
typedef typename calendar_type::month_type month_type;
typedef typename calendar_type::year_type year_type;
typedef typename date_type::duration_type duration_type;
first_kday_of_month(day_of_week_type dow, month_type m)
;
date_type get_date(year_type year) const
;
month_type month() const
;
day_of_week_type day_of_week() const
;
virtual std::string to_string() const
;
private:
month_type month_;
day_of_week_type dow_;
};
template<class date_type>
class last_kday_of_month : public year_based_generator<date_type>
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_of_week_type day_of_week_type;
typedef typename calendar_type::month_type month_type;
typedef typename calendar_type::year_type year_type;
typedef typename date_type::duration_type duration_type;
last_kday_of_month(day_of_week_type dow, month_type m)
;
date_type get_date(year_type year) const
;
month_type month() const
;
day_of_week_type day_of_week() const
;
virtual std::string to_string() const
;
private:
month_type month_;
day_of_week_type dow_;
};
template<class date_type>
class first_kday_after
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_of_week_type day_of_week_type;
typedef typename date_type::duration_type duration_type;
first_kday_after(day_of_week_type dow)
;
date_type get_date(date_type start_day) const
;
day_of_week_type day_of_week() const
;
private:
day_of_week_type dow_;
};
template<class date_type>
class first_kday_before
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_of_week_type day_of_week_type;
typedef typename date_type::duration_type duration_type;
first_kday_before(day_of_week_type dow)
;
date_type get_date(date_type start_day) const
;
day_of_week_type day_of_week() const
;
private:
day_of_week_type dow_;
};
template<typename date_type, class weekday_type>
typename date_type::duration_type days_until_weekday(const date_type& d, const weekday_type& wd)
;
template<typename date_type, class weekday_type>
typename date_type::duration_type days_before_weekday(const date_type& d, const weekday_type& wd)
;
template<class date_type, class weekday_type>
date_type next_weekday(const date_type& d, const weekday_type& wd)
;
template<class date_type, class weekday_type>
date_type previous_weekday(const date_type& d, const weekday_type& wd)
;
} }
#define DATE_CLOCK_DEVICE_HPP___
namespace boost {
namespace date_time {
template<class date_type>
class day_clock
{
public:
typedef typename date_type::ymd_type ymd_type;
static date_type local_day()
;
static typename date_type::ymd_type local_day_ymd()
;
static typename date_type::ymd_type universal_day_ymd()
;
static date_type universal_day()
;
private:
static ::std::tm* get_local_time(std::tm& result)
;
static ::std::tm* get_universal_time(std::tm& result)
;
};
} }
#define DATE_ITERATOR_HPP___
namespace boost {
namespace date_time {
enum date_resolutions {day, week, months, year, decade, century, NumDateResolutions};
template<class date_type>
class date_itr_base {
public:
typedef typename date_type::duration_type duration_type;
typedef date_type value_type;
typedef std::input_iterator_tag iterator_category;
date_itr_base(date_type d) ;
virtual ~date_itr_base() ;
date_itr_base& operator++()
;
date_itr_base& operator--()
;
virtual duration_type get_offset(const date_type& current) const=0;
virtual duration_type get_neg_offset(const date_type& current) const=0;
date_type operator*() ;
date_type* operator->() ;
bool operator< (const date_type& d) ;
bool operator<= (const date_type& d) ;
bool operator> (const date_type& d) ;
bool operator>= (const date_type& d) ;
bool operator== (const date_type& d) ;
bool operator!= (const date_type& d) ;
private:
date_type current_;
};
template<class offset_functor, class date_type>
class date_itr : public date_itr_base<date_type> {
public:
typedef typename date_type::duration_type duration_type;
date_itr(date_type d, int factor=1)
;
private:
virtual duration_type get_offset(const date_type& current) const
;
virtual duration_type get_neg_offset(const date_type& current) const
;
offset_functor of_;
};
} }
namespace boost {
namespace gregorian {
typedef date_time::period<date, date_duration> date_period;
typedef date_time::year_based_generator<date> year_based_generator;
typedef date_time::partial_date<date> partial_date;
typedef date_time::nth_kday_of_month<date> nth_kday_of_month;
typedef nth_kday_of_month nth_day_of_the_week_in_month;
typedef date_time::first_kday_of_month<date> first_kday_of_month;
typedef first_kday_of_month first_day_of_the_week_in_month;
typedef date_time::last_kday_of_month<date> last_kday_of_month;
typedef last_kday_of_month last_day_of_the_week_in_month;
typedef date_time::first_kday_after<date> first_kday_after;
typedef first_kday_after first_day_of_the_week_after;
typedef date_time::first_kday_before<date> first_kday_before;
typedef first_kday_before first_day_of_the_week_before;
typedef date_time::day_clock<date> day_clock;
typedef date_time::date_itr_base<date> date_iterator;
typedef date_time::date_itr<date_time::day_functor<date>,
date> day_iterator;
typedef date_time::date_itr<date_time::week_functor<date>,
date> week_iterator;
typedef date_time::date_itr<date_time::month_functor<date>,
date> month_iterator;
typedef date_time::date_itr<date_time::year_functor<date>,
date> year_iterator;
using date_time::days_until_weekday;
using date_time::days_before_weekday;
using date_time::next_weekday;
using date_time::previous_weekday;
} }
namespace boost {
namespace posix_time {
#define BOOST_DATE_TIME_HAS_MILLISECONDS
#define BOOST_DATE_TIME_HAS_MICROSECONDS
#undef BOOST_DATE_TIME_HAS_NANOSECONDS
typedef date_time::time_resolution_traits<
boost::date_time::time_resolution_traits_adapted64_impl, boost::date_time::micro,
1000000, 6 > time_res_traits;
class time_duration :
public date_time::time_duration<time_duration, time_res_traits>
{
public:
typedef time_res_traits rep_type;
typedef time_res_traits::day_type day_type;
typedef time_res_traits::hour_type hour_type;
typedef time_res_traits::min_type min_type;
typedef time_res_traits::sec_type sec_type;
typedef time_res_traits::fractional_seconds_type fractional_seconds_type;
typedef time_res_traits::tick_type tick_type;
typedef time_res_traits::impl_type impl_type;
time_duration(hour_type hour,
min_type min,
sec_type sec,
fractional_seconds_type fs=0)
;
time_duration()
;
time_duration(boost::date_time::special_values sv)
;
friend class date_time::time_duration<time_duration, time_res_traits>;
protected:
explicit time_duration(impl_type tick_count)
;
};
class millisec_posix_time_system_config
{
public:
typedef boost::int64_t time_rep_type;
typedef gregorian::date date_type;
typedef gregorian::date_duration date_duration_type;
typedef time_duration time_duration_type;
typedef time_res_traits::tick_type int_type;
typedef time_res_traits::impl_type impl_type;
typedef time_res_traits resolution_traits;
static const boost::int64_t tick_per_second = 1000000;
};
} }
#define DATE_TIME_TIME_SYSTEM_SPLIT_HPP
namespace boost {
namespace date_time {
template<typename config>
class split_timedate_system
{
public:
typedef typename config::time_rep_type time_rep_type;
typedef typename config::date_type date_type;
typedef typename config::time_duration_type time_duration_type;
typedef typename config::date_duration_type date_duration_type;
typedef typename config::int_type int_type;
typedef typename config::resolution_traits resolution_traits;
private:
static const int_type ticks_per_day = 86400L * config::tick_per_second;
public:
typedef date_time::wrapping_int<int_type, ticks_per_day> wrap_int_type;
static time_rep_type get_time_rep(special_values sv)
;
static time_rep_type get_time_rep(const date_type& day,
const time_duration_type& tod,
date_time::dst_flags = not_dst)
;
static date_type get_date(const time_rep_type& val)
;
static time_duration_type get_time_of_day(const time_rep_type& val)
;
static std::string zone_name(const time_rep_type&)
;
static bool is_equal(const time_rep_type& lhs, const time_rep_type& rhs)
;
static bool is_less(const time_rep_type& lhs, const time_rep_type& rhs)
;
static time_rep_type add_days(const time_rep_type& base,
const date_duration_type& dd)
;
static time_rep_type subtract_days(const time_rep_type& base,
const date_duration_type& dd)
;
static time_rep_type subtract_time_duration(const time_rep_type& base,
const time_duration_type& td)
;
static time_rep_type add_time_duration(const time_rep_type& base,
time_duration_type td)
;
static time_duration_type subtract_times(const time_rep_type& lhs,
const time_rep_type& rhs)
;
};
} }
#define DATE_TIME_TIME_SYSTEM_COUNTED_HPP
namespace boost {
namespace date_time {
template<class config>
struct counted_time_rep
{
typedef typename config::int_type int_type;
typedef typename config::date_type date_type;
typedef typename config::impl_type impl_type;
typedef typename date_type::duration_type date_duration_type;
typedef typename date_type::calendar_type calendar_type;
typedef typename date_type::ymd_type ymd_type;
typedef typename config::time_duration_type time_duration_type;
typedef typename config::resolution_traits resolution_traits;
counted_time_rep(const date_type& d, const time_duration_type& time_of_day)
;
explicit counted_time_rep(int_type count)
;
explicit counted_time_rep(impl_type count)
;
date_type date() const
;
unsigned long day_count() const
;
int_type time_count() const
;
int_type tod() const
;
static int_type frac_sec_per_day()
;
bool is_pos_infinity()const
;
bool is_neg_infinity()const
;
bool is_not_a_date_time()const
;
bool is_special()const
;
impl_type get_rep()const
;
private:
impl_type time_count_;
};
template<class time_rep>
class counted_time_system
{
public:
typedef time_rep time_rep_type;
typedef typename time_rep_type::impl_type impl_type;
typedef typename time_rep_type::time_duration_type time_duration_type;
typedef typename time_duration_type::fractional_seconds_type fractional_seconds_type;
typedef typename time_rep_type::date_type date_type;
typedef typename time_rep_type::date_duration_type date_duration_type;
template<class T> static void unused_var(const T&) ;
static time_rep_type get_time_rep(const date_type& day,
const time_duration_type& tod,
date_time::dst_flags dst=not_dst)
;
static time_rep_type get_time_rep(special_values sv)
;
static date_type get_date(const time_rep_type& val)
;
static time_duration_type get_time_of_day(const time_rep_type& val)
;
static std::string zone_name(const time_rep_type&)
;
static bool is_equal(const time_rep_type& lhs, const time_rep_type& rhs)
;
static bool is_less(const time_rep_type& lhs, const time_rep_type& rhs)
;
static time_rep_type add_days(const time_rep_type& base,
const date_duration_type& dd)
;
static time_rep_type subtract_days(const time_rep_type& base,
const date_duration_type& dd)
;
static time_rep_type subtract_time_duration(const time_rep_type& base,
const time_duration_type& td)
;
static time_rep_type add_time_duration(const time_rep_type& base,
time_duration_type td)
;
static time_duration_type subtract_times(const time_rep_type& lhs,
const time_rep_type& rhs)
;
};
} }
namespace boost {
namespace posix_time {
typedef date_time::counted_time_rep<millisec_posix_time_system_config> int64_time_rep;
typedef date_time::counted_time_system<int64_time_rep> posix_time_system;
} }
#define DATE_TIME_TIME_HPP___
namespace boost {
namespace date_time {
template <class T, class time_system>
class base_time : private
boost::less_than_comparable<T
, boost::equality_comparable<T
> >
{
public:
typedef T time_type;
typedef typename time_system::time_rep_type time_rep_type;
typedef typename time_system::date_type date_type;
typedef typename time_system::date_duration_type date_duration_type;
typedef typename time_system::time_duration_type time_duration_type;
base_time(const date_type& day,
const time_duration_type& td,
dst_flags dst=not_dst)
;
base_time(special_values sv)
;
base_time(const time_rep_type& rhs)
;
date_type date() const
;
time_duration_type time_of_day() const
;
std::string zone_name(bool =false) const
;
std::string zone_abbrev(bool =false) const
;
std::string zone_as_posix_string() const
;
bool is_not_a_date_time() const
;
bool is_infinity() const
;
bool is_pos_infinity() const
;
bool is_neg_infinity() const
;
bool is_special() const
;
bool operator==(const time_type& rhs) const
;
bool operator<(const time_type& rhs) const
;
time_duration_type operator-(const time_type& rhs) const
;
time_type operator+(const date_duration_type& dd) const
;
time_type operator+=(const date_duration_type& dd)
;
time_type operator-(const date_duration_type& dd) const
;
time_type operator-=(const date_duration_type& dd)
;
time_type operator+(const time_duration_type& td) const
;
time_type operator+=(const time_duration_type& td)
;
time_type operator-(const time_duration_type& rhs) const
;
time_type operator-=(const time_duration_type& td)
;
protected:
time_rep_type time_;
};
} }
namespace boost {
namespace posix_time {
using date_time::special_values;
using date_time::not_special;
using date_time::neg_infin;
using date_time::pos_infin;
using date_time::not_a_date_time;
using date_time::max_date_time;
using date_time::min_date_time;
class ptime : public date_time::base_time<ptime, posix_time_system>
{
public:
typedef posix_time_system time_system_type;
typedef time_system_type::time_rep_type time_rep_type;
typedef time_system_type::time_duration_type time_duration_type;
typedef ptime time_type;
ptime(gregorian::date d,time_duration_type td)
;
explicit ptime(gregorian::date d)
;
ptime(const time_rep_type& rhs)
;
ptime(const special_values sv)
;
ptime()
;
};
} }
#define DATE_DURATION_OPERATORS_HPP___
namespace boost {
namespace posix_time {
ptime
operator+(const ptime& t, const boost::gregorian::months& m)
;
ptime
operator+=(ptime& t, const boost::gregorian::months& m)
;
ptime
operator-(const ptime& t, const boost::gregorian::months& m)
;
ptime
operator-=(ptime& t, const boost::gregorian::months& m)
;
ptime
operator+(const ptime& t, const boost::gregorian::years& y)
;
ptime
operator+=(ptime& t, const boost::gregorian::years& y)
;
ptime
operator-(const ptime& t, const boost::gregorian::years& y)
;
ptime
operator-=(ptime& t, const boost::gregorian::years& y)
;
}}
#define POSIX_TIME_DURATION_HPP___
namespace boost {
namespace posix_time {
class hours : public time_duration
{
public:
explicit hours(long h)
;
};
class minutes : public time_duration
{
public:
explicit minutes(long m)
;
};
class seconds : public time_duration
{
public:
explicit seconds(long s)
;
};
typedef date_time::subsecond_duration<time_duration,1000> millisec;
typedef date_time::subsecond_duration<time_duration,1000> milliseconds;
typedef date_time::subsecond_duration<time_duration,1000000> microsec;
typedef date_time::subsecond_duration<time_duration,1000000> microseconds;
} }
#define POSIX_TIME_PERIOD_HPP___
namespace boost {
namespace posix_time {
typedef date_time::period<ptime, time_duration> time_period;
} }
#define DATE_TIME_TIME_ITERATOR_HPP___
namespace boost {
namespace date_time {
template<class time_type>
class time_itr {
public:
typedef typename time_type::time_duration_type time_duration_type;
time_itr(time_type t, time_duration_type d) ;
time_itr& operator++()
;
time_itr& operator--()
;
time_type operator*() ;
time_type* operator->() ;
bool operator< (const time_type& t) ;
bool operator<= (const time_type& t) ;
bool operator!= (const time_type& t) ;
bool operator== (const time_type& t) ;
bool operator> (const time_type& t) ;
bool operator>= (const time_type& t) ;
private:
time_type current_;
time_duration_type offset_;
};
} }
#define DATE_TIME_DST_RULES_HPP__
namespace boost {
namespace date_time {
enum time_is_dst_result {is_not_in_dst, is_in_dst,
ambiguous, invalid_time_label};
template<class date_type_,
class time_duration_type_>
class dst_calculator
{
public:
typedef time_duration_type_ time_duration_type;
typedef date_type_ date_type;
static time_is_dst_result
process_local_dst_start_day(const time_duration_type& time_of_day,
unsigned int dst_start_offset_minutes,
long dst_length_minutes)
;
static time_is_dst_result
process_local_dst_end_day(const time_duration_type& time_of_day,
unsigned int dst_end_offset_minutes,
long dst_length_minutes)
;
static time_is_dst_result
local_is_dst(const date_type& current_day,
const time_duration_type& time_of_day,
const date_type& dst_start_day,
const time_duration_type& dst_start_offset,
const date_type& dst_end_day,
const time_duration_type& dst_end_offset,
const time_duration_type& dst_length_minutes)
;
static time_is_dst_result
local_is_dst(const date_type& current_day,
const time_duration_type& time_of_day,
const date_type& dst_start_day,
unsigned int dst_start_offset_minutes,
const date_type& dst_end_day,
unsigned int dst_end_offset_minutes,
long dst_length_minutes)
;
};
template<class date_type,
class time_duration_type,
class dst_traits>
class dst_calc_engine
{
public:
typedef typename date_type::year_type year_type;
typedef typename date_type::calendar_type calendar_type;
typedef dst_calculator<date_type, time_duration_type> dstcalc;
static time_is_dst_result local_is_dst(const date_type& d,
const time_duration_type& td)
;
static bool is_dst_boundary_day(date_type d)
;
static time_duration_type dst_offset()
;
static date_type local_dst_start_day(year_type year)
;
static date_type local_dst_end_day(year_type year)
;
};
template<class date_type_,
class time_duration_type_,
unsigned int dst_start_offset_minutes=120,
short dst_length_minutes=60>
class us_dst_rules
{
public:
typedef time_duration_type_ time_duration_type;
typedef date_type_ date_type;
typedef typename date_type::year_type year_type;
typedef typename date_type::calendar_type calendar_type;
typedef date_time::last_kday_of_month<date_type> lkday;
typedef date_time::first_kday_of_month<date_type> fkday;
typedef date_time::nth_kday_of_month<date_type> nkday;
typedef dst_calculator<date_type, time_duration_type> dstcalc;
static time_is_dst_result local_is_dst(const date_type& d,
const time_duration_type& td)
;
static bool is_dst_boundary_day(date_type d)
;
static date_type local_dst_start_day(year_type year)
;
static date_type local_dst_end_day(year_type year)
;
static time_duration_type dst_offset()
;
private:
};
template<class date_type_, class time_duration_type_>
class null_dst_rules
{
public:
typedef time_duration_type_ time_duration_type;
typedef date_type_ date_type;
static time_is_dst_result local_is_dst(const date_type&,
const time_duration_type&)
;
static time_is_dst_result utc_is_dst(const date_type&,
const time_duration_type&)
;
static bool is_dst_boundary_day(date_type )
;
static time_duration_type dst_offset()
;
};
} }
namespace boost {
namespace posix_time {
typedef date_time::time_itr<ptime> time_iterator;
typedef date_time::second_clock<ptime> second_clock;
typedef date_time::microsec_clock<ptime> microsec_clock;
typedef date_time::null_dst_rules<ptime::date_type, time_duration> no_dst;
typedef date_time::us_dst_rules<ptime::date_type, time_duration> us_dst;
} }
namespace boost {
namespace asio {
template <typename Time>
struct time_traits;
template <>
struct time_traits<boost::posix_time::ptime>
{
typedef boost::posix_time::ptime time_type;
typedef boost::posix_time::time_duration duration_type;
static time_type now()
;
static time_type add(const time_type& t, const duration_type& d)
;
static duration_type subtract(const time_type& t1, const time_type& t2)
;
static bool less_than(const time_type& t1, const time_type& t2)
;
static boost::posix_time::time_duration to_posix_duration(
const duration_type& d)
;
};
}
}
#define BOOST_ASIO_DETAIL_TIMER_QUEUE_PTIME_HPP
namespace boost {
namespace asio {
namespace detail {
struct forwarding_posix_time_traits : time_traits<boost::posix_time::ptime> {};
template <>
class timer_queue<time_traits<boost::posix_time::ptime> >
: public timer_queue_base
{
public:
typedef boost::posix_time::ptime time_type;
typedef boost::posix_time::time_duration duration_type;
typedef timer_queue<forwarding_posix_time_traits>::per_timer_data
per_timer_data;
inline timer_queue();
inline virtual ~timer_queue();
inline bool enqueue_timer(const time_type& time,
per_timer_data& timer, wait_op* op);
inline virtual bool empty() const;
inline virtual long wait_duration_msec(long max_duration) const;
inline virtual long wait_duration_usec(long max_duration) const;
inline virtual void get_ready_timers(op_queue<operation>& ops);
inline virtual void get_all_timers(op_queue<operation>& ops);
inline std::size_t cancel_timer(
per_timer_data& timer, op_queue<operation>& ops,
std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
private:
timer_queue<forwarding_posix_time_traits> impl_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_TIMER_QUEUE_PTIME_IPP
namespace boost {
namespace asio {
namespace detail {
bool timer_queue<time_traits<boost::posix_time::ptime> >::enqueue_timer(
const time_type& time, per_timer_data& timer, wait_op* op)
{
return impl_.enqueue_timer(time, timer, op);
}
bool timer_queue<time_traits<boost::posix_time::ptime> >::empty() const
{
return impl_.empty();
}
}
}
}
namespace boost {
namespace asio {
template <typename TimeType,
typename TimeTraits = boost::asio::time_traits<TimeType> >
class deadline_timer_service
: public boost::asio::detail::service_base<
deadline_timer_service<TimeType, TimeTraits> >
{
public:
typedef TimeTraits traits_type;
typedef typename traits_type::time_type time_type;
typedef typename traits_type::duration_type duration_type;
private:
typedef detail::deadline_timer_service<traits_type> service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
explicit deadline_timer_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void destroy(implementation_type& impl)
;
std::size_t cancel(implementation_type& impl, boost::system::error_code& ec)
;
std::size_t cancel_one(implementation_type& impl,
boost::system::error_code& ec)
;
time_type expires_at(const implementation_type& impl) const
;
std::size_t expires_at(implementation_type& impl,
const time_type& expiry_time, boost::system::error_code& ec)
;
duration_type expires_from_now(const implementation_type& impl) const
;
std::size_t expires_from_now(implementation_type& impl,
const duration_type& expiry_time, boost::system::error_code& ec)
;
void wait(implementation_type& impl, boost::system::error_code& ec)
;
template <typename WaitHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WaitHandler, void (boost::system::error_code)>::type>::type
async_wait(implementation_type& impl,
WaitHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename Time,
typename TimeTraits = boost::asio::time_traits<Time>,
typename TimerService = deadline_timer_service<Time, TimeTraits> >
class basic_deadline_timer
: public basic_io_object<TimerService>
{
public:
typedef TimeTraits traits_type;
typedef typename traits_type::time_type time_type;
typedef typename traits_type::duration_type duration_type;
explicit basic_deadline_timer(boost::asio::io_service& io_service)
;
basic_deadline_timer(boost::asio::io_service& io_service,
const time_type& expiry_time)
;
basic_deadline_timer(boost::asio::io_service& io_service,
const duration_type& expiry_time)
;
std::size_t cancel()
;
std::size_t cancel(boost::system::error_code& ec)
;
std::size_t cancel_one()
;
std::size_t cancel_one(boost::system::error_code& ec)
;
time_type expires_at() const
;
std::size_t expires_at(const time_type& expiry_time)
;
std::size_t expires_at(const time_type& expiry_time,
boost::system::error_code& ec)
;
duration_type expires_from_now() const
;
std::size_t expires_from_now(const duration_type& expiry_time)
;
std::size_t expires_from_now(const duration_type& expiry_time,
boost::system::error_code& ec)
;
void wait()
;
void wait(boost::system::error_code& ec)
;
template <typename WaitHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WaitHandler, void (boost::system::error_code)>::type>::type
async_wait(WaitHandler&& handler)
;
};
}
}
#define BOOST_ASIO_BASIC_RAW_SOCKET_HPP
#define BOOST_ASIO_RAW_SOCKET_SERVICE_HPP
namespace boost {
namespace asio {
template <typename Protocol>
class raw_socket_service
: public boost::asio::detail::service_base<raw_socket_service<Protocol> >
{
public:
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
private:
typedef detail::reactive_socket_service<Protocol> service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
typedef typename service_impl_type::native_handle_type native_type;
typedef typename service_impl_type::native_handle_type native_handle_type;
explicit raw_socket_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
raw_socket_service& other_service,
implementation_type& other_impl)
;
template <typename Protocol1>
void converting_move_construct(implementation_type& impl,
typename raw_socket_service<
Protocol1>::implementation_type& other_impl,
typename enable_if<is_convertible<
Protocol1, Protocol>::value>::type* = 0)
;
void destroy(implementation_type& impl)
;
boost::system::error_code open(implementation_type& impl,
const protocol_type& protocol, boost::system::error_code& ec)
;
boost::system::error_code assign(implementation_type& impl,
const protocol_type& protocol, const native_handle_type& native_socket,
boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_type native(implementation_type& impl)
;
native_handle_type native_handle(implementation_type& impl)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
bool at_mark(const implementation_type& impl,
boost::system::error_code& ec) const
;
std::size_t available(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code bind(implementation_type& impl,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
boost::system::error_code connect(implementation_type& impl,
const endpoint_type& peer_endpoint, boost::system::error_code& ec)
;
template <typename ConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ConnectHandler, void (boost::system::error_code)>::type>::type
async_connect(implementation_type& impl,
const endpoint_type& peer_endpoint,
ConnectHandler&& handler)
;
template <typename SettableSocketOption>
boost::system::error_code set_option(implementation_type& impl,
const SettableSocketOption& option, boost::system::error_code& ec)
;
template <typename GettableSocketOption>
boost::system::error_code get_option(const implementation_type& impl,
GettableSocketOption& option, boost::system::error_code& ec) const
;
template <typename IoControlCommand>
boost::system::error_code io_control(implementation_type& impl,
IoControlCommand& command, boost::system::error_code& ec)
;
bool non_blocking(const implementation_type& impl) const
;
boost::system::error_code non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const implementation_type& impl) const
;
boost::system::error_code native_non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
endpoint_type local_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
endpoint_type remote_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code shutdown(implementation_type& impl,
socket_base::shutdown_type what, boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t send(implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(implementation_type& impl, const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename ConstBufferSequence>
std::size_t send_to(implementation_type& impl,
const ConstBufferSequence& buffers, const endpoint_type& destination,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send_to(implementation_type& impl,
const ConstBufferSequence& buffers, const endpoint_type& destination,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags,
ReadHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive_from(implementation_type& impl,
const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive_from(implementation_type& impl,
const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
socket_base::message_flags flags,
ReadHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename Protocol,
typename RawSocketService = raw_socket_service<Protocol> >
class basic_raw_socket
: public basic_socket<Protocol, RawSocketService>
{
public:
typedef typename RawSocketService::native_handle_type native_type;
typedef typename RawSocketService::native_handle_type native_handle_type;
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
explicit basic_raw_socket(boost::asio::io_service& io_service)
;
basic_raw_socket(boost::asio::io_service& io_service,
const protocol_type& protocol)
;
basic_raw_socket(boost::asio::io_service& io_service,
const endpoint_type& endpoint)
;
basic_raw_socket(boost::asio::io_service& io_service,
const protocol_type& protocol, const native_handle_type& native_socket)
;
basic_raw_socket(basic_raw_socket&& other)
;
basic_raw_socket& operator=(basic_raw_socket&& other)
;
template <typename Protocol1, typename RawSocketService1>
basic_raw_socket(basic_raw_socket<Protocol1, RawSocketService1>&& other,
typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
;
template <typename Protocol1, typename RawSocketService1>
typename enable_if<is_convertible<Protocol1, Protocol>::value,
basic_raw_socket>::type& operator=(
basic_raw_socket<Protocol1, RawSocketService1>&& other)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename ConstBufferSequence>
std::size_t send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination)
;
template <typename ConstBufferSequence>
std::size_t send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags)
;
template <typename ConstBufferSequence>
std::size_t send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination,
WriteHandler&& handler)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags,
ReadHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint)
;
template <typename MutableBufferSequence>
std::size_t receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint, socket_base::message_flags flags)
;
template <typename MutableBufferSequence>
std::size_t receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint, socket_base::message_flags flags,
boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint,
ReadHandler&& handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint, socket_base::message_flags flags,
ReadHandler&& handler)
;
};
}
}
#define BOOST_ASIO_BASIC_SEQ_PACKET_SOCKET_HPP
#define BOOST_ASIO_SEQ_PACKET_SOCKET_SERVICE_HPP
namespace boost {
namespace asio {
template <typename Protocol>
class seq_packet_socket_service
: public boost::asio::detail::service_base<
seq_packet_socket_service<Protocol> >
{
public:
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
private:
typedef detail::reactive_socket_service<Protocol> service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
typedef typename service_impl_type::native_handle_type native_type;
typedef typename service_impl_type::native_handle_type native_handle_type;
explicit seq_packet_socket_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
seq_packet_socket_service& other_service,
implementation_type& other_impl)
;
template <typename Protocol1>
void converting_move_construct(implementation_type& impl,
typename seq_packet_socket_service<
Protocol1>::implementation_type& other_impl,
typename enable_if<is_convertible<
Protocol1, Protocol>::value>::type* = 0)
;
void destroy(implementation_type& impl)
;
boost::system::error_code open(implementation_type& impl,
const protocol_type& protocol, boost::system::error_code& ec)
;
boost::system::error_code assign(implementation_type& impl,
const protocol_type& protocol, const native_handle_type& native_socket,
boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_type native(implementation_type& impl)
;
native_handle_type native_handle(implementation_type& impl)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
bool at_mark(const implementation_type& impl,
boost::system::error_code& ec) const
;
std::size_t available(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code bind(implementation_type& impl,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
boost::system::error_code connect(implementation_type& impl,
const endpoint_type& peer_endpoint, boost::system::error_code& ec)
;
template <typename ConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ConnectHandler, void (boost::system::error_code)>::type>::type
async_connect(implementation_type& impl,
const endpoint_type& peer_endpoint,
ConnectHandler&& handler)
;
template <typename SettableSocketOption>
boost::system::error_code set_option(implementation_type& impl,
const SettableSocketOption& option, boost::system::error_code& ec)
;
template <typename GettableSocketOption>
boost::system::error_code get_option(const implementation_type& impl,
GettableSocketOption& option, boost::system::error_code& ec) const
;
template <typename IoControlCommand>
boost::system::error_code io_control(implementation_type& impl,
IoControlCommand& command, boost::system::error_code& ec)
;
bool non_blocking(const implementation_type& impl) const
;
boost::system::error_code non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const implementation_type& impl) const
;
boost::system::error_code native_non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
endpoint_type local_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
endpoint_type remote_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code shutdown(implementation_type& impl,
socket_base::shutdown_type what, boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t send(implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(implementation_type& impl,
const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
socket_base::message_flags& out_flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(implementation_type& impl,
const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
socket_base::message_flags& out_flags,
ReadHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename Protocol,
typename SeqPacketSocketService = seq_packet_socket_service<Protocol> >
class basic_seq_packet_socket
: public basic_socket<Protocol, SeqPacketSocketService>
{
public:
typedef typename SeqPacketSocketService::native_handle_type native_type;
typedef typename SeqPacketSocketService::native_handle_type
native_handle_type;
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
explicit basic_seq_packet_socket(boost::asio::io_service& io_service)
;
basic_seq_packet_socket(boost::asio::io_service& io_service,
const protocol_type& protocol)
;
basic_seq_packet_socket(boost::asio::io_service& io_service,
const endpoint_type& endpoint)
;
basic_seq_packet_socket(boost::asio::io_service& io_service,
const protocol_type& protocol, const native_handle_type& native_socket)
;
basic_seq_packet_socket(basic_seq_packet_socket&& other)
;
basic_seq_packet_socket& operator=(basic_seq_packet_socket&& other)
;
template <typename Protocol1, typename SeqPacketSocketService1>
basic_seq_packet_socket(
basic_seq_packet_socket<Protocol1, SeqPacketSocketService1>&& other,
typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
;
template <typename Protocol1, typename SeqPacketSocketService1>
typename enable_if<is_convertible<Protocol1, Protocol>::value,
basic_seq_packet_socket>::type& operator=(
basic_seq_packet_socket<Protocol1, SeqPacketSocketService1>&& other)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags& out_flags)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags in_flags,
socket_base::message_flags& out_flags)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags in_flags,
socket_base::message_flags& out_flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
socket_base::message_flags& out_flags,
ReadHandler&& handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
socket_base::message_flags in_flags,
socket_base::message_flags& out_flags,
ReadHandler&& handler)
;
};
}
}
#define BOOST_ASIO_BASIC_SERIAL_PORT_HPP
#define BOOST_ASIO_SERIAL_PORT_BASE_HPP
#define _TERMIOS_H 1
extern "C" {
typedef unsigned char cc_t;
typedef unsigned int speed_t;
typedef unsigned int tcflag_t;
#define NCCS 32
struct termios
{
tcflag_t c_iflag;
tcflag_t c_oflag;
tcflag_t c_cflag;
tcflag_t c_lflag;
cc_t c_line;
cc_t c_cc[32];
speed_t c_ispeed;
speed_t c_ospeed;
#define _HAVE_STRUCT_TERMIOS_C_ISPEED 1
#define _HAVE_STRUCT_TERMIOS_C_OSPEED 1
};
#define VINTR 0
#define VQUIT 1
#define VERASE 2
#define VKILL 3
#define VEOF 4
#define VTIME 5
#define VMIN 6
#define VSWTC 7
#define VSTART 8
#define VSTOP 9
#define VSUSP 10
#define VEOL 11
#define VREPRINT 12
#define VDISCARD 13
#define VWERASE 14
#define VLNEXT 15
#define VEOL2 16
#define IGNBRK 0000001
#define BRKINT 0000002
#define IGNPAR 0000004
#define PARMRK 0000010
#define INPCK 0000020
#define ISTRIP 0000040
#define INLCR 0000100
#define IGNCR 0000200
#define ICRNL 0000400
#define IUCLC 0001000
#define IXON 0002000
#define IXANY 0004000
#define IXOFF 0010000
#define IMAXBEL 0020000
#define IUTF8 0040000
#define OPOST 0000001
#define OLCUC 0000002
#define ONLCR 0000004
#define OCRNL 0000010
#define ONOCR 0000020
#define ONLRET 0000040
#define OFILL 0000100
#define OFDEL 0000200
#define NLDLY 0000400
#define NL0 0000000
#define NL1 0000400
#define CRDLY 0003000
#define CR0 0000000
#define CR1 0001000
#define CR2 0002000
#define CR3 0003000
#define TABDLY 0014000
#define TAB0 0000000
#define TAB1 0004000
#define TAB2 0010000
#define TAB3 0014000
#define BSDLY 0020000
#define BS0 0000000
#define BS1 0020000
#define FFDLY 0100000
#define FF0 0000000
#define FF1 0100000
#define VTDLY 0040000
#define VT0 0000000
#define VT1 0040000
#define XTABS 0014000
#define CBAUD 0010017
#define B0 0000000
#define B50 0000001
#define B75 0000002
#define B110 0000003
#define B134 0000004
#define B150 0000005
#define B200 0000006
#define B300 0000007
#define B600 0000010
#define B1200 0000011
#define B1800 0000012
#define B2400 0000013
#define B4800 0000014
#define B9600 0000015
#define B19200 0000016
#define B38400 0000017
#define EXTA B19200
#define EXTB B38400
#define CSIZE 0000060
#define CS5 0000000
#define CS6 0000020
#define CS7 0000040
#define CS8 0000060
#define CSTOPB 0000100
#define CREAD 0000200
#define PARENB 0000400
#define PARODD 0001000
#define HUPCL 0002000
#define CLOCAL 0004000
#define CBAUDEX 0010000
#define B57600 0010001
#define B115200 0010002
#define B230400 0010003
#define B460800 0010004
#define B500000 0010005
#define B576000 0010006
#define B921600 0010007
#define B1000000 0010010
#define B1152000 0010011
#define B1500000 0010012
#define B2000000 0010013
#define B2500000 0010014
#define B3000000 0010015
#define B3500000 0010016
#define B4000000 0010017
#define __MAX_BAUD B4000000
#define CIBAUD 002003600000
#define CMSPAR 010000000000
#define CRTSCTS 020000000000
#define ISIG 0000001
#define ICANON 0000002
#define XCASE 0000004
#define ECHO 0000010
#define ECHOE 0000020
#define ECHOK 0000040
#define ECHONL 0000100
#define NOFLSH 0000200
#define TOSTOP 0000400
#define ECHOCTL 0001000
#define ECHOPRT 0002000
#define ECHOKE 0004000
#define FLUSHO 0010000
#define PENDIN 0040000
#define IEXTEN 0100000
#define EXTPROC 0200000
#define TCOOFF 0
#define TCOON 1
#define TCIOFF 2
#define TCION 3
#define TCIFLUSH 0
#define TCOFLUSH 1
#define TCIOFLUSH 2
#define TCSANOW 0
#define TCSADRAIN 1
#define TCSAFLUSH 2
#define _IOT_termios _IOT (_IOTS (cflag_t), 4, _IOTS (cc_t), NCCS, _IOTS (speed_t), 2)
#define CCEQ(val,c) ((c) == (val) && (val) != _POSIX_VDISABLE)
extern speed_t cfgetospeed (const struct termios *__termios_p) throw ();
extern speed_t cfgetispeed (const struct termios *__termios_p) throw ();
extern int cfsetospeed (struct termios *__termios_p, speed_t __speed) throw ();
extern int cfsetispeed (struct termios *__termios_p, speed_t __speed) throw ();
extern int cfsetspeed (struct termios *__termios_p, speed_t __speed) throw ();
extern int tcgetattr (int __fd, struct termios *__termios_p) throw ();
extern int tcsetattr (int __fd, int __optional_actions,
const struct termios *__termios_p) throw ();
extern void cfmakeraw (struct termios *__termios_p) throw ();
extern int tcsendbreak (int __fd, int __duration) throw ();
extern int tcdrain (int __fd);
extern int tcflush (int __fd, int __queue_selector) throw ();
extern int tcflow (int __fd, int __action) throw ();
extern __pid_t tcgetsid (int __fd) throw ();
}
#define BOOST_ASIO_OPTION_STORAGE termios
namespace boost {
namespace asio {
class serial_port_base
{
public:
class baud_rate
{
public:
explicit baud_rate(unsigned int rate = 0);
unsigned int value() const;
inline boost::system::error_code store(
termios& storage,
boost::system::error_code& ec) const;
inline boost::system::error_code load(
const termios& storage,
boost::system::error_code& ec);
private:
unsigned int value_;
};
class flow_control
{
public:
enum type { none, software, hardware };
inline explicit flow_control(type t = none);
type value() const;
inline boost::system::error_code store(
termios& storage,
boost::system::error_code& ec) const;
inline boost::system::error_code load(
const termios& storage,
boost::system::error_code& ec);
private:
type value_;
};
class parity
{
public:
enum type { none, odd, even };
inline explicit parity(type t = none);
type value() const;
inline boost::system::error_code store(
termios& storage,
boost::system::error_code& ec) const;
inline boost::system::error_code load(
const termios& storage,
boost::system::error_code& ec);
private:
type value_;
};
class stop_bits
{
public:
enum type { one, onepointfive, two };
inline explicit stop_bits(type t = one);
type value() const;
inline boost::system::error_code store(
termios& storage,
boost::system::error_code& ec) const;
inline boost::system::error_code load(
const termios& storage,
boost::system::error_code& ec);
private:
type value_;
};
class character_size
{
public:
inline explicit character_size(unsigned int t = 8);
unsigned int value() const;
inline boost::system::error_code store(
termios& storage,
boost::system::error_code& ec) const;
inline boost::system::error_code load(
const termios& storage,
boost::system::error_code& ec);
private:
unsigned int value_;
};
protected:
~serial_port_base()
;
};
}
}
#undef BOOST_ASIO_OPTION_STORAGE
#define BOOST_ASIO_IMPL_SERIAL_PORT_BASE_HPP
namespace boost {
namespace asio {
}
}
#define BOOST_ASIO_IMPL_SERIAL_PORT_BASE_IPP
#define BOOST_ASIO_OPTION_STORAGE termios
namespace boost {
namespace asio {
}
}
#undef BOOST_ASIO_OPTION_STORAGE
#define BOOST_ASIO_SERIAL_PORT_SERVICE_HPP
#define BOOST_ASIO_DETAIL_REACTIVE_SERIAL_PORT_SERVICE_HPP
#define BOOST_ASIO_DETAIL_DESCRIPTOR_OPS_HPP
namespace boost {
namespace asio {
namespace detail {
namespace descriptor_ops {
enum
{
user_set_non_blocking = 1,
internal_non_blocking = 2,
non_blocking = user_set_non_blocking | internal_non_blocking,
possible_dup = 4
};
typedef unsigned char state_type;
template <typename ReturnType>
ReturnType error_wrapper(ReturnType return_value,
boost::system::error_code& ec)
;
inline int open(const char* path, int flags,
boost::system::error_code& ec);
inline int close(int d, state_type& state,
boost::system::error_code& ec);
inline bool set_user_non_blocking(int d,
state_type& state, bool value, boost::system::error_code& ec);
inline bool set_internal_non_blocking(int d,
state_type& state, bool value, boost::system::error_code& ec);
typedef iovec buf;
inline std::size_t sync_read(int d, state_type state, buf* bufs,
std::size_t count, bool all_empty, boost::system::error_code& ec);
inline bool non_blocking_read(int d, buf* bufs, std::size_t count,
boost::system::error_code& ec, std::size_t& bytes_transferred);
inline std::size_t sync_write(int d, state_type state,
const buf* bufs, std::size_t count, bool all_empty,
boost::system::error_code& ec);
inline bool non_blocking_write(int d,
const buf* bufs, std::size_t count,
boost::system::error_code& ec, std::size_t& bytes_transferred);
inline int ioctl(int d, state_type& state, long cmd,
ioctl_arg_type* arg, boost::system::error_code& ec);
inline int fcntl(int d, int cmd, boost::system::error_code& ec);
inline int fcntl(int d, int cmd,
long arg, boost::system::error_code& ec);
inline int poll_read(int d,
state_type state, boost::system::error_code& ec);
inline int poll_write(int d,
state_type state, boost::system::error_code& ec);
}
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_DESCRIPTOR_OPS_IPP
#undef __need_error_t
namespace boost {
namespace asio {
namespace detail {
namespace descriptor_ops {
int open(const char* path, int flags, boost::system::error_code& ec)
;
int close(int d, state_type& state, boost::system::error_code& ec)
;
bool set_user_non_blocking(int d, state_type& state,
bool value, boost::system::error_code& ec)
;
bool set_internal_non_blocking(int d, state_type& state,
bool value, boost::system::error_code& ec)
;
std::size_t sync_read(int d, state_type state, buf* bufs,
std::size_t count, bool all_empty, boost::system::error_code& ec)
;
bool non_blocking_read(int d, buf* bufs, std::size_t count,
boost::system::error_code& ec, std::size_t& bytes_transferred)
;
std::size_t sync_write(int d, state_type state, const buf* bufs,
std::size_t count, bool all_empty, boost::system::error_code& ec)
;
bool non_blocking_write(int d, const buf* bufs, std::size_t count,
boost::system::error_code& ec, std::size_t& bytes_transferred)
;
int ioctl(int d, state_type& state, long cmd,
ioctl_arg_type* arg, boost::system::error_code& ec)
;
int fcntl(int d, int cmd, boost::system::error_code& ec)
;
int fcntl(int d, int cmd, long arg, boost::system::error_code& ec)
;
int poll_read(int d, state_type state, boost::system::error_code& ec)
;
int poll_write(int d, state_type state, boost::system::error_code& ec)
;
}
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_DESCRIPTOR_SERVICE_HPP
#define BOOST_ASIO_DETAIL_DESCRIPTOR_READ_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename MutableBufferSequence>
class descriptor_read_op_base : public reactor_op
{
public:
descriptor_read_op_base(int descriptor,
const MutableBufferSequence& buffers, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
int descriptor_;
MutableBufferSequence buffers_;
};
template <typename MutableBufferSequence, typename Handler>
class descriptor_read_op
: public descriptor_read_op_base<MutableBufferSequence>
{
public:
struct ptr { Handler* h; void* v; descriptor_read_op* p; ~ptr() ; void reset() ; };
descriptor_read_op(int descriptor,
const MutableBufferSequence& buffers, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_DESCRIPTOR_WRITE_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename ConstBufferSequence>
class descriptor_write_op_base : public reactor_op
{
public:
descriptor_write_op_base(int descriptor,
const ConstBufferSequence& buffers, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
int descriptor_;
ConstBufferSequence buffers_;
};
template <typename ConstBufferSequence, typename Handler>
class descriptor_write_op
: public descriptor_write_op_base<ConstBufferSequence>
{
public:
struct ptr { Handler* h; void* v; descriptor_write_op* p; ~ptr() ; void reset() ; };
descriptor_write_op(int descriptor,
const ConstBufferSequence& buffers, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
class reactive_descriptor_service
{
public:
typedef int native_handle_type;
class implementation_type
: private boost::asio::detail::noncopyable
{
public:
implementation_type()
;
private:
friend class reactive_descriptor_service;
int descriptor_;
descriptor_ops::state_type state_;
reactor::per_descriptor_data reactor_data_;
};
inline reactive_descriptor_service(
boost::asio::io_service& io_service);
inline void shutdown_service();
inline void construct(implementation_type& impl);
inline void move_construct(implementation_type& impl,
implementation_type& other_impl);
inline void move_assign(implementation_type& impl,
reactive_descriptor_service& other_service,
implementation_type& other_impl);
inline void destroy(implementation_type& impl);
inline boost::system::error_code assign(implementation_type& impl,
const native_handle_type& native_descriptor,
boost::system::error_code& ec);
bool is_open(const implementation_type& impl) const
;
inline boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec);
native_handle_type native_handle(const implementation_type& impl) const
;
inline native_handle_type release(implementation_type& impl);
inline boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec);
template <typename IO_Control_Command>
boost::system::error_code io_control(implementation_type& impl,
IO_Control_Command& command, boost::system::error_code& ec)
;
bool non_blocking(const implementation_type& impl) const
;
boost::system::error_code non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const implementation_type& impl) const
;
boost::system::error_code native_non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
size_t write_some(implementation_type& impl,
const ConstBufferSequence& buffers, boost::system::error_code& ec)
;
size_t write_some(implementation_type& impl,
const null_buffers&, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename Handler>
void async_write_some(implementation_type& impl,
const ConstBufferSequence& buffers, Handler& handler)
;
template <typename Handler>
void async_write_some(implementation_type& impl,
const null_buffers&, Handler& handler)
;
template <typename MutableBufferSequence>
size_t read_some(implementation_type& impl,
const MutableBufferSequence& buffers, boost::system::error_code& ec)
;
size_t read_some(implementation_type& impl,
const null_buffers&, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename Handler>
void async_read_some(implementation_type& impl,
const MutableBufferSequence& buffers, Handler& handler)
;
template <typename Handler>
void async_read_some(implementation_type& impl,
const null_buffers&, Handler& handler)
;
private:
inline void start_op(implementation_type& impl, int op_type,
reactor_op* op, bool is_continuation, bool is_non_blocking, bool noop);
reactor& reactor_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_REACTIVE_DESCRIPTOR_SERVICE_IPP
namespace boost {
namespace asio {
namespace detail {
}
}
}
namespace boost {
namespace asio {
namespace detail {
class reactive_serial_port_service
{
public:
typedef reactive_descriptor_service::native_handle_type native_handle_type;
typedef reactive_descriptor_service::implementation_type implementation_type;
inline reactive_serial_port_service(
boost::asio::io_service& io_service);
inline void shutdown_service();
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
reactive_serial_port_service& other_service,
implementation_type& other_impl)
;
void destroy(implementation_type& impl)
;
inline boost::system::error_code open(implementation_type& impl,
const std::string& device, boost::system::error_code& ec);
boost::system::error_code assign(implementation_type& impl,
const native_handle_type& native_descriptor,
boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_handle_type native_handle(implementation_type& impl)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
template <typename SettableSerialPortOption>
boost::system::error_code set_option(implementation_type& impl,
const SettableSerialPortOption& option, boost::system::error_code& ec)
;
template <typename GettableSerialPortOption>
boost::system::error_code get_option(const implementation_type& impl,
GettableSerialPortOption& option, boost::system::error_code& ec) const
;
boost::system::error_code send_break(implementation_type& impl,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
size_t write_some(implementation_type& impl,
const ConstBufferSequence& buffers, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename Handler>
void async_write_some(implementation_type& impl,
const ConstBufferSequence& buffers, Handler& handler)
;
template <typename MutableBufferSequence>
size_t read_some(implementation_type& impl,
const MutableBufferSequence& buffers, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename Handler>
void async_read_some(implementation_type& impl,
const MutableBufferSequence& buffers, Handler& handler)
;
private:
typedef boost::system::error_code (*store_function_type)(
const void*, termios&, boost::system::error_code&);
template <typename SettableSerialPortOption>
static boost::system::error_code store_option(const void* option,
termios& storage, boost::system::error_code& ec)
;
inline boost::system::error_code do_set_option(
implementation_type& impl, store_function_type store,
const void* option, boost::system::error_code& ec);
typedef boost::system::error_code (*load_function_type)(
void*, const termios&, boost::system::error_code&);
template <typename GettableSerialPortOption>
static boost::system::error_code load_option(void* option,
const termios& storage, boost::system::error_code& ec)
;
inline boost::system::error_code do_get_option(
const implementation_type& impl, load_function_type load,
void* option, boost::system::error_code& ec) const;
reactive_descriptor_service descriptor_service_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_REACTIVE_SERIAL_PORT_SERVICE_IPP
namespace boost {
namespace asio {
namespace detail {
}
}
}
#define BOOST_ASIO_DETAIL_WIN_IOCP_SERIAL_PORT_SERVICE_HPP
namespace boost {
namespace asio {
class serial_port_service
: public boost::asio::detail::service_base<serial_port_service>
{
public:
private:
typedef detail::reactive_serial_port_service service_impl_type;
public:
typedef service_impl_type::implementation_type implementation_type;
typedef service_impl_type::native_handle_type native_type;
typedef service_impl_type::native_handle_type native_handle_type;
explicit serial_port_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
serial_port_service& other_service,
implementation_type& other_impl)
;
void destroy(implementation_type& impl)
;
boost::system::error_code open(implementation_type& impl,
const std::string& device, boost::system::error_code& ec)
;
boost::system::error_code assign(implementation_type& impl,
const native_handle_type& handle, boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_type native(implementation_type& impl)
;
native_handle_type native_handle(implementation_type& impl)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
template <typename SettableSerialPortOption>
boost::system::error_code set_option(implementation_type& impl,
const SettableSerialPortOption& option, boost::system::error_code& ec)
;
template <typename GettableSerialPortOption>
boost::system::error_code get_option(const implementation_type& impl,
GettableSerialPortOption& option, boost::system::error_code& ec) const
;
boost::system::error_code send_break(implementation_type& impl,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t write_some(implementation_type& impl,
const ConstBufferSequence& buffers, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(implementation_type& impl,
const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t read_some(implementation_type& impl,
const MutableBufferSequence& buffers, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(implementation_type& impl,
const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename SerialPortService = serial_port_service>
class basic_serial_port
: public basic_io_object<SerialPortService>,
public serial_port_base
{
public:
typedef typename SerialPortService::native_handle_type native_type;
typedef typename SerialPortService::native_handle_type native_handle_type;
typedef basic_serial_port<SerialPortService> lowest_layer_type;
explicit basic_serial_port(boost::asio::io_service& io_service)
;
explicit basic_serial_port(boost::asio::io_service& io_service,
const char* device)
;
explicit basic_serial_port(boost::asio::io_service& io_service,
const std::string& device)
;
basic_serial_port(boost::asio::io_service& io_service,
const native_handle_type& native_serial_port)
;
basic_serial_port(basic_serial_port&& other)
;
basic_serial_port& operator=(basic_serial_port&& other)
;
lowest_layer_type& lowest_layer()
;
const lowest_layer_type& lowest_layer() const
;
void open(const std::string& device)
;
boost::system::error_code open(const std::string& device,
boost::system::error_code& ec)
;
void assign(const native_handle_type& native_serial_port)
;
boost::system::error_code assign(const native_handle_type& native_serial_port,
boost::system::error_code& ec)
;
bool is_open() const
;
void close()
;
boost::system::error_code close(boost::system::error_code& ec)
;
native_type native()
;
native_handle_type native_handle()
;
void cancel()
;
boost::system::error_code cancel(boost::system::error_code& ec)
;
void send_break()
;
boost::system::error_code send_break(boost::system::error_code& ec)
;
template <typename SettableSerialPortOption>
void set_option(const SettableSerialPortOption& option)
;
template <typename SettableSerialPortOption>
boost::system::error_code set_option(const SettableSerialPortOption& option,
boost::system::error_code& ec)
;
template <typename GettableSerialPortOption>
void get_option(GettableSerialPortOption& option)
;
template <typename GettableSerialPortOption>
boost::system::error_code get_option(GettableSerialPortOption& option,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
};
}
}
#define BOOST_ASIO_BASIC_SIGNAL_SET_HPP
#define BOOST_ASIO_SIGNAL_SET_SERVICE_HPP
#define BOOST_ASIO_DETAIL_SIGNAL_SET_SERVICE_HPP
#define _SIGNAL_H
extern "C" {
#define _SIGSET_H_fns 1
#define _EXTERN_INLINE __extern_inline
#define __sigmask(sig) (((unsigned long int) 1) << (((sig) - 1) % (8 * sizeof (unsigned long int))))
#define __sigword(sig) (((sig) - 1) / (8 * sizeof (unsigned long int)))
#define __sigemptyset(set) (__extension__ ({ int __cnt = _SIGSET_NWORDS; sigset_t *__set = (set); while (--__cnt >= 0) __set->__val[__cnt] = 0; 0; }))
#define __sigfillset(set) (__extension__ ({ int __cnt = _SIGSET_NWORDS; sigset_t *__set = (set); while (--__cnt >= 0) __set->__val[__cnt] = ~0UL; 0; }))
#define __sigisemptyset(set) (__extension__ ({ int __cnt = _SIGSET_NWORDS; const sigset_t *__set = (set); int __ret = __set->__val[--__cnt]; while (!__ret && --__cnt >= 0) __ret = __set->__val[__cnt]; __ret == 0; }))
#define __sigandset(dest,left,right) (__extension__ ({ int __cnt = _SIGSET_NWORDS; sigset_t *__dest = (dest); const sigset_t *__left = (left); const sigset_t *__right = (right); while (--__cnt >= 0) __dest->__val[__cnt] = (__left->__val[__cnt] & __right->__val[__cnt]); 0; }))
#define __sigorset(dest,left,right) (__extension__ ({ int __cnt = _SIGSET_NWORDS; sigset_t *__dest = (dest); const sigset_t *__left = (left); const sigset_t *__right = (right); while (--__cnt >= 0) __dest->__val[__cnt] = (__left->__val[__cnt] | __right->__val[__cnt]); 0; }))
extern int __sigismember (const __sigset_t *, int);
extern int __sigaddset (__sigset_t *, int);
extern int __sigdelset (__sigset_t *, int);
#define __sig_atomic_t_defined
typedef __sig_atomic_t sig_atomic_t;
#undef __need_sig_atomic_t
#undef __need_sigset_t
#define SIG_ERR ((__sighandler_t) -1)
#define SIG_DFL ((__sighandler_t) 0)
#define SIG_IGN ((__sighandler_t) 1)
#define SIG_HOLD ((__sighandler_t) 2)
#define SIGHUP 1
#define SIGINT 2
#define SIGQUIT 3
#define SIGILL 4
#define SIGTRAP 5
#define SIGABRT 6
#define SIGIOT 6
#define SIGBUS 7
#define SIGFPE 8
#define SIGKILL 9
#define SIGUSR1 10
#define SIGSEGV 11
#define SIGUSR2 12
#define SIGPIPE 13
#define SIGALRM 14
#define SIGTERM 15
#define SIGSTKFLT 16
#define SIGCLD SIGCHLD
#define SIGCHLD 17
#define SIGCONT 18
#define SIGSTOP 19
#define SIGTSTP 20
#define SIGTTIN 21
#define SIGTTOU 22
#define SIGURG 23
#define SIGXCPU 24
#define SIGXFSZ 25
#define SIGVTALRM 26
#define SIGPROF 27
#define SIGWINCH 28
#define SIGPOLL SIGIO
#define SIGIO 29
#define SIGPWR 30
#define SIGSYS 31
#define SIGUNUSED 31
#define _NSIG 65
#define SIGRTMIN (__libc_current_sigrtmin ())
#define SIGRTMAX (__libc_current_sigrtmax ())
#define __SIGRTMIN 32
#define __SIGRTMAX (_NSIG - 1)
#define __need_timespec
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
#define __have_siginfo_t 1
#define __SI_MAX_SIZE 128
#define __SI_PAD_SIZE ((__SI_MAX_SIZE / sizeof (int)) - 4)
typedef __clock_t __sigchld_clock_t;
#define __SI_ALIGNMENT
typedef struct
{
int si_signo;
int si_errno;
int si_code;
union
{
int _pad[((128 / sizeof (int)) - 4)];
struct
{
__pid_t si_pid;
__uid_t si_uid;
} _kill;
struct
{
int si_tid;
int si_overrun;
sigval_t si_sigval;
} _timer;
struct
{
__pid_t si_pid;
__uid_t si_uid;
sigval_t si_sigval;
} _rt;
struct
{
__pid_t si_pid;
__uid_t si_uid;
int si_status;
__sigchld_clock_t si_utime;
__sigchld_clock_t si_stime;
} _sigchld;
struct
{
void *si_addr;
short int si_addr_lsb;
} _sigfault;
struct
{
long int si_band;
int si_fd;
} _sigpoll;
struct
{
void *_call_addr;
int _syscall;
unsigned int _arch;
} _sigsys;
} _sifields;
} siginfo_t ;
#define si_pid _sifields._kill.si_pid
#define si_uid _sifields._kill.si_uid
#define si_timerid _sifields._timer.si_tid
#define si_overrun _sifields._timer.si_overrun
#define si_status _sifields._sigchld.si_status
#define si_utime _sifields._sigchld.si_utime
#define si_stime _sifields._sigchld.si_stime
#define si_value _sifields._rt.si_sigval
#define si_int _sifields._rt.si_sigval.sival_int
#define si_ptr _sifields._rt.si_sigval.sival_ptr
#define si_addr _sifields._sigfault.si_addr
#define si_addr_lsb _sifields._sigfault.si_addr_lsb
#define si_band _sifields._sigpoll.si_band
#define si_fd _sifields._sigpoll.si_fd
#define si_call_addr _sifields._sigsys._call_addr
#define si_syscall _sifields._sigsys._syscall
#define si_arch _sifields._sigsys._arch
enum
{
SI_ASYNCNL = -60,
#define SI_ASYNCNL SI_ASYNCNL
SI_TKILL = -6,
#define SI_TKILL SI_TKILL
SI_SIGIO,
#define SI_SIGIO SI_SIGIO
SI_ASYNCIO,
#define SI_ASYNCIO SI_ASYNCIO
SI_MESGQ,
#define SI_MESGQ SI_MESGQ
SI_TIMER,
#define SI_TIMER SI_TIMER
SI_QUEUE,
#define SI_QUEUE SI_QUEUE
SI_USER,
#define SI_USER SI_USER
SI_KERNEL = 0x80
#define SI_KERNEL SI_KERNEL
};
enum
{
ILL_ILLOPC = 1,
#define ILL_ILLOPC ILL_ILLOPC
ILL_ILLOPN,
#define ILL_ILLOPN ILL_ILLOPN
ILL_ILLADR,
#define ILL_ILLADR ILL_ILLADR
ILL_ILLTRP,
#define ILL_ILLTRP ILL_ILLTRP
ILL_PRVOPC,
#define ILL_PRVOPC ILL_PRVOPC
ILL_PRVREG,
#define ILL_PRVREG ILL_PRVREG
ILL_COPROC,
#define ILL_COPROC ILL_COPROC
ILL_BADSTK
#define ILL_BADSTK ILL_BADSTK
};
enum
{
FPE_INTDIV = 1,
#define FPE_INTDIV FPE_INTDIV
FPE_INTOVF,
#define FPE_INTOVF FPE_INTOVF
FPE_FLTDIV,
#define FPE_FLTDIV FPE_FLTDIV
FPE_FLTOVF,
#define FPE_FLTOVF FPE_FLTOVF
FPE_FLTUND,
#define FPE_FLTUND FPE_FLTUND
FPE_FLTRES,
#define FPE_FLTRES FPE_FLTRES
FPE_FLTINV,
#define FPE_FLTINV FPE_FLTINV
FPE_FLTSUB
#define FPE_FLTSUB FPE_FLTSUB
};
enum
{
SEGV_MAPERR = 1,
#define SEGV_MAPERR SEGV_MAPERR
SEGV_ACCERR
#define SEGV_ACCERR SEGV_ACCERR
};
enum
{
BUS_ADRALN = 1,
#define BUS_ADRALN BUS_ADRALN
BUS_ADRERR,
#define BUS_ADRERR BUS_ADRERR
BUS_OBJERR,
#define BUS_OBJERR BUS_OBJERR
BUS_MCEERR_AR,
#define BUS_MCEERR_AR BUS_MCEERR_AR
BUS_MCEERR_AO
#define BUS_MCEERR_AO BUS_MCEERR_AO
};
enum
{
TRAP_BRKPT = 1,
#define TRAP_BRKPT TRAP_BRKPT
TRAP_TRACE
#define TRAP_TRACE TRAP_TRACE
};
enum
{
CLD_EXITED = 1,
#define CLD_EXITED CLD_EXITED
CLD_KILLED,
#define CLD_KILLED CLD_KILLED
CLD_DUMPED,
#define CLD_DUMPED CLD_DUMPED
CLD_TRAPPED,
#define CLD_TRAPPED CLD_TRAPPED
CLD_STOPPED,
#define CLD_STOPPED CLD_STOPPED
CLD_CONTINUED
#define CLD_CONTINUED CLD_CONTINUED
};
enum
{
POLL_IN = 1,
#define POLL_IN POLL_IN
POLL_OUT,
#define POLL_OUT POLL_OUT
POLL_MSG,
#define POLL_MSG POLL_MSG
POLL_ERR,
#define POLL_ERR POLL_ERR
POLL_PRI,
#define POLL_PRI POLL_PRI
POLL_HUP
#define POLL_HUP POLL_HUP
};
#undef __need_siginfo_t
typedef void (*__sighandler_t) (int);
extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
throw ();
extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler)
throw ();
extern __sighandler_t signal (int __sig, __sighandler_t __handler)
throw ();
extern __sighandler_t bsd_signal (int __sig, __sighandler_t __handler)
throw ();
extern int kill (__pid_t __pid, int __sig) throw ();
extern int killpg (__pid_t __pgrp, int __sig) throw ();
extern int raise (int __sig) throw ();
extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
throw ();
extern int gsignal (int __sig) throw ();
extern void psignal (int __sig, const char *__s);
extern void psiginfo (const siginfo_t *__pinfo, const char *__s);
extern int __sigpause (int __sig_or_mask, int __is_sig);
extern int sigpause (int __sig) __asm__ ("__xpg_sigpause");
#define sigmask(sig) __sigmask(sig)
extern int sigblock (int __mask) throw () __attribute__ ((__deprecated__));
extern int sigsetmask (int __mask) throw () __attribute__ ((__deprecated__));
extern int siggetmask (void) throw () __attribute__ ((__deprecated__));
#define NSIG _NSIG
typedef __sighandler_t sighandler_t;
typedef __sighandler_t sig_t;
extern int sigemptyset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
extern int sigfillset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
extern int sigaddset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
extern int sigdelset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
extern int sigismember (const sigset_t *__set, int __signo)
throw () __attribute__ ((__nonnull__ (1)));
extern int sigisemptyset (const sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
extern int sigandset (sigset_t *__set, const sigset_t *__left,
const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
extern int sigorset (sigset_t *__set, const sigset_t *__left,
const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
struct sigaction
{
union
{
__sighandler_t sa_handler;
void (*sa_sigaction) (int, siginfo_t *, void *);
}
__sigaction_handler;
#define sa_handler __sigaction_handler.sa_handler
#define sa_sigaction __sigaction_handler.sa_sigaction
__sigset_t sa_mask;
int sa_flags;
void (*sa_restorer) (void);
};
#define SA_NOCLDSTOP 1
#define SA_NOCLDWAIT 2
#define SA_SIGINFO 4
#define SA_ONSTACK 0x08000000
#define SA_RESTART 0x10000000
#define SA_NODEFER 0x40000000
#define SA_RESETHAND 0x80000000
#define SA_INTERRUPT 0x20000000
#define SA_NOMASK SA_NODEFER
#define SA_ONESHOT SA_RESETHAND
#define SA_STACK SA_ONSTACK
#define SIG_BLOCK 0
#define SIG_UNBLOCK 1
#define SIG_SETMASK 2
extern int sigprocmask (int __how, const sigset_t *__restrict __set,
sigset_t *__restrict __oset) throw ();
extern int sigsuspend (const sigset_t *__set) __attribute__ ((__nonnull__ (1)));
extern int sigaction (int __sig, const struct sigaction *__restrict __act,
struct sigaction *__restrict __oact) throw ();
extern int sigpending (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
extern int sigwait (const sigset_t *__restrict __set, int *__restrict __sig)
__attribute__ ((__nonnull__ (1, 2)));
extern int sigwaitinfo (const sigset_t *__restrict __set,
siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1)));
extern int sigtimedwait (const sigset_t *__restrict __set,
siginfo_t *__restrict __info,
const struct timespec *__restrict __timeout)
__attribute__ ((__nonnull__ (1)));
extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val)
throw ();
extern const char *const _sys_siglist[65];
extern const char *const sys_siglist[65];
struct sigvec
{
__sighandler_t sv_handler;
int sv_mask;
int sv_flags;
#define sv_onstack sv_flags
};
#define SV_ONSTACK (1 << 0)
#define SV_INTERRUPT (1 << 1)
#define SV_RESETHAND (1 << 2)
extern int sigvec (int __sig, const struct sigvec *__vec,
struct sigvec *__ovec) throw ();
#define _BITS_SIGCONTEXT_H 1
#define FP_XSTATE_MAGIC1 0x46505853U
#define FP_XSTATE_MAGIC2 0x46505845U
#define FP_XSTATE_MAGIC2_SIZE sizeof(FP_XSTATE_MAGIC2)
struct _fpx_sw_bytes
{
__uint32_t magic1;
__uint32_t extended_size;
__uint64_t xstate_bv;
__uint32_t xstate_size;
__uint32_t padding[7];
};
struct _fpreg
{
unsigned short significand[4];
unsigned short exponent;
};
struct _fpxreg
{
unsigned short significand[4];
unsigned short exponent;
unsigned short padding[3];
};
struct _xmmreg
{
__uint32_t element[4];
};
struct _fpstate
{
__uint16_t cwd;
__uint16_t swd;
__uint16_t ftw;
__uint16_t fop;
__uint64_t rip;
__uint64_t rdp;
__uint32_t mxcsr;
__uint32_t mxcr_mask;
struct _fpxreg _st[8];
struct _xmmreg _xmm[16];
__uint32_t padding[24];
};
struct sigcontext
{
__uint64_t r8;
__uint64_t r9;
__uint64_t r10;
__uint64_t r11;
__uint64_t r12;
__uint64_t r13;
__uint64_t r14;
__uint64_t r15;
__uint64_t rdi;
__uint64_t rsi;
__uint64_t rbp;
__uint64_t rbx;
__uint64_t rdx;
__uint64_t rax;
__uint64_t rcx;
__uint64_t rsp;
__uint64_t rip;
__uint64_t eflags;
unsigned short cs;
unsigned short gs;
unsigned short fs;
unsigned short __pad0;
__uint64_t err;
__uint64_t trapno;
__uint64_t oldmask;
__uint64_t cr2;
__extension__ union
{
struct _fpstate * fpstate;
__uint64_t __fpstate_word;
};
__uint64_t __reserved1 [8];
};
struct _xsave_hdr
{
__uint64_t xstate_bv;
__uint64_t reserved1[2];
__uint64_t reserved2[5];
};
struct _ymmh_state
{
__uint32_t ymmh_space[64];
};
struct _xstate
{
struct _fpstate fpstate;
struct _xsave_hdr xstate_hdr;
struct _ymmh_state ymmh;
};
extern int sigreturn (struct sigcontext *__scp) throw ();
#define __need_size_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
extern int siginterrupt (int __sig, int __interrupt) throw ();
struct sigstack
{
void *ss_sp;
int ss_onstack;
};
enum
{
SS_ONSTACK = 1,
#define SS_ONSTACK SS_ONSTACK
SS_DISABLE
#define SS_DISABLE SS_DISABLE
};
#define MINSIGSTKSZ 2048
#define SIGSTKSZ 8192
typedef struct sigaltstack
{
void *ss_sp;
int ss_flags;
size_t ss_size;
} stack_t;
#define _SYS_UCONTEXT_H 1
__extension__ typedef long long int greg_t;
#define NGREG 23
typedef greg_t gregset_t[23];
enum
{
REG_R8 = 0,
#define REG_R8 REG_R8
REG_R9,
#define REG_R9 REG_R9
REG_R10,
#define REG_R10 REG_R10
REG_R11,
#define REG_R11 REG_R11
REG_R12,
#define REG_R12 REG_R12
REG_R13,
#define REG_R13 REG_R13
REG_R14,
#define REG_R14 REG_R14
REG_R15,
#define REG_R15 REG_R15
REG_RDI,
#define REG_RDI REG_RDI
REG_RSI,
#define REG_RSI REG_RSI
REG_RBP,
#define REG_RBP REG_RBP
REG_RBX,
#define REG_RBX REG_RBX
REG_RDX,
#define REG_RDX REG_RDX
REG_RAX,
#define REG_RAX REG_RAX
REG_RCX,
#define REG_RCX REG_RCX
REG_RSP,
#define REG_RSP REG_RSP
REG_RIP,
#define REG_RIP REG_RIP
REG_EFL,
#define REG_EFL REG_EFL
REG_CSGSFS,
#define REG_CSGSFS REG_CSGSFS
REG_ERR,
#define REG_ERR REG_ERR
REG_TRAPNO,
#define REG_TRAPNO REG_TRAPNO
REG_OLDMASK,
#define REG_OLDMASK REG_OLDMASK
REG_CR2
#define REG_CR2 REG_CR2
};
struct _libc_fpxreg
{
unsigned short int significand[4];
unsigned short int exponent;
unsigned short int padding[3];
};
struct _libc_xmmreg
{
__uint32_t element[4];
};
struct _libc_fpstate
{
__uint16_t cwd;
__uint16_t swd;
__uint16_t ftw;
__uint16_t fop;
__uint64_t rip;
__uint64_t rdp;
__uint32_t mxcsr;
__uint32_t mxcr_mask;
struct _libc_fpxreg _st[8];
struct _libc_xmmreg _xmm[16];
__uint32_t padding[24];
};
typedef struct _libc_fpstate *fpregset_t;
typedef struct
{
gregset_t gregs;
fpregset_t fpregs;
__extension__ unsigned long long __reserved1 [8];
} mcontext_t;
typedef struct ucontext
{
unsigned long int uc_flags;
struct ucontext *uc_link;
stack_t uc_stack;
mcontext_t uc_mcontext;
__sigset_t uc_sigmask;
struct _libc_fpstate __fpregs_mem;
} ucontext_t;
extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
throw () __attribute__ ((__deprecated__));
extern int sigaltstack (const struct sigaltstack *__restrict __ss,
struct sigaltstack *__restrict __oss) throw ();
extern int sighold (int __sig) throw ();
extern int sigrelse (int __sig) throw ();
extern int sigignore (int __sig) throw ();
extern __sighandler_t sigset (int __sig, __sighandler_t __disp) throw ();
#define _BITS_SIGTHREAD_H 1
extern int pthread_sigmask (int __how,
const __sigset_t *__restrict __newmask,
__sigset_t *__restrict __oldmask)throw ();
extern int pthread_kill (pthread_t __threadid, int __signo) throw ();
extern int pthread_sigqueue (pthread_t __threadid, int __signo,
const union sigval __value) throw ();
extern int __libc_current_sigrtmin (void) throw ();
extern int __libc_current_sigrtmax (void) throw ();
}
#define BOOST_ASIO_DETAIL_SIGNAL_HANDLER_HPP
#define BOOST_ASIO_DETAIL_SIGNAL_OP_HPP
namespace boost {
namespace asio {
namespace detail {
class signal_op
: public operation
{
public:
boost::system::error_code ec_;
int signal_number_;
protected:
signal_op(func_type func)
;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Handler>
class signal_handler : public signal_op
{
public:
struct ptr { Handler* h; void* v; signal_handler* p; ~ptr() ; void reset() ; };
signal_handler(Handler& h)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
enum { max_signal_number = 65 };
extern inline struct signal_state* get_signal_state();
extern "C" inline void boost_asio_signal_handler(int signal_number);
class signal_set_service
{
public:
class registration
{
public:
registration()
;
private:
friend class signal_set_service;
int signal_number_;
op_queue<signal_op>* queue_;
std::size_t undelivered_;
registration* next_in_table_;
registration* prev_in_table_;
registration* next_in_set_;
};
class implementation_type
{
public:
implementation_type()
;
private:
friend class signal_set_service;
op_queue<signal_op> queue_;
registration* signals_;
};
inline signal_set_service(boost::asio::io_service& io_service);
inline ~signal_set_service();
inline void shutdown_service();
inline void fork_service(
boost::asio::io_service::fork_event fork_ev);
inline void construct(implementation_type& impl);
inline void destroy(implementation_type& impl);
inline boost::system::error_code add(implementation_type& impl,
int signal_number, boost::system::error_code& ec);
inline boost::system::error_code remove(implementation_type& impl,
int signal_number, boost::system::error_code& ec);
inline boost::system::error_code clear(implementation_type& impl,
boost::system::error_code& ec);
inline boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec);
template <typename Handler>
void async_wait(implementation_type& impl, Handler& handler)
;
inline static void deliver_signal(int signal_number);
private:
inline static void add_service(signal_set_service* service);
inline static void remove_service(signal_set_service* service);
inline static void open_descriptors();
inline static void close_descriptors();
inline void start_wait_op(implementation_type& impl, signal_op* op);
io_service_impl& io_service_;
class pipe_read_op;
reactor& reactor_;
reactor::per_descriptor_data reactor_data_;
registration* registrations_[max_signal_number];
signal_set_service* next_;
signal_set_service* prev_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_SIGNAL_SET_SERVICE_IPP
#define BOOST_ASIO_DETAIL_SIGNAL_BLOCKER_HPP
#define BOOST_ASIO_DETAIL_POSIX_SIGNAL_BLOCKER_HPP
#define _GLIBCXX_CSIGNAL 1
#undef raise
namespace std
{
using ::sig_atomic_t;
using ::signal;
using ::raise;
}
namespace boost {
namespace asio {
namespace detail {
class posix_signal_blocker
: private noncopyable
{
public:
posix_signal_blocker()
;
~posix_signal_blocker()
;
void block()
;
void unblock()
;
private:
bool blocked_;
sigset_t old_mask_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
typedef posix_signal_blocker signal_blocker;
}
}
}
#define BOOST_ASIO_DETAIL_STATIC_MUTEX_HPP
#define BOOST_ASIO_DETAIL_POSIX_STATIC_MUTEX_HPP
namespace boost {
namespace asio {
namespace detail {
struct posix_static_mutex
{
typedef boost::asio::detail::scoped_lock<posix_static_mutex> scoped_lock;
void init()
;
void lock()
;
void unlock()
;
::pthread_mutex_t mutex_;
};
#define BOOST_ASIO_POSIX_STATIC_MUTEX_INIT { PTHREAD_MUTEX_INITIALIZER }
}
}
}
namespace boost {
namespace asio {
namespace detail {
typedef posix_static_mutex static_mutex;
#define BOOST_ASIO_STATIC_MUTEX_INIT BOOST_ASIO_POSIX_STATIC_MUTEX_INIT
}
}
}
namespace boost {
namespace asio {
namespace detail {
struct signal_state
{
static_mutex mutex_;
int read_descriptor_;
int write_descriptor_;
bool fork_prepared_;
class signal_set_service* service_list_;
std::size_t registration_count_[max_signal_number];
};
signal_state* get_signal_state()
;
void boost_asio_signal_handler(int signal_number)
;
class signal_set_service::pipe_read_op : public reactor_op
{
public:
pipe_read_op()
;
static bool do_perform(reactor_op*)
;
static void do_complete(io_service_impl* , operation* base,
const boost::system::error_code& ,
std::size_t )
;
};
}
}
}
namespace boost {
namespace asio {
class signal_set_service
: public boost::asio::detail::service_base<signal_set_service>
{
public:
public:
typedef detail::signal_set_service::implementation_type implementation_type;
explicit signal_set_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void destroy(implementation_type& impl)
;
boost::system::error_code add(implementation_type& impl,
int signal_number, boost::system::error_code& ec)
;
boost::system::error_code remove(implementation_type& impl,
int signal_number, boost::system::error_code& ec)
;
boost::system::error_code clear(implementation_type& impl,
boost::system::error_code& ec)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
template <typename SignalHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<SignalHandler, void (boost::system::error_code, int)>::type>::type
async_wait(implementation_type& impl,
SignalHandler&& handler)
;
private:
void shutdown_service()
;
void fork_service(boost::asio::io_service::fork_event event)
;
detail::signal_set_service service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename SignalSetService = signal_set_service>
class basic_signal_set
: public basic_io_object<SignalSetService>
{
public:
explicit basic_signal_set(boost::asio::io_service& io_service)
;
basic_signal_set(boost::asio::io_service& io_service, int signal_number_1)
;
basic_signal_set(boost::asio::io_service& io_service, int signal_number_1,
int signal_number_2)
;
basic_signal_set(boost::asio::io_service& io_service, int signal_number_1,
int signal_number_2, int signal_number_3)
;
void add(int signal_number)
;
boost::system::error_code add(int signal_number,
boost::system::error_code& ec)
;
void remove(int signal_number)
;
boost::system::error_code remove(int signal_number,
boost::system::error_code& ec)
;
void clear()
;
boost::system::error_code clear(boost::system::error_code& ec)
;
void cancel()
;
boost::system::error_code cancel(boost::system::error_code& ec)
;
template <typename SignalHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<SignalHandler, void (boost::system::error_code, int)>::type>::type
async_wait(SignalHandler&& handler)
;
};
}
}
#define BOOST_ASIO_BASIC_SOCKET_ACCEPTOR_HPP
#define BOOST_ASIO_SOCKET_ACCEPTOR_SERVICE_HPP
namespace boost {
namespace asio {
template <typename Protocol>
class socket_acceptor_service
: public boost::asio::detail::service_base<socket_acceptor_service<Protocol> >
{
public:
typedef Protocol protocol_type;
typedef typename protocol_type::endpoint endpoint_type;
private:
typedef detail::reactive_socket_service<Protocol> service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
typedef typename service_impl_type::native_handle_type native_type;
typedef typename service_impl_type::native_handle_type native_handle_type;
explicit socket_acceptor_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
socket_acceptor_service& other_service,
implementation_type& other_impl)
;
template <typename Protocol1>
void converting_move_construct(implementation_type& impl,
typename socket_acceptor_service<
Protocol1>::implementation_type& other_impl,
typename enable_if<is_convertible<
Protocol1, Protocol>::value>::type* = 0)
;
void destroy(implementation_type& impl)
;
boost::system::error_code open(implementation_type& impl,
const protocol_type& protocol, boost::system::error_code& ec)
;
boost::system::error_code assign(implementation_type& impl,
const protocol_type& protocol, const native_handle_type& native_acceptor,
boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
boost::system::error_code bind(implementation_type& impl,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
boost::system::error_code listen(implementation_type& impl, int backlog,
boost::system::error_code& ec)
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_type native(implementation_type& impl)
;
native_handle_type native_handle(implementation_type& impl)
;
template <typename SettableSocketOption>
boost::system::error_code set_option(implementation_type& impl,
const SettableSocketOption& option, boost::system::error_code& ec)
;
template <typename GettableSocketOption>
boost::system::error_code get_option(const implementation_type& impl,
GettableSocketOption& option, boost::system::error_code& ec) const
;
template <typename IoControlCommand>
boost::system::error_code io_control(implementation_type& impl,
IoControlCommand& command, boost::system::error_code& ec)
;
bool non_blocking(const implementation_type& impl) const
;
boost::system::error_code non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const implementation_type& impl) const
;
boost::system::error_code native_non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
endpoint_type local_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
template <typename Protocol1, typename SocketService>
boost::system::error_code accept(implementation_type& impl,
basic_socket<Protocol1, SocketService>& peer,
endpoint_type* peer_endpoint, boost::system::error_code& ec,
typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
;
template <typename Protocol1, typename SocketService, typename AcceptHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<AcceptHandler, void (boost::system::error_code)>::type>::type
async_accept(implementation_type& impl,
basic_socket<Protocol1, SocketService>& peer,
endpoint_type* peer_endpoint,
AcceptHandler&& handler,
typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename Protocol,
typename SocketAcceptorService = socket_acceptor_service<Protocol> >
class basic_socket_acceptor
: public basic_io_object<SocketAcceptorService>,
public socket_base
{
public:
typedef typename SocketAcceptorService::native_handle_type native_type;
typedef typename SocketAcceptorService::native_handle_type native_handle_type;
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
explicit basic_socket_acceptor(boost::asio::io_service& io_service)
;
basic_socket_acceptor(boost::asio::io_service& io_service,
const protocol_type& protocol)
;
basic_socket_acceptor(boost::asio::io_service& io_service,
const endpoint_type& endpoint, bool reuse_addr = true)
;
basic_socket_acceptor(boost::asio::io_service& io_service,
const protocol_type& protocol, const native_handle_type& native_acceptor)
;
basic_socket_acceptor(basic_socket_acceptor&& other)
;
basic_socket_acceptor& operator=(basic_socket_acceptor&& other)
;
template <typename Protocol1, typename SocketAcceptorService1>
friend class basic_socket_acceptor;
template <typename Protocol1, typename SocketAcceptorService1>
basic_socket_acceptor(
basic_socket_acceptor<Protocol1, SocketAcceptorService1>&& other,
typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
;
template <typename Protocol1, typename SocketAcceptorService1>
typename enable_if<is_convertible<Protocol1, Protocol>::value,
basic_socket_acceptor>::type& operator=(
basic_socket_acceptor<Protocol1, SocketAcceptorService1>&& other)
;
void open(const protocol_type& protocol = protocol_type())
;
boost::system::error_code open(const protocol_type& protocol,
boost::system::error_code& ec)
;
void assign(const protocol_type& protocol,
const native_handle_type& native_acceptor)
;
boost::system::error_code assign(const protocol_type& protocol,
const native_handle_type& native_acceptor, boost::system::error_code& ec)
;
bool is_open() const
;
void bind(const endpoint_type& endpoint)
;
boost::system::error_code bind(const endpoint_type& endpoint,
boost::system::error_code& ec)
;
void listen(int backlog = socket_base::max_connections)
;
boost::system::error_code listen(int backlog, boost::system::error_code& ec)
;
void close()
;
boost::system::error_code close(boost::system::error_code& ec)
;
native_type native()
;
native_handle_type native_handle()
;
void cancel()
;
boost::system::error_code cancel(boost::system::error_code& ec)
;
template <typename SettableSocketOption>
void set_option(const SettableSocketOption& option)
;
template <typename SettableSocketOption>
boost::system::error_code set_option(const SettableSocketOption& option,
boost::system::error_code& ec)
;
template <typename GettableSocketOption>
void get_option(GettableSocketOption& option)
;
template <typename GettableSocketOption>
boost::system::error_code get_option(GettableSocketOption& option,
boost::system::error_code& ec)
;
template <typename IoControlCommand>
void io_control(IoControlCommand& command)
;
template <typename IoControlCommand>
boost::system::error_code io_control(IoControlCommand& command,
boost::system::error_code& ec)
;
bool non_blocking() const
;
void non_blocking(bool mode)
;
boost::system::error_code non_blocking(
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking() const
;
void native_non_blocking(bool mode)
;
boost::system::error_code native_non_blocking(
bool mode, boost::system::error_code& ec)
;
endpoint_type local_endpoint() const
;
endpoint_type local_endpoint(boost::system::error_code& ec) const
;
template <typename Protocol1, typename SocketService>
void accept(basic_socket<Protocol1, SocketService>& peer,
typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
;
template <typename Protocol1, typename SocketService>
boost::system::error_code accept(
basic_socket<Protocol1, SocketService>& peer,
boost::system::error_code& ec,
typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
;
template <typename Protocol1, typename SocketService, typename AcceptHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<AcceptHandler, void (boost::system::error_code)>::type>::type
async_accept(basic_socket<Protocol1, SocketService>& peer,
AcceptHandler&& handler,
typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
;
template <typename SocketService>
void accept(basic_socket<protocol_type, SocketService>& peer,
endpoint_type& peer_endpoint)
;
template <typename SocketService>
boost::system::error_code accept(
basic_socket<protocol_type, SocketService>& peer,
endpoint_type& peer_endpoint, boost::system::error_code& ec)
;
template <typename SocketService, typename AcceptHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<AcceptHandler, void (boost::system::error_code)>::type>::type
async_accept(basic_socket<protocol_type, SocketService>& peer,
endpoint_type& peer_endpoint, AcceptHandler&& handler)
;
};
}
}
#define BOOST_ASIO_BASIC_SOCKET_IOSTREAM_HPP
#define BOOST_ASIO_BASIC_SOCKET_STREAMBUF_HPP
#define BOOST_ASIO_DETAIL_ARRAY_HPP
namespace boost {
namespace asio {
namespace detail {
using std::array;
}
}
}
#define BOOST_ASIO_STREAM_SOCKET_SERVICE_HPP
namespace boost {
namespace asio {
template <typename Protocol>
class stream_socket_service
: public boost::asio::detail::service_base<stream_socket_service<Protocol> >
{
public:
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
private:
typedef detail::reactive_socket_service<Protocol> service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
typedef typename service_impl_type::native_handle_type native_type;
typedef typename service_impl_type::native_handle_type native_handle_type;
explicit stream_socket_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
stream_socket_service& other_service,
implementation_type& other_impl)
;
template <typename Protocol1>
void converting_move_construct(implementation_type& impl,
typename stream_socket_service<
Protocol1>::implementation_type& other_impl,
typename enable_if<is_convertible<
Protocol1, Protocol>::value>::type* = 0)
;
void destroy(implementation_type& impl)
;
boost::system::error_code open(implementation_type& impl,
const protocol_type& protocol, boost::system::error_code& ec)
;
boost::system::error_code assign(implementation_type& impl,
const protocol_type& protocol, const native_handle_type& native_socket,
boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_type native(implementation_type& impl)
;
native_handle_type native_handle(implementation_type& impl)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
bool at_mark(const implementation_type& impl,
boost::system::error_code& ec) const
;
std::size_t available(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code bind(implementation_type& impl,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
boost::system::error_code connect(implementation_type& impl,
const endpoint_type& peer_endpoint, boost::system::error_code& ec)
;
template <typename ConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ConnectHandler, void (boost::system::error_code)>::type>::type
async_connect(implementation_type& impl,
const endpoint_type& peer_endpoint,
ConnectHandler&& handler)
;
template <typename SettableSocketOption>
boost::system::error_code set_option(implementation_type& impl,
const SettableSocketOption& option, boost::system::error_code& ec)
;
template <typename GettableSocketOption>
boost::system::error_code get_option(const implementation_type& impl,
GettableSocketOption& option, boost::system::error_code& ec) const
;
template <typename IoControlCommand>
boost::system::error_code io_control(implementation_type& impl,
IoControlCommand& command, boost::system::error_code& ec)
;
bool non_blocking(const implementation_type& impl) const
;
boost::system::error_code non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const implementation_type& impl) const
;
boost::system::error_code native_non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
endpoint_type local_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
endpoint_type remote_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code shutdown(implementation_type& impl,
socket_base::shutdown_type what, boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t send(implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags,
ReadHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
#define BOOST_ASIO_DEADLINE_TIMER_HPP
namespace boost {
namespace asio {
typedef basic_deadline_timer<boost::posix_time::ptime> deadline_timer;
}
}
namespace boost {
namespace asio {
namespace detail {
class socket_streambuf_base
{
protected:
io_service io_service_;
};
}
template <typename Protocol,
typename StreamSocketService = stream_socket_service<Protocol>,
typename Time = boost::posix_time::ptime,
typename TimeTraits = boost::asio::time_traits<Time>,
typename TimerService = deadline_timer_service<Time, TimeTraits> >
class basic_socket_streambuf
: public std::streambuf,
private detail::socket_streambuf_base,
public basic_socket<Protocol, StreamSocketService>
{
private:
typedef TimeTraits traits_helper;
public:
typedef typename Protocol::endpoint endpoint_type;
typedef typename traits_helper::time_type time_type;
typedef typename traits_helper::duration_type duration_type;
basic_socket_streambuf()
;
virtual ~basic_socket_streambuf()
;
basic_socket_streambuf<Protocol, StreamSocketService,
Time, TimeTraits, TimerService>* connect(
const endpoint_type& endpoint)
;
template <typename... T>
basic_socket_streambuf<Protocol, StreamSocketService,
Time, TimeTraits, TimerService>* connect(T... x)
;
basic_socket_streambuf<Protocol, StreamSocketService,
Time, TimeTraits, TimerService>* close()
;
const boost::system::error_code& puberror() const
;
time_type expires_at() const
;
void expires_at(const time_type& expiry_time)
;
duration_type expires_from_now() const
;
void expires_from_now(const duration_type& expiry_time)
;
protected:
int_type underflow()
;
int_type overflow(int_type c)
;
int sync()
;
std::streambuf* setbuf(char_type* s, std::streamsize n)
;
virtual const boost::system::error_code& error() const
;
private:
void init_buffers()
;
template <typename ResolverQuery>
void resolve_and_connect(const ResolverQuery& query)
;
struct io_handler;
friend struct io_handler;
struct io_handler
{
basic_socket_streambuf* this_;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred = 0)
;
};
struct timer_handler;
friend struct timer_handler;
struct timer_handler
{
basic_socket_streambuf* this_;
void operator()(const boost::system::error_code&)
;
};
void construct_timer()
;
void destroy_timer()
;
void start_timer()
;
enum { putback_max = 8 };
enum { buffer_size = 512 };
boost::asio::detail::array<char, buffer_size> get_buffer_;
boost::asio::detail::array<char, buffer_size> put_buffer_;
bool unbuffered_;
boost::system::error_code ec_;
std::size_t bytes_transferred_;
TimerService* timer_service_;
typename TimerService::implementation_type timer_implementation_;
enum state { no_timer, timer_is_pending, timer_has_expired } timer_state_;
};
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Protocol, typename StreamSocketService,
typename Time, typename TimeTraits, typename TimerService>
class socket_iostream_base
{
protected:
basic_socket_streambuf<Protocol, StreamSocketService,
Time, TimeTraits, TimerService> streambuf_;
};
}
template <typename Protocol,
typename StreamSocketService = stream_socket_service<Protocol>,
typename Time = boost::posix_time::ptime,
typename TimeTraits = boost::asio::time_traits<Time>,
typename TimerService = deadline_timer_service<Time, TimeTraits> >
class basic_socket_iostream
: private detail::socket_iostream_base<Protocol,
StreamSocketService, Time, TimeTraits, TimerService>,
public std::basic_iostream<char>
{
private:
typedef TimeTraits traits_helper;
public:
typedef typename Protocol::endpoint endpoint_type;
typedef typename traits_helper::time_type time_type;
typedef typename traits_helper::duration_type duration_type;
basic_socket_iostream()
;
template <typename... T>
explicit basic_socket_iostream(T... x)
;
template <typename... T>
void connect(T... x)
;
void close()
;
basic_socket_streambuf<Protocol, StreamSocketService,
Time, TimeTraits, TimerService>* rdbuf() const
;
const boost::system::error_code& error() const
;
time_type expires_at() const
;
void expires_at(const time_type& expiry_time)
;
duration_type expires_from_now() const
;
void expires_from_now(const duration_type& expiry_time)
;
};
}
}
#define BOOST_ASIO_BASIC_STREAM_SOCKET_HPP
namespace boost {
namespace asio {
template <typename Protocol,
typename StreamSocketService = stream_socket_service<Protocol> >
class basic_stream_socket
: public basic_socket<Protocol, StreamSocketService>
{
public:
typedef typename StreamSocketService::native_handle_type native_type;
typedef typename StreamSocketService::native_handle_type native_handle_type;
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
explicit basic_stream_socket(boost::asio::io_service& io_service)
;
basic_stream_socket(boost::asio::io_service& io_service,
const protocol_type& protocol)
;
basic_stream_socket(boost::asio::io_service& io_service,
const endpoint_type& endpoint)
;
basic_stream_socket(boost::asio::io_service& io_service,
const protocol_type& protocol, const native_handle_type& native_socket)
;
basic_stream_socket(basic_stream_socket&& other)
;
basic_stream_socket& operator=(basic_stream_socket&& other)
;
template <typename Protocol1, typename StreamSocketService1>
basic_stream_socket(
basic_stream_socket<Protocol1, StreamSocketService1>&& other,
typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
;
template <typename Protocol1, typename StreamSocketService1>
typename enable_if<is_convertible<Protocol1, Protocol>::value,
basic_stream_socket>::type& operator=(
basic_stream_socket<Protocol1, StreamSocketService1>&& other)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags,
ReadHandler&& handler)
{
typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
return this->get_service().async_receive(this->get_implementation(),
buffers, flags, static_cast<ReadHandler&&>(handler));
}
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers)
{
boost::system::error_code ec;
std::size_t s = this->get_service().send(
this->get_implementation(), buffers, 0, ec);
boost::asio::detail::throw_error(ec, "write_some");
return s;
}
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers,
boost::system::error_code& ec)
{
return this->get_service().send(this->get_implementation(), buffers, 0, ec);
}
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(const ConstBufferSequence& buffers,
WriteHandler&& handler)
{
typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
return this->get_service().async_send(this->get_implementation(),
buffers, 0, static_cast<WriteHandler&&>(handler));
}
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers)
{
boost::system::error_code ec;
std::size_t s = this->get_service().receive(
this->get_implementation(), buffers, 0, ec);
boost::asio::detail::throw_error(ec, "read_some");
return s;
}
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers,
boost::system::error_code& ec)
{
return this->get_service().receive(
this->get_implementation(), buffers, 0, ec);
}
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(const MutableBufferSequence& buffers,
ReadHandler&& handler)
{
typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
return this->get_service().async_receive(this->get_implementation(),
buffers, 0, static_cast<ReadHandler&&>(handler));
}
};
}
}
#define BOOST_ASIO_BASIC_STREAMBUF_HPP
#define BOOST_ASIO_BASIC_STREAMBUF_FWD_HPP
namespace boost {
namespace asio {
template <typename Allocator = std::allocator<char> >
class basic_streambuf;
}
}
namespace boost {
namespace asio {
template <typename Allocator>
class basic_streambuf
: public std::streambuf,
private noncopyable
{
public:
typedef boost::asio::const_buffers_1 const_buffers_type;
typedef boost::asio::mutable_buffers_1 mutable_buffers_type;
explicit basic_streambuf(
std::size_t maximum_size = (std::numeric_limits<std::size_t>::max)(),
const Allocator& allocator = Allocator())
: max_size_(maximum_size),
buffer_(allocator)
{
std::size_t pend = (std::min<std::size_t>)(max_size_, buffer_delta);
buffer_.resize((std::max<std::size_t>)(pend, 1));
setg(&buffer_[0], &buffer_[0], &buffer_[0]);
setp(&buffer_[0], &buffer_[0] + pend);
}
std::size_t size() const
{
return pptr() - gptr();
}
std::size_t max_size() const
{
return max_size_;
}
const_buffers_type data() const
;
mutable_buffers_type prepare(std::size_t n)
;
void commit(std::size_t n)
;
void consume(std::size_t n)
;
protected:
enum { buffer_delta = 128 };
int_type underflow()
;
int_type overflow(int_type c)
;
void reserve(std::size_t n)
;
private:
std::size_t max_size_;
std::vector<char_type, Allocator> buffer_;
friend std::size_t read_size_helper(
basic_streambuf& sb, std::size_t max_size)
;
};
template <typename Allocator>
std::size_t read_size_helper(
basic_streambuf<Allocator>& sb, std::size_t max_size)
;
}
}
#define BOOST_ASIO_BASIC_WAITABLE_TIMER_HPP
#define BOOST_ASIO_WAIT_TRAITS_HPP
namespace boost {
namespace asio {
template <typename Clock>
struct wait_traits
{
static typename Clock::duration to_wait_duration(
const typename Clock::duration& d)
;
};
}
}
#define BOOST_ASIO_WAITABLE_TIMER_SERVICE_HPP
#define BOOST_ASIO_DETAIL_CHRONO_TIME_TRAITS_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Clock, typename WaitTraits>
struct chrono_time_traits
{
typedef Clock clock_type;
typedef typename clock_type::duration duration_type;
typedef typename clock_type::time_point time_type;
typedef typename duration_type::period period_type;
static time_type now()
;
static time_type add(const time_type& t, const duration_type& d)
;
static duration_type subtract(const time_type& t1, const time_type& t2)
;
static bool less_than(const time_type& t1, const time_type& t2)
;
class posix_time_duration
{
public:
explicit posix_time_duration(const duration_type& d)
;
int64_t ticks() const
;
int64_t total_seconds() const
;
int64_t total_milliseconds() const
;
int64_t total_microseconds() const
;
private:
template <int64_t Num, int64_t Den>
int64_t duration_cast() const
;
duration_type d_;
};
static posix_time_duration to_posix_duration(const duration_type& d)
;
};
}
}
}
namespace boost {
namespace asio {
template <typename Clock,
typename WaitTraits = boost::asio::wait_traits<Clock> >
class waitable_timer_service
: public boost::asio::detail::service_base<
waitable_timer_service<Clock, WaitTraits> >
{
public:
typedef Clock clock_type;
typedef typename clock_type::duration duration;
typedef typename clock_type::time_point time_point;
typedef WaitTraits traits_type;
private:
typedef detail::deadline_timer_service<
detail::chrono_time_traits<Clock, WaitTraits> > service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
explicit waitable_timer_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void destroy(implementation_type& impl)
;
std::size_t cancel(implementation_type& impl, boost::system::error_code& ec)
;
std::size_t cancel_one(implementation_type& impl,
boost::system::error_code& ec)
;
time_point expires_at(const implementation_type& impl) const
;
std::size_t expires_at(implementation_type& impl,
const time_point& expiry_time, boost::system::error_code& ec)
;
duration expires_from_now(const implementation_type& impl) const
;
std::size_t expires_from_now(implementation_type& impl,
const duration& expiry_time, boost::system::error_code& ec)
;
void wait(implementation_type& impl, boost::system::error_code& ec)
;
template <typename WaitHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WaitHandler, void (boost::system::error_code)>::type>::type
async_wait(implementation_type& impl,
WaitHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename Clock,
typename WaitTraits = boost::asio::wait_traits<Clock>,
typename WaitableTimerService = waitable_timer_service<Clock, WaitTraits> >
class basic_waitable_timer
: public basic_io_object<WaitableTimerService>
{
public:
typedef Clock clock_type;
typedef typename clock_type::duration duration;
typedef typename clock_type::time_point time_point;
typedef WaitTraits traits_type;
explicit basic_waitable_timer(boost::asio::io_service& io_service)
;
basic_waitable_timer(boost::asio::io_service& io_service,
const time_point& expiry_time)
;
basic_waitable_timer(boost::asio::io_service& io_service,
const duration& expiry_time)
;
std::size_t cancel()
;
std::size_t cancel(boost::system::error_code& ec)
;
std::size_t cancel_one()
;
std::size_t cancel_one(boost::system::error_code& ec)
;
time_point expires_at() const
;
std::size_t expires_at(const time_point& expiry_time)
;
std::size_t expires_at(const time_point& expiry_time,
boost::system::error_code& ec)
;
duration expires_from_now() const
;
std::size_t expires_from_now(const duration& expiry_time)
;
std::size_t expires_from_now(const duration& expiry_time,
boost::system::error_code& ec)
{
return this->service.expires_from_now(
this->implementation, expiry_time, ec);
}
void wait()
{
boost::system::error_code ec;
this->service.wait(this->implementation, ec);
boost::asio::detail::throw_error(ec, "wait");
}
void wait(boost::system::error_code& ec)
{
this->service.wait(this->implementation, ec);
}
template <typename WaitHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WaitHandler, void (boost::system::error_code)>::type>::type
async_wait(WaitHandler&& handler)
{
typedef typename handler_type<WaitHandler, void(boost::system::error_code)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "WaitHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> __attribute__((__unused__)) type_check;
return this->service.async_wait(this->implementation,
static_cast<WaitHandler&&>(handler));
}
};
}
}
#define BOOST_ASIO_BUFFERED_READ_STREAM_FWD_HPP
namespace boost {
namespace asio {
template <typename Stream>
class buffered_read_stream;
}
}
#define BOOST_ASIO_BUFFERED_READ_STREAM_HPP
#define BOOST_ASIO_DETAIL_BUFFER_RESIZE_GUARD_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Buffer>
class buffer_resize_guard
{
public:
buffer_resize_guard(Buffer& buffer)
: buffer_(buffer),
old_size_(buffer.size())
{
}
~buffer_resize_guard()
{
if (old_size_ != (std::numeric_limits<size_t>::max)())
{
buffer_.resize(old_size_);
}
}
void commit()
{
old_size_ = (std::numeric_limits<size_t>::max)();
}
private:
Buffer& buffer_;
size_t old_size_;
};
}
}
}
#define BOOST_ASIO_DETAIL_BUFFERED_STREAM_STORAGE_HPP
namespace boost {
namespace asio {
namespace detail {
class buffered_stream_storage
{
public:
typedef unsigned char byte_type;
typedef std::size_t size_type;
explicit buffered_stream_storage(std::size_t buffer_capacity)
: begin_offset_(0),
end_offset_(0),
buffer_(buffer_capacity)
{
}
void clear()
{
begin_offset_ = 0;
end_offset_ = 0;
}
mutable_buffer data()
{
return boost::asio::buffer(buffer_) + begin_offset_;
}
const_buffer data() const
{
return boost::asio::buffer(buffer_) + begin_offset_;
}
bool empty() const
{
return begin_offset_ == end_offset_;
}
size_type size() const
{
return end_offset_ - begin_offset_;
}
void resize(size_type length)
{
(static_cast<void> (0));
if (begin_offset_ + length <= capacity())
{
end_offset_ = begin_offset_ + length;
}
else
{
using namespace std;
memmove(&buffer_[0], &buffer_[0] + begin_offset_, size());
end_offset_ = length;
begin_offset_ = 0;
}
}
size_type capacity() const
{
return buffer_.size();
}
void consume(size_type count)
{
(static_cast<void> (0));
begin_offset_ += count;
if (empty())
clear();
}
private:
size_type begin_offset_;
size_type end_offset_;
std::vector<byte_type> buffer_;
};
}
}
}
namespace boost {
namespace asio {
template <typename Stream>
class buffered_read_stream
: private noncopyable
{
public:
typedef typename remove_reference<Stream>::type next_layer_type;
typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
static const std::size_t default_buffer_size = 1024;
template <typename Arg>
explicit buffered_read_stream(Arg& a)
: next_layer_(a),
storage_(default_buffer_size)
{
}
template <typename Arg>
buffered_read_stream(Arg& a, std::size_t buffer_size)
: next_layer_(a),
storage_(buffer_size)
{
}
next_layer_type& next_layer()
{
return next_layer_;
}
lowest_layer_type& lowest_layer()
{
return next_layer_.lowest_layer();
}
const lowest_layer_type& lowest_layer() const
{
return next_layer_.lowest_layer();
}
boost::asio::io_service& get_io_service()
{
return next_layer_.get_io_service();
}
void close()
{
next_layer_.close();
}
boost::system::error_code close(boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
std::size_t fill();
std::size_t fill(boost::system::error_code& ec);
template <typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_fill(ReadHandler&& handler);
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers);
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers,
boost::system::error_code& ec);
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(const MutableBufferSequence& buffers,
ReadHandler&& handler);
template <typename MutableBufferSequence>
std::size_t peek(const MutableBufferSequence& buffers);
template <typename MutableBufferSequence>
std::size_t peek(const MutableBufferSequence& buffers,
boost::system::error_code& ec);
std::size_t in_avail()
;
std::size_t in_avail(boost::system::error_code& ec)
;
private:
template <typename MutableBufferSequence>
std::size_t copy(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t peek_copy(const MutableBufferSequence& buffers)
;
Stream next_layer_;
detail::buffered_stream_storage storage_;
};
}
}
#define BOOST_ASIO_IMPL_BUFFERED_READ_STREAM_HPP
namespace boost {
namespace asio {
namespace detail
{
template <typename ReadHandler>
class buffered_fill_handler
{
public:
buffered_fill_handler(detail::buffered_stream_storage& storage,
std::size_t previous_size, ReadHandler& handler)
;
buffered_fill_handler(const buffered_fill_handler& other)
;
buffered_fill_handler(buffered_fill_handler&& other)
;
void operator()(const boost::system::error_code& ec,
const std::size_t bytes_transferred)
;
detail::buffered_stream_storage& storage_;
std::size_t previous_size_;
ReadHandler handler_;
};
template <typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
buffered_fill_handler<ReadHandler>* this_handler)
;
template <typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
buffered_fill_handler<ReadHandler>* this_handler)
;
template <typename ReadHandler>
bool asio_handler_is_continuation(
buffered_fill_handler<ReadHandler>* this_handler)
;
template <typename Function, typename ReadHandler>
void asio_handler_invoke(Function& function,
buffered_fill_handler<ReadHandler>* this_handler)
;
template <typename Function, typename ReadHandler>
void asio_handler_invoke(const Function& function,
buffered_fill_handler<ReadHandler>* this_handler)
;
}
namespace detail
{
template <typename MutableBufferSequence, typename ReadHandler>
class buffered_read_some_handler
{
public:
buffered_read_some_handler(detail::buffered_stream_storage& storage,
const MutableBufferSequence& buffers, ReadHandler& handler)
;
buffered_read_some_handler(const buffered_read_some_handler& other)
;
buffered_read_some_handler(buffered_read_some_handler&& other)
;
void operator()(const boost::system::error_code& ec, std::size_t)
;
detail::buffered_stream_storage& storage_;
MutableBufferSequence buffers_;
ReadHandler handler_;
};
template <typename MutableBufferSequence, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
buffered_read_some_handler<
MutableBufferSequence, ReadHandler>* this_handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
buffered_read_some_handler<
MutableBufferSequence, ReadHandler>* this_handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
bool asio_handler_is_continuation(
buffered_read_some_handler<
MutableBufferSequence, ReadHandler>* this_handler)
;
template <typename Function, typename MutableBufferSequence,
typename ReadHandler>
void asio_handler_invoke(Function& function,
buffered_read_some_handler<
MutableBufferSequence, ReadHandler>* this_handler)
;
template <typename Function, typename MutableBufferSequence,
typename ReadHandler>
void asio_handler_invoke(const Function& function,
buffered_read_some_handler<
MutableBufferSequence, ReadHandler>* this_handler)
;
}
}
}
#define BOOST_ASIO_BUFFERED_STREAM_FWD_HPP
namespace boost {
namespace asio {
template <typename Stream>
class buffered_stream;
}
}
#define BOOST_ASIO_BUFFERED_STREAM_HPP
#define BOOST_ASIO_BUFFERED_WRITE_STREAM_HPP
#define BOOST_ASIO_BUFFERED_WRITE_STREAM_FWD_HPP
namespace boost {
namespace asio {
template <typename Stream>
class buffered_write_stream;
}
}
#define BOOST_ASIO_COMPLETION_CONDITION_HPP
namespace boost {
namespace asio {
namespace detail {
enum { default_max_transfer_size = 65536 };
std::size_t adapt_completion_condition_result(bool result)
;
std::size_t adapt_completion_condition_result(std::size_t result)
;
class transfer_all_t
{
public:
typedef std::size_t result_type;
template <typename Error>
std::size_t operator()(const Error& err, std::size_t)
;
};
class transfer_at_least_t
{
public:
typedef std::size_t result_type;
explicit transfer_at_least_t(std::size_t minimum)
;
template <typename Error>
std::size_t operator()(const Error& err, std::size_t bytes_transferred)
;
private:
std::size_t minimum_;
};
class transfer_exactly_t
{
public:
typedef std::size_t result_type;
explicit transfer_exactly_t(std::size_t size)
;
template <typename Error>
std::size_t operator()(const Error& err, std::size_t bytes_transferred)
;
private:
std::size_t size_;
};
}
detail::transfer_all_t transfer_all()
;
detail::transfer_at_least_t transfer_at_least(std::size_t minimum)
;
detail::transfer_exactly_t transfer_exactly(std::size_t size)
;
}
}
#define BOOST_ASIO_WRITE_HPP
namespace boost {
namespace asio {
template <typename SyncWriteStream, typename ConstBufferSequence>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers);
template <typename SyncWriteStream, typename ConstBufferSequence>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
boost::system::error_code& ec);
template <typename SyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
CompletionCondition completion_condition);
template <typename SyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
CompletionCondition completion_condition, boost::system::error_code& ec);
template <typename SyncWriteStream, typename Allocator>
std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b);
template <typename SyncWriteStream, typename Allocator>
std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
boost::system::error_code& ec);
template <typename SyncWriteStream, typename Allocator,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition);
template <typename SyncWriteStream, typename Allocator,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition, boost::system::error_code& ec);
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
WriteHandler&& handler);
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
CompletionCondition completion_condition,
WriteHandler&& handler);
template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
WriteHandler&& handler);
template <typename AsyncWriteStream, typename Allocator,
typename CompletionCondition, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition,
WriteHandler&& handler);
}
}
#define BOOST_ASIO_IMPL_WRITE_HPP
#define BOOST_ASIO_DETAIL_BASE_FROM_COMPLETION_COND_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename CompletionCondition>
class base_from_completion_cond
{
protected:
explicit base_from_completion_cond(CompletionCondition completion_condition)
;
std::size_t check_for_completion(
const boost::system::error_code& ec,
std::size_t total_transferred)
;
private:
CompletionCondition completion_condition_;
};
template <>
class base_from_completion_cond<transfer_all_t>
{
protected:
explicit base_from_completion_cond(transfer_all_t)
;
static std::size_t check_for_completion(
const boost::system::error_code& ec,
std::size_t total_transferred)
;
};
}
}
}
#define BOOST_ASIO_DETAIL_CONSUMING_BUFFERS_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Buffer, typename Buffer_Iterator>
class consuming_buffers_iterator
{
public:
typedef std::ptrdiff_t difference_type;
typedef Buffer value_type;
typedef const Buffer* pointer;
typedef const Buffer& reference;
typedef std::forward_iterator_tag iterator_category;
consuming_buffers_iterator()
;
consuming_buffers_iterator(bool at_end, const Buffer& first,
Buffer_Iterator begin_remainder, Buffer_Iterator end_remainder,
std::size_t max_size)
;
const Buffer& operator*() const
;
const Buffer* operator->() const
;
consuming_buffers_iterator& operator++()
;
consuming_buffers_iterator operator++(int)
;
friend bool operator==(const consuming_buffers_iterator& a,
const consuming_buffers_iterator& b)
;
friend bool operator!=(const consuming_buffers_iterator& a,
const consuming_buffers_iterator& b)
;
private:
void increment()
;
bool equal(const consuming_buffers_iterator& other) const
;
const Buffer& dereference() const
;
bool at_end_;
Buffer first_;
Buffer_Iterator begin_remainder_;
Buffer_Iterator end_remainder_;
std::size_t offset_;
std::size_t max_size_;
};
template <typename Buffer, typename Buffers>
class consuming_buffers
{
public:
typedef Buffer value_type;
typedef consuming_buffers_iterator<Buffer, typename Buffers::const_iterator>
const_iterator;
consuming_buffers(const Buffers& buffers)
: buffers_(buffers),
at_end_(buffers_.begin() == buffers_.end()),
begin_remainder_(buffers_.begin()),
max_size_((std::numeric_limits<std::size_t>::max)())
{
if (!at_end_)
{
first_ = *buffers_.begin();
++begin_remainder_;
}
}
consuming_buffers(const consuming_buffers& other)
: buffers_(other.buffers_),
at_end_(other.at_end_),
first_(other.first_),
begin_remainder_(buffers_.begin()),
max_size_(other.max_size_)
{
typename Buffers::const_iterator first = other.buffers_.begin();
typename Buffers::const_iterator second = other.begin_remainder_;
std::advance(begin_remainder_, std::distance(first, second));
}
consuming_buffers& operator=(const consuming_buffers& other)
{
buffers_ = other.buffers_;
at_end_ = other.at_end_;
first_ = other.first_;
begin_remainder_ = buffers_.begin();
typename Buffers::const_iterator first = other.buffers_.begin();
typename Buffers::const_iterator second = other.begin_remainder_;
std::advance(begin_remainder_, std::distance(first, second));
max_size_ = other.max_size_;
return *this;
}
const_iterator begin() const
;
const_iterator end() const
;
void prepare(std::size_t max_size)
;
void consume(std::size_t size)
;
private:
Buffers buffers_;
bool at_end_;
Buffer first_;
typename Buffers::const_iterator begin_remainder_;
std::size_t max_size_;
};
template <typename Buffer>
class consuming_buffers<Buffer, boost::asio::null_buffers>
: public boost::asio::null_buffers
{
public:
consuming_buffers(const boost::asio::null_buffers&)
;
void prepare(std::size_t)
;
void consume(std::size_t)
;
};
}
}
}
#define BOOST_ASIO_DETAIL_DEPENDENT_TYPE_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename DependsOn, typename T>
struct dependent_type
{
typedef T type;
};
}
}
}
namespace boost {
namespace asio {
template <typename SyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
CompletionCondition completion_condition, boost::system::error_code& ec)
;
template <typename SyncWriteStream, typename ConstBufferSequence>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers)
;
template <typename SyncWriteStream, typename ConstBufferSequence>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename SyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
CompletionCondition completion_condition)
;
template <typename SyncWriteStream, typename Allocator,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s,
boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition, boost::system::error_code& ec)
;
template <typename SyncWriteStream, typename Allocator>
std::size_t write(SyncWriteStream& s,
boost::asio::basic_streambuf<Allocator>& b)
;
template <typename SyncWriteStream, typename Allocator>
std::size_t write(SyncWriteStream& s,
boost::asio::basic_streambuf<Allocator>& b,
boost::system::error_code& ec)
;
template <typename SyncWriteStream, typename Allocator,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s,
boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition)
;
namespace detail
{
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition, typename WriteHandler>
class write_op
: detail::base_from_completion_cond<CompletionCondition>
{
public:
write_op(AsyncWriteStream& stream, const ConstBufferSequence& buffers,
CompletionCondition completion_condition, WriteHandler& handler)
;
write_op(const write_op& other)
;
write_op(write_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncWriteStream& stream_;
boost::asio::detail::consuming_buffers<
const_buffer, ConstBufferSequence> buffers_;
int start_;
std::size_t total_transferred_;
WriteHandler handler_;
};
template <typename AsyncWriteStream,
typename CompletionCondition, typename WriteHandler>
class write_op<AsyncWriteStream, boost::asio::mutable_buffers_1,
CompletionCondition, WriteHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
write_op(AsyncWriteStream& stream,
const boost::asio::mutable_buffers_1& buffers,
CompletionCondition completion_condition,
WriteHandler& handler)
;
write_op(const write_op& other)
;
write_op(write_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncWriteStream& stream_;
boost::asio::mutable_buffer buffer_;
int start_;
std::size_t total_transferred_;
WriteHandler handler_;
};
template <typename AsyncWriteStream,
typename CompletionCondition, typename WriteHandler>
class write_op<AsyncWriteStream, boost::asio::const_buffers_1,
CompletionCondition, WriteHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
write_op(AsyncWriteStream& stream,
const boost::asio::const_buffers_1& buffers,
CompletionCondition completion_condition,
WriteHandler& handler)
;
write_op(const write_op& other)
;
write_op(write_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncWriteStream& stream_;
boost::asio::const_buffer buffer_;
int start_;
std::size_t total_transferred_;
WriteHandler handler_;
};
template <typename AsyncWriteStream, typename Elem,
typename CompletionCondition, typename WriteHandler>
class write_op<AsyncWriteStream, boost::array<Elem, 2>,
CompletionCondition, WriteHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
write_op(AsyncWriteStream& stream, const boost::array<Elem, 2>& buffers,
CompletionCondition completion_condition, WriteHandler& handler)
;
write_op(const write_op& other)
;
write_op(write_op&& other)
: detail::base_from_completion_cond<CompletionCondition>(other),
stream_(other.stream_),
buffers_(other.buffers_),
start_(other.start_),
total_transferred_(other.total_transferred_),
handler_(static_cast<WriteHandler&&>(other.handler_))
{
}
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
{
typename boost::asio::detail::dependent_type<Elem,
boost::array<boost::asio::const_buffer, 2> >::type bufs = {{
boost::asio::const_buffer(buffers_[0]),
boost::asio::const_buffer(buffers_[1]) }};
std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
std::size_t n = 0;
switch (start_ = start)
{
case 1:
n = this->check_for_completion(ec, total_transferred_);
for (;;)
{
bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
bufs[1] = boost::asio::buffer(
bufs[1] + (total_transferred_ < buffer_size0
? 0 : total_transferred_ - buffer_size0),
n - boost::asio::buffer_size(bufs[0]));
stream_.async_write_some(bufs, static_cast<write_op&&>(*this));
return; default:
total_transferred_ += bytes_transferred;
if ((!ec && bytes_transferred == 0)
|| (n = this->check_for_completion(ec, total_transferred_)) == 0
|| total_transferred_ == buffer_size0 + buffer_size1)
break;
}
handler_(ec, static_cast<const std::size_t&>(total_transferred_));
}
}
AsyncWriteStream& stream_;
boost::array<Elem, 2> buffers_;
int start_;
std::size_t total_transferred_;
WriteHandler handler_;
};
template <typename AsyncWriteStream, typename Elem,
typename CompletionCondition, typename WriteHandler>
class write_op<AsyncWriteStream, std::array<Elem, 2>,
CompletionCondition, WriteHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
write_op(AsyncWriteStream& stream, const std::array<Elem, 2>& buffers,
CompletionCondition completion_condition, WriteHandler& handler)
;
write_op(const write_op& other)
;
write_op(write_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncWriteStream& stream_;
std::array<Elem, 2> buffers_;
int start_;
std::size_t total_transferred_;
WriteHandler handler_;
};
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition, typename WriteHandler>
void* asio_handler_allocate(std::size_t size,
write_op<AsyncWriteStream, ConstBufferSequence,
CompletionCondition, WriteHandler>* this_handler)
;
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition, typename WriteHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
write_op<AsyncWriteStream, ConstBufferSequence,
CompletionCondition, WriteHandler>* this_handler)
;
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition, typename WriteHandler>
bool asio_handler_is_continuation(
write_op<AsyncWriteStream, ConstBufferSequence,
CompletionCondition, WriteHandler>* this_handler)
;
template <typename Function, typename AsyncWriteStream,
typename ConstBufferSequence, typename CompletionCondition,
typename WriteHandler>
void asio_handler_invoke(Function& function,
write_op<AsyncWriteStream, ConstBufferSequence,
CompletionCondition, WriteHandler>* this_handler)
;
template <typename Function, typename AsyncWriteStream,
typename ConstBufferSequence, typename CompletionCondition,
typename WriteHandler>
inline void asio_handler_invoke(const Function& function,
write_op<AsyncWriteStream, ConstBufferSequence,
CompletionCondition, WriteHandler>* this_handler)
{
boost_asio_handler_invoke_helpers::invoke(
function, this_handler->handler_);
}
}
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition, typename WriteHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
CompletionCondition completion_condition,
WriteHandler&& handler)
{
typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
detail::async_result_init<
WriteHandler, void (boost::system::error_code, std::size_t)> init(
static_cast<WriteHandler&&>(handler));
detail::write_op<AsyncWriteStream, ConstBufferSequence,
CompletionCondition, typename handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>(
s, buffers, completion_condition, init.handler)(
boost::system::error_code(), 0, 1);
return init.result.get();
}
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename WriteHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
WriteHandler&& handler)
{
typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
detail::async_result_init<
WriteHandler, void (boost::system::error_code, std::size_t)> init(
static_cast<WriteHandler&&>(handler));
detail::write_op<AsyncWriteStream, ConstBufferSequence,
detail::transfer_all_t, typename handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>(
s, buffers, transfer_all(), init.handler)(
boost::system::error_code(), 0, 1);
return init.result.get();
}
namespace detail
{
template <typename Allocator, typename WriteHandler>
class write_streambuf_handler
{
public:
write_streambuf_handler(boost::asio::basic_streambuf<Allocator>& streambuf,
WriteHandler& handler)
: streambuf_(streambuf),
handler_(static_cast<WriteHandler&&>(handler))
{
}
write_streambuf_handler(const write_streambuf_handler& other)
: streambuf_(other.streambuf_),
handler_(other.handler_)
{
}
write_streambuf_handler(write_streambuf_handler&& other)
: streambuf_(other.streambuf_),
handler_(static_cast<WriteHandler&&>(other.handler_))
{
}
void operator()(const boost::system::error_code& ec,
const std::size_t bytes_transferred)
{
streambuf_.consume(bytes_transferred);
handler_(ec, bytes_transferred);
}
boost::asio::basic_streambuf<Allocator>& streambuf_;
WriteHandler handler_;
};
template <typename Allocator, typename WriteHandler>
inline void* asio_handler_allocate(std::size_t size,
write_streambuf_handler<Allocator, WriteHandler>* this_handler)
{
return boost_asio_handler_alloc_helpers::allocate(
size, this_handler->handler_);
}
template <typename Allocator, typename WriteHandler>
inline void asio_handler_deallocate(void* pointer, std::size_t size,
write_streambuf_handler<Allocator, WriteHandler>* this_handler)
{
boost_asio_handler_alloc_helpers::deallocate(
pointer, size, this_handler->handler_);
}
template <typename Allocator, typename WriteHandler>
inline bool asio_handler_is_continuation(
write_streambuf_handler<Allocator, WriteHandler>* this_handler)
{
return boost_asio_handler_cont_helpers::is_continuation(
this_handler->handler_);
}
template <typename Function, typename Allocator, typename WriteHandler>
inline void asio_handler_invoke(Function& function,
write_streambuf_handler<Allocator, WriteHandler>* this_handler)
{
boost_asio_handler_invoke_helpers::invoke(
function, this_handler->handler_);
}
template <typename Function, typename Allocator, typename WriteHandler>
inline void asio_handler_invoke(const Function& function,
write_streambuf_handler<Allocator, WriteHandler>* this_handler)
{
boost_asio_handler_invoke_helpers::invoke(
function, this_handler->handler_);
}
}
template <typename AsyncWriteStream, typename Allocator,
typename CompletionCondition, typename WriteHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s,
boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition,
WriteHandler&& handler)
{
typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
detail::async_result_init<
WriteHandler, void (boost::system::error_code, std::size_t)> init(
static_cast<WriteHandler&&>(handler));
async_write(s, b.data(), completion_condition,
detail::write_streambuf_handler<Allocator, typename handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>(
b, init.handler));
return init.result.get();
}
template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s,
boost::asio::basic_streambuf<Allocator>& b,
WriteHandler&& handler)
{
typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
detail::async_result_init<
WriteHandler, void (boost::system::error_code, std::size_t)> init(
static_cast<WriteHandler&&>(handler));
async_write(s, b.data(), transfer_all(),
detail::write_streambuf_handler<Allocator, typename handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>(
b, init.handler));
return init.result.get();
}
}
}
namespace boost {
namespace asio {
template <typename Stream>
class buffered_write_stream
: private noncopyable
{
public:
typedef typename remove_reference<Stream>::type next_layer_type;
typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
static const std::size_t default_buffer_size = 1024;
template <typename Arg>
explicit buffered_write_stream(Arg& a)
: next_layer_(a),
storage_(default_buffer_size)
{
}
template <typename Arg>
buffered_write_stream(Arg& a, std::size_t buffer_size)
: next_layer_(a),
storage_(buffer_size)
{
}
next_layer_type& next_layer()
;
lowest_layer_type& lowest_layer()
;
const lowest_layer_type& lowest_layer() const
;
boost::asio::io_service& get_io_service()
;
void close()
;
boost::system::error_code close(boost::system::error_code& ec)
;
std::size_t flush();
std::size_t flush(boost::system::error_code& ec);
template <typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_flush(WriteHandler&& handler);
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers);
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers,
boost::system::error_code& ec);
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(const ConstBufferSequence& buffers,
WriteHandler&& handler);
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t peek(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t peek(const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
std::size_t in_avail()
;
std::size_t in_avail(boost::system::error_code& ec)
;
private:
template <typename ConstBufferSequence>
std::size_t copy(const ConstBufferSequence& buffers);
Stream next_layer_;
detail::buffered_stream_storage storage_;
};
}
}
#define BOOST_ASIO_IMPL_BUFFERED_WRITE_STREAM_HPP
namespace boost {
namespace asio {
namespace detail
{
template <typename WriteHandler>
class buffered_flush_handler
{
public:
buffered_flush_handler(detail::buffered_stream_storage& storage,
WriteHandler& handler)
;
buffered_flush_handler(const buffered_flush_handler& other)
;
buffered_flush_handler(buffered_flush_handler&& other)
;
void operator()(const boost::system::error_code& ec,
const std::size_t bytes_written)
;
detail::buffered_stream_storage& storage_;
WriteHandler handler_;
};
template <typename WriteHandler>
void* asio_handler_allocate(std::size_t size,
buffered_flush_handler<WriteHandler>* this_handler)
;
template <typename WriteHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
buffered_flush_handler<WriteHandler>* this_handler)
;
template <typename WriteHandler>
bool asio_handler_is_continuation(
buffered_flush_handler<WriteHandler>* this_handler)
;
template <typename Function, typename WriteHandler>
void asio_handler_invoke(Function& function,
buffered_flush_handler<WriteHandler>* this_handler)
;
template <typename Function, typename WriteHandler>
void asio_handler_invoke(const Function& function,
buffered_flush_handler<WriteHandler>* this_handler)
;
}
namespace detail
{
template <typename ConstBufferSequence, typename WriteHandler>
class buffered_write_some_handler
{
public:
buffered_write_some_handler(detail::buffered_stream_storage& storage,
const ConstBufferSequence& buffers, WriteHandler& handler)
;
buffered_write_some_handler(const buffered_write_some_handler& other)
;
buffered_write_some_handler(buffered_write_some_handler&& other)
;
void operator()(const boost::system::error_code& ec, std::size_t)
;
detail::buffered_stream_storage& storage_;
ConstBufferSequence buffers_;
WriteHandler handler_;
};
template <typename ConstBufferSequence, typename WriteHandler>
void* asio_handler_allocate(std::size_t size,
buffered_write_some_handler<
ConstBufferSequence, WriteHandler>* this_handler)
;
template <typename ConstBufferSequence, typename WriteHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
buffered_write_some_handler<
ConstBufferSequence, WriteHandler>* this_handler)
;
template <typename ConstBufferSequence, typename WriteHandler>
bool asio_handler_is_continuation(
buffered_write_some_handler<
ConstBufferSequence, WriteHandler>* this_handler)
;
template <typename Function, typename ConstBufferSequence,
typename WriteHandler>
void asio_handler_invoke(Function& function,
buffered_write_some_handler<
ConstBufferSequence, WriteHandler>* this_handler)
;
template <typename Function, typename ConstBufferSequence,
typename WriteHandler>
void asio_handler_invoke(const Function& function,
buffered_write_some_handler<
ConstBufferSequence, WriteHandler>* this_handler)
;
}
}
}
namespace boost {
namespace asio {
template <typename Stream>
class buffered_stream
: private noncopyable
{
public:
typedef typename remove_reference<Stream>::type next_layer_type;
typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
template <typename Arg>
explicit buffered_stream(Arg& a)
;
template <typename Arg>
explicit buffered_stream(Arg& a, std::size_t read_buffer_size,
std::size_t write_buffer_size)
;
next_layer_type& next_layer()
;
lowest_layer_type& lowest_layer()
;
const lowest_layer_type& lowest_layer() const
;
boost::asio::io_service& get_io_service()
;
void close()
;
boost::system::error_code close(boost::system::error_code& ec)
;
std::size_t flush()
;
std::size_t flush(boost::system::error_code& ec)
;
template <typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_flush(WriteHandler&& handler)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
std::size_t fill()
;
std::size_t fill(boost::system::error_code& ec)
;
template <typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_fill(ReadHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t peek(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t peek(const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
std::size_t in_avail()
;
std::size_t in_avail(boost::system::error_code& ec)
;
private:
typedef buffered_write_stream<Stream> write_stream_type;
write_stream_type inner_stream_impl_;
typedef buffered_read_stream<write_stream_type&> read_stream_type;
read_stream_type stream_impl_;
};
}
}
#define BOOST_ASIO_BUFFERS_ITERATOR_HPP
namespace boost {
namespace asio {
namespace detail
{
template <bool IsMutable>
struct buffers_iterator_types_helper;
template <>
struct buffers_iterator_types_helper<false>
{
typedef const_buffer buffer_type;
template <typename ByteType>
struct byte_type
{
typedef typename add_const<ByteType>::type type;
};
};
template <>
struct buffers_iterator_types_helper<true>
{
typedef mutable_buffer buffer_type;
template <typename ByteType>
struct byte_type
{
typedef ByteType type;
};
};
template <typename BufferSequence, typename ByteType>
struct buffers_iterator_types
{
enum
{
is_mutable = is_convertible<
typename BufferSequence::value_type,
mutable_buffer>::value
};
typedef buffers_iterator_types_helper<is_mutable> helper;
typedef typename helper::buffer_type buffer_type;
typedef typename helper::template byte_type<ByteType>::type byte_type;
};
}
template <typename BufferSequence, typename ByteType = char>
class buffers_iterator
{
private:
typedef typename detail::buffers_iterator_types<
BufferSequence, ByteType>::buffer_type buffer_type;
public:
typedef std::ptrdiff_t difference_type;
typedef ByteType value_type;
typedef typename detail::buffers_iterator_types<
BufferSequence, ByteType>::byte_type* pointer;
typedef typename detail::buffers_iterator_types<
BufferSequence, ByteType>::byte_type& reference;
typedef std::random_access_iterator_tag iterator_category;
buffers_iterator()
;
static buffers_iterator begin(const BufferSequence& buffers)
;
static buffers_iterator end(const BufferSequence& buffers)
;
reference operator*() const
;
pointer operator->() const
;
reference operator[](std::ptrdiff_t difference) const
;
buffers_iterator& operator++()
;
buffers_iterator operator++(int)
;
buffers_iterator& operator--()
;
buffers_iterator operator--(int)
;
buffers_iterator& operator+=(std::ptrdiff_t difference)
;
buffers_iterator& operator-=(std::ptrdiff_t difference)
;
friend buffers_iterator operator+(const buffers_iterator& iter,
std::ptrdiff_t difference)
;
friend buffers_iterator operator+(std::ptrdiff_t difference,
const buffers_iterator& iter)
;
friend buffers_iterator operator-(const buffers_iterator& iter,
std::ptrdiff_t difference)
;
friend std::ptrdiff_t operator-(const buffers_iterator& a,
const buffers_iterator& b)
;
friend bool operator==(const buffers_iterator& a, const buffers_iterator& b)
;
friend bool operator!=(const buffers_iterator& a, const buffers_iterator& b)
;
friend bool operator<(const buffers_iterator& a, const buffers_iterator& b)
;
friend bool operator<=(const buffers_iterator& a, const buffers_iterator& b)
;
friend bool operator>(const buffers_iterator& a, const buffers_iterator& b)
;
friend bool operator>=(const buffers_iterator& a, const buffers_iterator& b)
;
private:
reference dereference() const
;
bool equal(const buffers_iterator& other) const
;
void increment()
;
void decrement()
;
void advance(std::ptrdiff_t n)
;
std::ptrdiff_t distance_to(const buffers_iterator& other) const
;
buffer_type current_buffer_;
std::size_t current_buffer_position_;
typename BufferSequence::const_iterator begin_;
typename BufferSequence::const_iterator current_;
typename BufferSequence::const_iterator end_;
std::size_t position_;
};
template <typename BufferSequence>
buffers_iterator<BufferSequence> buffers_begin(
const BufferSequence& buffers)
;
template <typename BufferSequence>
buffers_iterator<BufferSequence> buffers_end(
const BufferSequence& buffers)
;
}
}
#define BOOST_ASIO_CONNECT_HPP
namespace boost {
namespace asio {
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin);
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, boost::system::error_code& ec);
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end);
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, boost::system::error_code& ec);
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, ConnectCondition connect_condition);
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
ConnectCondition connect_condition, boost::system::error_code& ec);
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
Iterator end, ConnectCondition connect_condition);
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, ConnectCondition connect_condition,
boost::system::error_code& ec);
template <typename Protocol, typename SocketService,
typename Iterator, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, ComposedConnectHandler&& handler);
template <typename Protocol, typename SocketService,
typename Iterator, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end,
ComposedConnectHandler&& handler);
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
ConnectCondition connect_condition,
ComposedConnectHandler&& handler);
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, ConnectCondition connect_condition,
ComposedConnectHandler&& handler);
}
}
#define BOOST_ASIO_IMPL_CONNECT_HPP
namespace boost {
namespace asio {
namespace detail
{
struct default_connect_condition
{
template <typename Iterator>
Iterator operator()(const boost::system::error_code&, Iterator next)
;
};
}
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin)
;
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, boost::system::error_code& ec)
;
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end)
;
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, boost::system::error_code& ec)
;
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, ConnectCondition connect_condition)
;
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, ConnectCondition connect_condition,
boost::system::error_code& ec)
;
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, ConnectCondition connect_condition)
;
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, ConnectCondition connect_condition,
boost::system::error_code& ec)
;
namespace detail
{
template <typename ConnectCondition>
class base_from_connect_condition
{
protected:
explicit base_from_connect_condition(
const ConnectCondition& connect_condition)
;
template <typename Iterator>
void check_condition(const boost::system::error_code& ec,
Iterator& iter, Iterator& end)
;
private:
ConnectCondition connect_condition_;
};
template <>
class base_from_connect_condition<default_connect_condition>
{
protected:
explicit base_from_connect_condition(const default_connect_condition&)
;
template <typename Iterator>
void check_condition(const boost::system::error_code&, Iterator&, Iterator&)
;
};
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
class connect_op : base_from_connect_condition<ConnectCondition>
{
public:
connect_op(basic_socket<Protocol, SocketService>& sock,
const Iterator& begin, const Iterator& end,
const ConnectCondition& connect_condition,
ComposedConnectHandler& handler)
;
connect_op(const connect_op& other)
;
connect_op(connect_op&& other)
;
void operator()(boost::system::error_code ec, int start = 0)
;
basic_socket<Protocol, SocketService>& socket_;
Iterator iter_;
Iterator end_;
int start_;
ComposedConnectHandler handler_;
};
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
void* asio_handler_allocate(std::size_t size,
connect_op<Protocol, SocketService, Iterator,
ConnectCondition, ComposedConnectHandler>* this_handler)
;
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
connect_op<Protocol, SocketService, Iterator,
ConnectCondition, ComposedConnectHandler>* this_handler)
;
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
bool asio_handler_is_continuation(
connect_op<Protocol, SocketService, Iterator,
ConnectCondition, ComposedConnectHandler>* this_handler)
;
template <typename Function, typename Protocol,
typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
void asio_handler_invoke(Function& function,
connect_op<Protocol, SocketService, Iterator,
ConnectCondition, ComposedConnectHandler>* this_handler)
;
template <typename Function, typename Protocol,
typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
void asio_handler_invoke(const Function& function,
connect_op<Protocol, SocketService, Iterator,
ConnectCondition, ComposedConnectHandler>* this_handler)
;
}
template <typename Protocol, typename SocketService,
typename Iterator, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, ComposedConnectHandler&& handler)
;
template <typename Protocol, typename SocketService,
typename Iterator, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end,
ComposedConnectHandler&& handler)
;
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, ConnectCondition connect_condition,
ComposedConnectHandler&& handler)
;
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, ConnectCondition connect_condition,
ComposedConnectHandler&& handler)
;
}
}
#define BOOST_ASIO_COROUTINE_HPP
namespace boost {
namespace asio {
namespace detail {
class coroutine_ref;
}
class coroutine
{
public:
coroutine() ;
bool is_child() const ;
bool is_parent() const ;
bool is_complete() const ;
private:
friend class detail::coroutine_ref;
int value_;
};
namespace detail {
class coroutine_ref
{
public:
coroutine_ref(coroutine& c) ;
coroutine_ref(coroutine* c) ;
~coroutine_ref() ;
operator int() const ;
int& operator=(int v) ;
private:
void operator=(const coroutine_ref&);
int& value_;
bool modified_;
};
}
}
}
#define BOOST_ASIO_CORO_REENTER(c) switch (::boost::asio::detail::coroutine_ref _coro_value = c) case -1: if (_coro_value) { goto terminate_coroutine; terminate_coroutine: _coro_value = -1; goto bail_out_of_coroutine; bail_out_of_coroutine: break; } else case 0:
#define BOOST_ASIO_CORO_YIELD_IMPL(n) for (_coro_value = (n);;) if (_coro_value == 0) { case (n): ; break; } else switch (_coro_value ? 0 : 1) for (;;) case -1: if (_coro_value) goto terminate_coroutine; else for (;;) case 1: if (_coro_value) goto bail_out_of_coroutine; else case 0:
#define BOOST_ASIO_CORO_FORK_IMPL(n) for (_coro_value = -(n);; _coro_value = (n)) if (_coro_value == (n)) { case -(n): ; break; } else
#define BOOST_ASIO_CORO_YIELD BOOST_ASIO_CORO_YIELD_IMPL(__LINE__)
#define BOOST_ASIO_CORO_FORK BOOST_ASIO_CORO_FORK_IMPL(__LINE__)
#define BOOST_ASIO_GENERIC_BASIC_ENDPOINT_HPP
#define BOOST_ASIO_GENERIC_DETAIL_ENDPOINT_HPP
namespace boost {
namespace asio {
namespace generic {
namespace detail {
class endpoint
{
public:
inline endpoint();
inline endpoint(const void* sock_addr,
std::size_t sock_addr_size, int sock_protocol);
endpoint(const endpoint& other)
;
endpoint& operator=(const endpoint& other)
;
int family() const
;
int protocol() const
;
boost::asio::detail::socket_addr_type* data()
;
const boost::asio::detail::socket_addr_type* data() const
;
std::size_t size() const
;
inline void resize(std::size_t size);
std::size_t capacity() const
;
inline friend bool operator==(
const endpoint& e1, const endpoint& e2);
inline friend bool operator<(
const endpoint& e1, const endpoint& e2);
private:
union data_union
{
boost::asio::detail::socket_addr_type base;
boost::asio::detail::sockaddr_storage_type generic;
} data_;
std::size_t size_;
int protocol_;
inline void init(const void* sock_addr,
std::size_t sock_addr_size, int sock_protocol);
};
}
}
}
}
#define BOOST_ASIO_GENERIC_DETAIL_IMPL_ENDPOINT_IPP
namespace boost {
namespace asio {
namespace generic {
namespace detail {
bool operator==(const endpoint& e1, const endpoint& e2)
;
bool operator<(const endpoint& e1, const endpoint& e2)
;
}
}
}
}
namespace boost {
namespace asio {
namespace generic {
template <typename Protocol>
class basic_endpoint
{
public:
typedef Protocol protocol_type;
typedef boost::asio::detail::socket_addr_type data_type;
basic_endpoint()
;
basic_endpoint(const void* socket_address,
std::size_t socket_address_size, int socket_protocol = 0)
;
template <typename Endpoint>
basic_endpoint(const Endpoint& endpoint)
;
basic_endpoint(const basic_endpoint& other)
;
basic_endpoint(basic_endpoint&& other)
;
basic_endpoint& operator=(const basic_endpoint& other)
;
basic_endpoint& operator=(basic_endpoint&& other)
;
protocol_type protocol() const
;
data_type* data()
;
const data_type* data() const
;
std::size_t size() const
;
void resize(std::size_t new_size)
;
std::size_t capacity() const
;
friend bool operator==(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator!=(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator<(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator>(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator<=(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator>=(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
private:
boost::asio::generic::detail::endpoint impl_;
};
}
}
}
#define BOOST_ASIO_GENERIC_DATAGRAM_PROTOCOL_HPP
namespace boost {
namespace asio {
namespace generic {
class datagram_protocol
{
public:
datagram_protocol(int address_family, int socket_protocol)
;
template <typename Protocol>
datagram_protocol(const Protocol& source_protocol)
;
int type() const
;
int protocol() const
;
int family() const
;
friend bool operator==(const datagram_protocol& p1,
const datagram_protocol& p2)
;
friend bool operator!=(const datagram_protocol& p1,
const datagram_protocol& p2)
;
typedef basic_endpoint<datagram_protocol> endpoint;
typedef basic_datagram_socket<datagram_protocol> socket;
private:
int family_;
int protocol_;
};
}
}
}
#define BOOST_ASIO_GENERIC_RAW_PROTOCOL_HPP
namespace boost {
namespace asio {
namespace generic {
class raw_protocol
{
public:
raw_protocol(int address_family, int socket_protocol)
;
template <typename Protocol>
raw_protocol(const Protocol& source_protocol)
;
int type() const
;
int protocol() const
;
int family() const
;
friend bool operator==(const raw_protocol& p1, const raw_protocol& p2)
;
friend bool operator!=(const raw_protocol& p1, const raw_protocol& p2)
;
typedef basic_endpoint<raw_protocol> endpoint;
typedef basic_raw_socket<raw_protocol> socket;
private:
int family_;
int protocol_;
};
}
}
}
#define BOOST_ASIO_GENERIC_SEQ_PACKET_PROTOCOL_HPP
namespace boost {
namespace asio {
namespace generic {
class seq_packet_protocol
{
public:
seq_packet_protocol(int address_family, int socket_protocol)
;
template <typename Protocol>
seq_packet_protocol(const Protocol& source_protocol)
;
int type() const
;
int protocol() const
;
int family() const
;
friend bool operator==(const seq_packet_protocol& p1,
const seq_packet_protocol& p2)
;
friend bool operator!=(const seq_packet_protocol& p1,
const seq_packet_protocol& p2)
;
typedef basic_endpoint<seq_packet_protocol> endpoint;
typedef basic_seq_packet_socket<seq_packet_protocol> socket;
private:
int family_;
int protocol_;
};
}
}
}
#define BOOST_ASIO_GENERIC_STREAM_PROTOCOL_HPP
namespace boost {
namespace asio {
namespace generic {
class stream_protocol
{
public:
stream_protocol(int address_family, int socket_protocol)
;
template <typename Protocol>
stream_protocol(const Protocol& source_protocol)
;
int type() const
;
int protocol() const
;
int family() const
;
friend bool operator==(const stream_protocol& p1, const stream_protocol& p2)
;
friend bool operator!=(const stream_protocol& p1, const stream_protocol& p2)
;
typedef basic_endpoint<stream_protocol> endpoint;
typedef basic_stream_socket<stream_protocol> socket;
typedef basic_socket_iostream<stream_protocol> iostream;
private:
int family_;
int protocol_;
};
}
}
}
#define BOOST_ASIO_IP_ADDRESS_HPP
#define BOOST_ASIO_IP_ADDRESS_V4_HPP
#define BOOST_ASIO_DETAIL_WINSOCK_INIT_HPP
namespace boost {
namespace asio {
namespace ip {
class address_v4
{
public:
typedef boost::asio::detail::array<unsigned char, 4> bytes_type;
address_v4()
;
inline explicit address_v4(const bytes_type& bytes);
inline explicit address_v4(unsigned long addr);
address_v4(const address_v4& other)
;
address_v4(address_v4&& other)
;
address_v4& operator=(const address_v4& other)
;
address_v4& operator=(address_v4&& other)
;
inline bytes_type to_bytes() const;
inline unsigned long to_ulong() const;
inline std::string to_string() const;
inline std::string to_string(boost::system::error_code& ec) const;
inline static address_v4 from_string(const char* str);
inline static address_v4 from_string(
const char* str, boost::system::error_code& ec);
inline static address_v4 from_string(const std::string& str);
inline static address_v4 from_string(
const std::string& str, boost::system::error_code& ec);
inline bool is_loopback() const;
inline bool is_unspecified() const;
inline bool is_class_a() const;
inline bool is_class_b() const;
inline bool is_class_c() const;
inline bool is_multicast() const;
friend bool operator==(const address_v4& a1, const address_v4& a2)
;
friend bool operator!=(const address_v4& a1, const address_v4& a2)
;
friend bool operator<(const address_v4& a1, const address_v4& a2)
;
friend bool operator>(const address_v4& a1, const address_v4& a2)
;
friend bool operator<=(const address_v4& a1, const address_v4& a2)
;
friend bool operator>=(const address_v4& a1, const address_v4& a2)
;
static address_v4 any()
;
static address_v4 loopback()
;
static address_v4 broadcast()
;
inline static address_v4 broadcast(
const address_v4& addr, const address_v4& mask);
inline static address_v4 netmask(const address_v4& addr);
private:
boost::asio::detail::in4_addr_type addr_;
};
template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os, const address_v4& addr);
}
}
}
#define BOOST_ASIO_IP_IMPL_ADDRESS_V4_HPP
namespace boost {
namespace asio {
namespace ip {
template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os, const address_v4& addr)
;
}
}
}
#define BOOST_ASIO_IP_IMPL_ADDRESS_V4_IPP
namespace boost {
namespace asio {
namespace ip {
bool address_v4::is_loopback() const
{
return (to_ulong() & 0xFF000000) == 0x7F000000;
}
bool address_v4::is_unspecified() const
{
return to_ulong() == 0;
}
bool address_v4::is_class_a() const
{
return (to_ulong() & 0x80000000) == 0;
}
bool address_v4::is_class_b() const
{
return (to_ulong() & 0xC0000000) == 0x80000000;
}
bool address_v4::is_class_c() const
{
return (to_ulong() & 0xE0000000) == 0xC0000000;
}
bool address_v4::is_multicast() const
{
return (to_ulong() & 0xF0000000) == 0xE0000000;
}
}
}
}
#define BOOST_ASIO_IP_ADDRESS_V6_HPP
namespace boost {
namespace asio {
namespace ip {
class address_v6
{
public:
typedef boost::asio::detail::array<unsigned char, 16> bytes_type;
inline address_v6();
inline explicit address_v6(const bytes_type& bytes,
unsigned long scope_id = 0);
inline address_v6(const address_v6& other);
inline address_v6(address_v6&& other);
inline address_v6& operator=(const address_v6& other);
inline address_v6& operator=(address_v6&& other);
unsigned long scope_id() const
;
void scope_id(unsigned long id)
;
inline bytes_type to_bytes() const;
inline std::string to_string() const;
inline std::string to_string(boost::system::error_code& ec) const;
inline static address_v6 from_string(const char* str);
inline static address_v6 from_string(
const char* str, boost::system::error_code& ec);
inline static address_v6 from_string(const std::string& str);
inline static address_v6 from_string(
const std::string& str, boost::system::error_code& ec);
inline address_v4 to_v4() const;
inline bool is_loopback() const;
inline bool is_unspecified() const;
inline bool is_link_local() const;
inline bool is_site_local() const;
inline bool is_v4_mapped() const;
inline bool is_v4_compatible() const;
inline bool is_multicast() const;
inline bool is_multicast_global() const;
inline bool is_multicast_link_local() const;
inline bool is_multicast_node_local() const;
inline bool is_multicast_org_local() const;
inline bool is_multicast_site_local() const;
inline friend bool operator==(
const address_v6& a1, const address_v6& a2);
friend bool operator!=(const address_v6& a1, const address_v6& a2)
;
inline friend bool operator<(
const address_v6& a1, const address_v6& a2);
friend bool operator>(const address_v6& a1, const address_v6& a2)
;
friend bool operator<=(const address_v6& a1, const address_v6& a2)
;
friend bool operator>=(const address_v6& a1, const address_v6& a2)
;
static address_v6 any()
;
inline static address_v6 loopback();
inline static address_v6 v4_mapped(const address_v4& addr);
inline static address_v6 v4_compatible(const address_v4& addr);
private:
boost::asio::detail::in6_addr_type addr_;
unsigned long scope_id_;
};
template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os, const address_v6& addr);
}
}
}
#define BOOST_ASIO_IP_IMPL_ADDRESS_V6_HPP
namespace boost {
namespace asio {
namespace ip {
template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os, const address_v6& addr)
;
}
}
}
#define BOOST_ASIO_IP_IMPL_ADDRESS_V6_IPP
namespace boost {
namespace asio {
namespace ip {
bool address_v6::is_loopback() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
&& (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
&& (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
&& (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
&& (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
&& (addr_.__in6_u.__u6_addr8[10] == 0) && (addr_.__in6_u.__u6_addr8[11] == 0)
&& (addr_.__in6_u.__u6_addr8[12] == 0) && (addr_.__in6_u.__u6_addr8[13] == 0)
&& (addr_.__in6_u.__u6_addr8[14] == 0) && (addr_.__in6_u.__u6_addr8[15] == 1));
}
bool address_v6::is_unspecified() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
&& (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
&& (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
&& (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
&& (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
&& (addr_.__in6_u.__u6_addr8[10] == 0) && (addr_.__in6_u.__u6_addr8[11] == 0)
&& (addr_.__in6_u.__u6_addr8[12] == 0) && (addr_.__in6_u.__u6_addr8[13] == 0)
&& (addr_.__in6_u.__u6_addr8[14] == 0) && (addr_.__in6_u.__u6_addr8[15] == 0));
}
bool address_v6::is_link_local() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0xfe) && ((addr_.__in6_u.__u6_addr8[1] & 0xc0) == 0x80));
}
bool address_v6::is_site_local() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0xfe) && ((addr_.__in6_u.__u6_addr8[1] & 0xc0) == 0xc0));
}
bool address_v6::is_v4_mapped() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
&& (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
&& (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
&& (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
&& (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
&& (addr_.__in6_u.__u6_addr8[10] == 0xff) && (addr_.__in6_u.__u6_addr8[11] == 0xff));
}
bool address_v6::is_v4_compatible() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
&& (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
&& (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
&& (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
&& (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
&& (addr_.__in6_u.__u6_addr8[10] == 0) && (addr_.__in6_u.__u6_addr8[11] == 0)
&& !((addr_.__in6_u.__u6_addr8[12] == 0)
&& (addr_.__in6_u.__u6_addr8[13] == 0)
&& (addr_.__in6_u.__u6_addr8[14] == 0)
&& ((addr_.__in6_u.__u6_addr8[15] == 0) || (addr_.__in6_u.__u6_addr8[15] == 1))));
}
bool address_v6::is_multicast() const
{
return (addr_.__in6_u.__u6_addr8[0] == 0xff);
}
bool address_v6::is_multicast_global() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x0e));
}
bool address_v6::is_multicast_link_local() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x02));
}
bool address_v6::is_multicast_node_local() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x01));
}
bool address_v6::is_multicast_org_local() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x08));
}
bool address_v6::is_multicast_site_local() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x05));
}
bool operator==(const address_v6& a1, const address_v6& a2)
;
bool operator<(const address_v6& a1, const address_v6& a2)
;
}
}
}
namespace boost {
namespace asio {
namespace ip {
class address
{
public:
inline address();
inline address(const boost::asio::ip::address_v4& ipv4_address);
inline address(const boost::asio::ip::address_v6& ipv6_address);
inline address(const address& other);
inline address(address&& other);
inline address& operator=(const address& other);
inline address& operator=(address&& other);
inline address& operator=(
const boost::asio::ip::address_v4& ipv4_address);
inline address& operator=(
const boost::asio::ip::address_v6& ipv6_address);
bool is_v4() const
;
bool is_v6() const
;
inline boost::asio::ip::address_v4 to_v4() const;
inline boost::asio::ip::address_v6 to_v6() const;
inline std::string to_string() const;
inline std::string to_string(boost::system::error_code& ec) const;
inline static address from_string(const char* str);
inline static address from_string(
const char* str, boost::system::error_code& ec);
inline static address from_string(const std::string& str);
inline static address from_string(
const std::string& str, boost::system::error_code& ec);
inline bool is_loopback() const;
inline bool is_unspecified() const;
inline bool is_multicast() const;
inline friend bool operator==(const address& a1, const address& a2);
friend bool operator!=(const address& a1, const address& a2)
;
inline friend bool operator<(const address& a1, const address& a2);
friend bool operator>(const address& a1, const address& a2)
;
friend bool operator<=(const address& a1, const address& a2)
;
friend bool operator>=(const address& a1, const address& a2)
;
private:
enum { ipv4, ipv6 } type_;
boost::asio::ip::address_v4 ipv4_address_;
boost::asio::ip::address_v6 ipv6_address_;
};
template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os, const address& addr);
}
}
}
#define BOOST_ASIO_IP_IMPL_ADDRESS_HPP
namespace boost {
namespace asio {
namespace ip {
template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os, const address& addr)
;
}
}
}
#define BOOST_ASIO_IP_IMPL_ADDRESS_IPP
namespace boost {
namespace asio {
namespace ip {
bool address::is_loopback() const
{
return (type_ == ipv4)
? ipv4_address_.is_loopback()
: ipv6_address_.is_loopback();
}
bool address::is_unspecified() const
{
return (type_ == ipv4)
? ipv4_address_.is_unspecified()
: ipv6_address_.is_unspecified();
}
bool address::is_multicast() const
{
return (type_ == ipv4)
? ipv4_address_.is_multicast()
: ipv6_address_.is_multicast();
}
bool operator==(const address& a1, const address& a2)
;
bool operator<(const address& a1, const address& a2)
;
}
}
}
#define BOOST_ASIO_IP_BASIC_ENDPOINT_HPP
#define BOOST_ASIO_IP_DETAIL_ENDPOINT_HPP
namespace boost {
namespace asio {
namespace ip {
namespace detail {
class endpoint
{
public:
inline endpoint();
inline endpoint(int family, unsigned short port_num);
inline endpoint(const boost::asio::ip::address& addr,
unsigned short port_num);
endpoint(const endpoint& other)
;
endpoint& operator=(const endpoint& other)
;
boost::asio::detail::socket_addr_type* data()
;
const boost::asio::detail::socket_addr_type* data() const
;
std::size_t size() const
;
inline void resize(std::size_t new_size);
std::size_t capacity() const
;
inline unsigned short port() const;
inline void port(unsigned short port_num);
inline boost::asio::ip::address address() const;
inline void address(const boost::asio::ip::address& addr);
inline friend bool operator==(
const endpoint& e1, const endpoint& e2);
inline friend bool operator<(
const endpoint& e1, const endpoint& e2);
bool is_v4() const
;
inline std::string to_string(boost::system::error_code& ec) const;
private:
union data_union
{
boost::asio::detail::socket_addr_type base;
boost::asio::detail::sockaddr_in4_type v4;
boost::asio::detail::sockaddr_in6_type v6;
} data_;
};
}
}
}
}
#define BOOST_ASIO_IP_DETAIL_IMPL_ENDPOINT_IPP
namespace boost {
namespace asio {
namespace ip {
namespace detail {
bool operator==(const endpoint& e1, const endpoint& e2)
;
bool operator<(const endpoint& e1, const endpoint& e2)
;
}
}
}
}
namespace boost {
namespace asio {
namespace ip {
template <typename InternetProtocol>
class basic_endpoint
{
public:
typedef InternetProtocol protocol_type;
typedef boost::asio::detail::socket_addr_type data_type;
basic_endpoint()
;
basic_endpoint(const InternetProtocol& internet_protocol,
unsigned short port_num)
;
basic_endpoint(const boost::asio::ip::address& addr, unsigned short port_num)
;
basic_endpoint(const basic_endpoint& other)
;
basic_endpoint(basic_endpoint&& other)
;
basic_endpoint& operator=(const basic_endpoint& other)
;
basic_endpoint& operator=(basic_endpoint&& other)
;
protocol_type protocol() const
;
data_type* data()
;
const data_type* data() const
;
std::size_t size() const
;
void resize(std::size_t new_size)
;
std::size_t capacity() const
;
unsigned short port() const
;
void port(unsigned short port_num)
;
boost::asio::ip::address address() const
;
void address(const boost::asio::ip::address& addr)
;
friend bool operator==(const basic_endpoint<InternetProtocol>& e1,
const basic_endpoint<InternetProtocol>& e2)
;
friend bool operator!=(const basic_endpoint<InternetProtocol>& e1,
const basic_endpoint<InternetProtocol>& e2)
;
friend bool operator<(const basic_endpoint<InternetProtocol>& e1,
const basic_endpoint<InternetProtocol>& e2)
;
friend bool operator>(const basic_endpoint<InternetProtocol>& e1,
const basic_endpoint<InternetProtocol>& e2)
;
friend bool operator<=(const basic_endpoint<InternetProtocol>& e1,
const basic_endpoint<InternetProtocol>& e2)
;
friend bool operator>=(const basic_endpoint<InternetProtocol>& e1,
const basic_endpoint<InternetProtocol>& e2)
;
private:
boost::asio::ip::detail::endpoint impl_;
};
template <typename Elem, typename Traits, typename InternetProtocol>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os,
const basic_endpoint<InternetProtocol>& endpoint);
}
}
}
#define BOOST_ASIO_IP_IMPL_BASIC_ENDPOINT_HPP
namespace boost {
namespace asio {
namespace ip {
template <typename Elem, typename Traits, typename InternetProtocol>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os,
const basic_endpoint<InternetProtocol>& endpoint)
;
}
}
}
#define BOOST_ASIO_IP_BASIC_RESOLVER_HPP
#define BOOST_ASIO_IP_BASIC_RESOLVER_ITERATOR_HPP
#define BOOST_ASIO_IP_BASIC_RESOLVER_ENTRY_HPP
namespace boost {
namespace asio {
namespace ip {
template <typename InternetProtocol>
class basic_resolver_entry
{
public:
typedef InternetProtocol protocol_type;
typedef typename InternetProtocol::endpoint endpoint_type;
basic_resolver_entry()
;
basic_resolver_entry(const endpoint_type& ep,
const std::string& host, const std::string& service)
;
endpoint_type endpoint() const
;
operator endpoint_type() const
;
std::string host_name() const
;
std::string service_name() const
;
private:
endpoint_type endpoint_;
std::string host_name_;
std::string service_name_;
};
}
}
}
namespace boost {
namespace asio {
namespace ip {
template <typename InternetProtocol>
class basic_resolver_iterator
{
public:
typedef std::ptrdiff_t difference_type;
typedef basic_resolver_entry<InternetProtocol> value_type;
typedef const basic_resolver_entry<InternetProtocol>* pointer;
typedef const basic_resolver_entry<InternetProtocol>& reference;
typedef std::forward_iterator_tag iterator_category;
basic_resolver_iterator()
;
static basic_resolver_iterator create(
boost::asio::detail::addrinfo_type* address_info,
const std::string& host_name, const std::string& service_name)
;
static basic_resolver_iterator create(
const typename InternetProtocol::endpoint& endpoint,
const std::string& host_name, const std::string& service_name)
;
template <typename EndpointIterator>
static basic_resolver_iterator create(
EndpointIterator begin, EndpointIterator end,
const std::string& host_name, const std::string& service_name)
;
const basic_resolver_entry<InternetProtocol>& operator*() const
;
const basic_resolver_entry<InternetProtocol>* operator->() const
;
basic_resolver_iterator& operator++()
;
basic_resolver_iterator operator++(int)
;
friend bool operator==(const basic_resolver_iterator& a,
const basic_resolver_iterator& b)
;
friend bool operator!=(const basic_resolver_iterator& a,
const basic_resolver_iterator& b)
;
private:
void increment()
;
bool equal(const basic_resolver_iterator& other) const
;
const basic_resolver_entry<InternetProtocol>& dereference() const
;
typedef std::vector<basic_resolver_entry<InternetProtocol> > values_type;
boost::asio::detail::shared_ptr<values_type> values_;
std::size_t index_;
};
}
}
}
#define BOOST_ASIO_IP_BASIC_RESOLVER_QUERY_HPP
#define BOOST_ASIO_IP_RESOLVER_QUERY_BASE_HPP
namespace boost {
namespace asio {
namespace ip {
class resolver_query_base
{
public:
enum flags
{
canonical_name = 0x0002,
passive = 0x0001,
numeric_host = 0x0004,
numeric_service = 0x0400,
v4_mapped = 0x0008,
all_matching = 0x0010,
address_configured = 0x0020
};
friend flags operator&(flags x, flags y)
;
friend flags operator|(flags x, flags y)
;
friend flags operator^(flags x, flags y)
;
friend flags operator~(flags x)
;
friend flags& operator&=(flags& x, flags y)
;
friend flags& operator|=(flags& x, flags y)
;
friend flags& operator^=(flags& x, flags y)
;
protected:
~resolver_query_base()
;
};
}
}
}
namespace boost {
namespace asio {
namespace ip {
template <typename InternetProtocol>
class basic_resolver_query
: public resolver_query_base
{
public:
typedef InternetProtocol protocol_type;
basic_resolver_query(const std::string& service,
resolver_query_base::flags resolve_flags = passive | address_configured)
;
basic_resolver_query(const protocol_type& protocol,
const std::string& service,
resolver_query_base::flags resolve_flags = passive | address_configured)
;
basic_resolver_query(const std::string& host, const std::string& service,
resolver_query_base::flags resolve_flags = address_configured)
;
basic_resolver_query(const protocol_type& protocol,
const std::string& host, const std::string& service,
resolver_query_base::flags resolve_flags = address_configured)
;
const boost::asio::detail::addrinfo_type& hints() const
;
std::string host_name() const
;
std::string service_name() const
;
private:
boost::asio::detail::addrinfo_type hints_;
std::string host_name_;
std::string service_name_;
};
}
}
}
#define BOOST_ASIO_IP_RESOLVER_SERVICE_HPP
#define BOOST_ASIO_DETAIL_RESOLVER_SERVICE_HPP
#define BOOST_ASIO_DETAIL_RESOLVER_ENDPOINT_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Protocol, typename Handler>
class resolve_endpoint_op : public operation
{
public:
struct ptr { Handler* h; void* v; resolve_endpoint_op* p; ~ptr() ; void reset() ; };
typedef typename Protocol::endpoint endpoint_type;
typedef boost::asio::ip::basic_resolver_iterator<Protocol> iterator_type;
resolve_endpoint_op(socket_ops::weak_cancel_token_type cancel_token,
const endpoint_type& endpoint, io_service_impl& ios, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
socket_ops::weak_cancel_token_type cancel_token_;
endpoint_type endpoint_;
io_service_impl& io_service_impl_;
Handler handler_;
boost::system::error_code ec_;
iterator_type iter_;
};
}
}
}
#define BOOST_ASIO_DETAIL_RESOLVE_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Protocol, typename Handler>
class resolve_op : public operation
{
public:
struct ptr { Handler* h; void* v; resolve_op* p; ~ptr() ; void reset() ; };
typedef boost::asio::ip::basic_resolver_query<Protocol> query_type;
typedef boost::asio::ip::basic_resolver_iterator<Protocol> iterator_type;
resolve_op(socket_ops::weak_cancel_token_type cancel_token,
const query_type& query, io_service_impl& ios, Handler& handler)
;
~resolve_op()
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
socket_ops::weak_cancel_token_type cancel_token_;
query_type query_;
io_service_impl& io_service_impl_;
Handler handler_;
boost::system::error_code ec_;
boost::asio::detail::addrinfo_type* addrinfo_;
};
}
}
}
#define BOOST_ASIO_DETAIL_RESOLVER_SERVICE_BASE_HPP
#define BOOST_ASIO_DETAIL_THREAD_HPP
#define BOOST_ASIO_DETAIL_POSIX_THREAD_HPP
namespace boost {
namespace asio {
namespace detail {
extern "C"
{
inline void* boost_asio_detail_posix_thread_function(void* arg);
}
class posix_thread
: private noncopyable
{
public:
template <typename Function>
posix_thread(Function f, unsigned int = 0)
;
inline ~posix_thread();
inline void join();
private:
friend void* boost_asio_detail_posix_thread_function(void* arg);
class func_base
{
public:
virtual ~func_base() ;
virtual void run() = 0;
};
struct auto_func_base_ptr
{
func_base* ptr;
~auto_func_base_ptr() ;
};
template <typename Function>
class func
: public func_base
{
public:
func(Function f)
;
virtual void run()
;
private:
Function f_;
};
inline void start_thread(func_base* arg);
::pthread_t thread_;
bool joined_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_POSIX_THREAD_IPP
namespace boost {
namespace asio {
namespace detail {
void* boost_asio_detail_posix_thread_function(void* arg)
;
}
}
}
namespace boost {
namespace asio {
namespace detail {
typedef posix_thread thread;
}
}
}
namespace boost {
namespace asio {
namespace detail {
class resolver_service_base
{
public:
typedef socket_ops::shared_cancel_token_type implementation_type;
inline resolver_service_base(boost::asio::io_service& io_service);
inline ~resolver_service_base();
inline void shutdown_service();
inline void fork_service(
boost::asio::io_service::fork_event fork_ev);
inline void construct(implementation_type& impl);
inline void destroy(implementation_type&);
inline void cancel(implementation_type& impl);
protected:
inline void start_resolve_op(operation* op);
class auto_addrinfo
: private boost::asio::detail::noncopyable
{
public:
explicit auto_addrinfo(boost::asio::detail::addrinfo_type* ai)
;
~auto_addrinfo()
;
operator boost::asio::detail::addrinfo_type*()
;
private:
boost::asio::detail::addrinfo_type* ai_;
};
class work_io_service_runner;
inline void start_work_thread();
io_service_impl& io_service_impl_;
private:
boost::asio::detail::mutex mutex_;
boost::asio::detail::scoped_ptr<boost::asio::io_service> work_io_service_;
io_service_impl& work_io_service_impl_;
boost::asio::detail::scoped_ptr<boost::asio::io_service::work> work_;
boost::asio::detail::scoped_ptr<boost::asio::detail::thread> work_thread_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_RESOLVER_SERVICE_BASE_IPP
namespace boost {
namespace asio {
namespace detail {
class resolver_service_base::work_io_service_runner
{
public:
work_io_service_runner(boost::asio::io_service& io_service) ;
void operator()() ;
private:
boost::asio::io_service& io_service_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Protocol>
class resolver_service : public resolver_service_base
{
public:
typedef socket_ops::shared_cancel_token_type implementation_type;
typedef typename Protocol::endpoint endpoint_type;
typedef boost::asio::ip::basic_resolver_query<Protocol> query_type;
typedef boost::asio::ip::basic_resolver_iterator<Protocol> iterator_type;
resolver_service(boost::asio::io_service& io_service)
;
iterator_type resolve(implementation_type&, const query_type& query,
boost::system::error_code& ec)
;
template <typename Handler>
void async_resolve(implementation_type& impl,
const query_type& query, Handler& handler)
;
iterator_type resolve(implementation_type&,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
template <typename Handler>
void async_resolve(implementation_type& impl,
const endpoint_type& endpoint, Handler& handler)
;
};
}
}
}
namespace boost {
namespace asio {
namespace ip {
template <typename InternetProtocol>
class resolver_service
: public boost::asio::detail::service_base<
resolver_service<InternetProtocol> >
{
public:
typedef InternetProtocol protocol_type;
typedef typename InternetProtocol::endpoint endpoint_type;
typedef basic_resolver_query<InternetProtocol> query_type;
typedef basic_resolver_iterator<InternetProtocol> iterator_type;
private:
typedef boost::asio::detail::resolver_service<InternetProtocol>
service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
explicit resolver_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void destroy(implementation_type& impl)
;
void cancel(implementation_type& impl)
;
iterator_type resolve(implementation_type& impl, const query_type& query,
boost::system::error_code& ec)
;
template <typename ResolveHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ResolveHandler, void (boost::system::error_code, iterator_type)>::type>::type
async_resolve(implementation_type& impl, const query_type& query,
ResolveHandler&& handler)
;
iterator_type resolve(implementation_type& impl,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
template <typename ResolveHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ResolveHandler, void (boost::system::error_code, iterator_type)>::type>::type
async_resolve(implementation_type& impl, const endpoint_type& endpoint,
ResolveHandler&& handler)
;
private:
void shutdown_service()
;
void fork_service(boost::asio::io_service::fork_event event)
;
service_impl_type service_impl_;
};
}
}
}
namespace boost {
namespace asio {
namespace ip {
template <typename InternetProtocol,
typename ResolverService = resolver_service<InternetProtocol> >
class basic_resolver
: public basic_io_object<ResolverService>
{
public:
typedef InternetProtocol protocol_type;
typedef typename InternetProtocol::endpoint endpoint_type;
typedef basic_resolver_query<InternetProtocol> query;
typedef basic_resolver_iterator<InternetProtocol> iterator;
explicit basic_resolver(boost::asio::io_service& io_service)
;
void cancel()
;
iterator resolve(const query& q)
;
iterator resolve(const query& q, boost::system::error_code& ec)
;
template <typename ResolveHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ResolveHandler, void (boost::system::error_code, iterator)>::type>::type
async_resolve(const query& q,
ResolveHandler&& handler)
;
iterator resolve(const endpoint_type& e)
;
iterator resolve(const endpoint_type& e, boost::system::error_code& ec)
;
template <typename ResolveHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ResolveHandler, void (boost::system::error_code, iterator)>::type>::type
async_resolve(const endpoint_type& e,
ResolveHandler&& handler)
;
};
}
}
}
#define BOOST_ASIO_IP_HOST_NAME_HPP
namespace boost {
namespace asio {
namespace ip {
inline std::string host_name();
inline std::string host_name(boost::system::error_code& ec);
}
}
}
#define BOOST_ASIO_IP_IMPL_HOST_NAME_IPP
namespace boost {
namespace asio {
namespace ip {
std::string host_name()
;
std::string host_name(boost::system::error_code& ec)
;
}
}
}
#define BOOST_ASIO_IP_ICMP_HPP
namespace boost {
namespace asio {
namespace ip {
class icmp
{
public:
typedef basic_endpoint<icmp> endpoint;
static icmp v4()
;
static icmp v6()
;
int type() const
;
int protocol() const
;
int family() const
;
typedef basic_raw_socket<icmp> socket;
typedef basic_resolver<icmp> resolver;
friend bool operator==(const icmp& p1, const icmp& p2)
;
friend bool operator!=(const icmp& p1, const icmp& p2)
;
private:
explicit icmp(int protocol_id, int protocol_family)
;
int protocol_;
int family_;
};
}
}
}
#define BOOST_ASIO_IP_MULTICAST_HPP
#define BOOST_ASIO_IP_DETAIL_SOCKET_OPTION_HPP
namespace boost {
namespace asio {
namespace ip {
namespace detail {
namespace socket_option {
template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
class multicast_enable_loopback
{
public:
typedef int ipv4_value_type;
typedef int ipv6_value_type;
multicast_enable_loopback()
;
explicit multicast_enable_loopback(bool v)
;
multicast_enable_loopback& operator=(bool v)
;
bool value() const
;
operator bool() const
;
bool operator!() const
;
template <typename Protocol>
int level(const Protocol& protocol) const
;
template <typename Protocol>
int name(const Protocol& protocol) const
;
template <typename Protocol>
void* data(const Protocol& protocol)
;
template <typename Protocol>
const void* data(const Protocol& protocol) const
;
template <typename Protocol>
std::size_t size(const Protocol& protocol) const
;
template <typename Protocol>
void resize(const Protocol& protocol, std::size_t s)
;
private:
ipv4_value_type ipv4_value_;
ipv6_value_type ipv6_value_;
};
template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
class unicast_hops
{
public:
unicast_hops()
;
explicit unicast_hops(int v)
;
unicast_hops& operator=(int v)
;
int value() const
;
template <typename Protocol>
int level(const Protocol& protocol) const
;
template <typename Protocol>
int name(const Protocol& protocol) const
;
template <typename Protocol>
int* data(const Protocol&)
;
template <typename Protocol>
const int* data(const Protocol&) const
;
template <typename Protocol>
std::size_t size(const Protocol&) const
;
template <typename Protocol>
void resize(const Protocol&, std::size_t s)
;
private:
int value_;
};
template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
class multicast_hops
{
public:
typedef unsigned char ipv4_value_type;
typedef int ipv6_value_type;
multicast_hops()
;
explicit multicast_hops(int v)
;
multicast_hops& operator=(int v)
;
int value() const
;
template <typename Protocol>
int level(const Protocol& protocol) const
;
template <typename Protocol>
int name(const Protocol& protocol) const
;
template <typename Protocol>
void* data(const Protocol& protocol)
;
template <typename Protocol>
const void* data(const Protocol& protocol) const
;
template <typename Protocol>
std::size_t size(const Protocol& protocol) const
;
template <typename Protocol>
void resize(const Protocol& protocol, std::size_t s)
;
private:
ipv4_value_type ipv4_value_;
ipv6_value_type ipv6_value_;
};
template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
class multicast_request
{
public:
multicast_request()
;
explicit multicast_request(const boost::asio::ip::address& multicast_address)
;
explicit multicast_request(
const boost::asio::ip::address_v4& multicast_address,
const boost::asio::ip::address_v4& network_interface
= boost::asio::ip::address_v4::any())
;
explicit multicast_request(
const boost::asio::ip::address_v6& multicast_address,
unsigned long network_interface = 0)
;
template <typename Protocol>
int level(const Protocol& protocol) const
;
template <typename Protocol>
int name(const Protocol& protocol) const
;
template <typename Protocol>
const void* data(const Protocol& protocol) const
;
template <typename Protocol>
std::size_t size(const Protocol& protocol) const
;
private:
boost::asio::detail::in4_mreq_type ipv4_value_;
boost::asio::detail::in6_mreq_type ipv6_value_;
};
template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
class network_interface
{
public:
network_interface()
;
explicit network_interface(const boost::asio::ip::address_v4& ipv4_interface)
;
explicit network_interface(unsigned int ipv6_interface)
;
template <typename Protocol>
int level(const Protocol& protocol) const
;
template <typename Protocol>
int name(const Protocol& protocol) const
;
template <typename Protocol>
const void* data(const Protocol& protocol) const
;
template <typename Protocol>
std::size_t size(const Protocol& protocol) const
;
private:
boost::asio::detail::in4_addr_type ipv4_value_;
unsigned int ipv6_value_;
};
}
}
}
}
}
namespace boost {
namespace asio {
namespace ip {
namespace multicast {
typedef boost::asio::ip::detail::socket_option::multicast_request<
IPPROTO_IP,
35,
IPPROTO_IPV6,
20> join_group;
typedef boost::asio::ip::detail::socket_option::multicast_request<
IPPROTO_IP,
36,
IPPROTO_IPV6,
21> leave_group;
typedef boost::asio::ip::detail::socket_option::network_interface<
IPPROTO_IP,
32,
IPPROTO_IPV6,
17> outbound_interface;
typedef boost::asio::ip::detail::socket_option::multicast_hops<
IPPROTO_IP,
33,
IPPROTO_IPV6,
18> hops;
typedef boost::asio::ip::detail::socket_option::multicast_enable_loopback<
IPPROTO_IP,
34,
IPPROTO_IPV6,
19> enable_loopback;
}
}
}
}
#define BOOST_ASIO_IP_TCP_HPP
namespace boost {
namespace asio {
namespace ip {
class tcp
{
public:
typedef basic_endpoint<tcp> endpoint;
static tcp v4()
;
static tcp v6()
;
int type() const
;
int protocol() const
;
int family() const
;
typedef basic_stream_socket<tcp> socket;
typedef basic_socket_acceptor<tcp> acceptor;
typedef basic_resolver<tcp> resolver;
typedef basic_socket_iostream<tcp> iostream;
typedef boost::asio::detail::socket_option::boolean<
IPPROTO_TCP, 1> no_delay;
friend bool operator==(const tcp& p1, const tcp& p2)
;
friend bool operator!=(const tcp& p1, const tcp& p2)
;
private:
explicit tcp(int protocol_family)
;
int family_;
};
}
}
}
#define BOOST_ASIO_IP_UDP_HPP
namespace boost {
namespace asio {
namespace ip {
class udp
{
public:
typedef basic_endpoint<udp> endpoint;
static udp v4()
;
static udp v6()
;
int type() const
;
int protocol() const
;
int family() const
;
typedef basic_datagram_socket<udp> socket;
typedef basic_resolver<udp> resolver;
friend bool operator==(const udp& p1, const udp& p2)
;
friend bool operator!=(const udp& p1, const udp& p2)
;
private:
explicit udp(int protocol_family)
;
int family_;
};
}
}
}
#define BOOST_ASIO_IP_UNICAST_HPP
namespace boost {
namespace asio {
namespace ip {
namespace unicast {
typedef boost::asio::ip::detail::socket_option::unicast_hops<
IPPROTO_IP,
2,
IPPROTO_IPV6,
16> hops;
}
}
}
}
#define BOOST_ASIO_IP_V6_ONLY_HPP
namespace boost {
namespace asio {
namespace ip {
typedef boost::asio::detail::socket_option::boolean<
IPPROTO_IPV6, 26> v6_only;
}
}
}
#define BOOST_ASIO_IS_READ_BUFFERED_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Stream>
char is_read_buffered_helper(buffered_stream<Stream>* s);
template <typename Stream>
char is_read_buffered_helper(buffered_read_stream<Stream>* s);
struct is_read_buffered_big_type { char data[10]; };
is_read_buffered_big_type is_read_buffered_helper(...);
}
template <typename Stream>
class is_read_buffered
{
public:
static const bool value = sizeof(detail::is_read_buffered_helper((Stream*)0)) == 1;
};
}
}
#define BOOST_ASIO_IS_WRITE_BUFFERED_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Stream>
char is_write_buffered_helper(buffered_stream<Stream>* s);
template <typename Stream>
char is_write_buffered_helper(buffered_write_stream<Stream>* s);
struct is_write_buffered_big_type { char data[10]; };
is_write_buffered_big_type is_write_buffered_helper(...);
}
template <typename Stream>
class is_write_buffered
{
public:
static const bool value = sizeof(detail::is_write_buffered_helper((Stream*)0)) == 1;
};
}
}
#define BOOST_ASIO_LOCAL_BASIC_ENDPOINT_HPP
#define BOOST_ASIO_LOCAL_DETAIL_ENDPOINT_HPP
namespace boost {
namespace asio {
namespace local {
namespace detail {
class endpoint
{
public:
inline endpoint();
inline endpoint(const char* path_name);
inline endpoint(const std::string& path_name);
endpoint(const endpoint& other)
;
endpoint& operator=(const endpoint& other)
;
boost::asio::detail::socket_addr_type* data()
;
const boost::asio::detail::socket_addr_type* data() const
;
std::size_t size() const
;
inline void resize(std::size_t size);
std::size_t capacity() const
;
inline std::string path() const;
inline void path(const char* p);
inline void path(const std::string& p);
inline friend bool operator==(
const endpoint& e1, const endpoint& e2);
inline friend bool operator<(
const endpoint& e1, const endpoint& e2);
private:
union data_union
{
boost::asio::detail::socket_addr_type base;
boost::asio::detail::sockaddr_un_type local;
} data_;
std::size_t path_length_;
inline void init(const char* path, std::size_t path_length);
};
}
}
}
}
#define BOOST_ASIO_LOCAL_DETAIL_IMPL_ENDPOINT_IPP
namespace boost {
namespace asio {
namespace local {
namespace detail {
bool operator==(const endpoint& e1, const endpoint& e2)
;
bool operator<(const endpoint& e1, const endpoint& e2)
;
}
}
}
}
namespace boost {
namespace asio {
namespace local {
template <typename Protocol>
class basic_endpoint
{
public:
typedef Protocol protocol_type;
typedef boost::asio::detail::socket_addr_type data_type;
basic_endpoint()
;
basic_endpoint(const char* path_name)
;
basic_endpoint(const std::string& path_name)
;
basic_endpoint(const basic_endpoint& other)
;
basic_endpoint(basic_endpoint&& other)
;
basic_endpoint& operator=(const basic_endpoint& other)
;
basic_endpoint& operator=(basic_endpoint&& other)
;
protocol_type protocol() const
;
data_type* data()
;
const data_type* data() const
;
std::size_t size() const
;
void resize(std::size_t new_size)
;
std::size_t capacity() const
;
std::string path() const
;
void path(const char* p)
;
void path(const std::string& p)
;
friend bool operator==(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator!=(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator<(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator>(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator<=(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator>=(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
private:
boost::asio::local::detail::endpoint impl_;
};
template <typename Elem, typename Traits, typename Protocol>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os,
const basic_endpoint<Protocol>& endpoint)
;
}
}
}
#define BOOST_ASIO_LOCAL_CONNECT_PAIR_HPP
namespace boost {
namespace asio {
namespace local {
template <typename Protocol, typename SocketService1, typename SocketService2>
void connect_pair(
basic_socket<Protocol, SocketService1>& socket1,
basic_socket<Protocol, SocketService2>& socket2);
template <typename Protocol, typename SocketService1, typename SocketService2>
boost::system::error_code connect_pair(
basic_socket<Protocol, SocketService1>& socket1,
basic_socket<Protocol, SocketService2>& socket2,
boost::system::error_code& ec);
template <typename Protocol, typename SocketService1, typename SocketService2>
void connect_pair(
basic_socket<Protocol, SocketService1>& socket1,
basic_socket<Protocol, SocketService2>& socket2)
;
template <typename Protocol, typename SocketService1, typename SocketService2>
boost::system::error_code connect_pair(
basic_socket<Protocol, SocketService1>& socket1,
basic_socket<Protocol, SocketService2>& socket2,
boost::system::error_code& ec)
;
}
}
}
#define BOOST_ASIO_LOCAL_DATAGRAM_PROTOCOL_HPP
namespace boost {
namespace asio {
namespace local {
class datagram_protocol
{
public:
int type() const
;
int protocol() const
;
int family() const
;
typedef basic_endpoint<datagram_protocol> endpoint;
typedef basic_datagram_socket<datagram_protocol> socket;
};
}
}
}
#define BOOST_ASIO_LOCAL_STREAM_PROTOCOL_HPP
namespace boost {
namespace asio {
namespace local {
class stream_protocol
{
public:
int type() const
;
int protocol() const
;
int family() const
;
typedef basic_endpoint<stream_protocol> endpoint;
typedef basic_stream_socket<stream_protocol> socket;
typedef basic_socket_acceptor<stream_protocol> acceptor;
typedef basic_socket_iostream<stream_protocol> iostream;
};
}
}
}
#define BOOST_ASIO_PLACEHOLDERS_HPP
#define BOOST_BIND_ARG_HPP_INCLUDED
#define BOOST_IS_PLACEHOLDER_HPP_INCLUDED
namespace boost
{
template< class T > struct is_placeholder
{
enum _vt { value = 0 };
};
}
namespace boost
{
template< int I > struct arg
{
arg()
;
template< class T > arg( T const & )
;
};
template< int I > bool operator==( arg<I> const &, arg<I> const & )
;
template< int I > struct is_placeholder< arg<I> >
{
enum _vt { value = I };
};
template< int I > struct is_placeholder< arg<I> (*) () >
{
enum _vt { value = I };
};
}
namespace boost {
namespace asio {
namespace placeholders {
boost::arg<1> error()
;
boost::arg<2> bytes_transferred()
;
boost::arg<2> iterator()
;
boost::arg<2> signal_number()
;
}
}
}
#define BOOST_ASIO_POSIX_BASIC_DESCRIPTOR_HPP
#define BOOST_ASIO_POSIX_DESCRIPTOR_BASE_HPP
namespace boost {
namespace asio {
namespace posix {
class descriptor_base
{
public:
typedef boost::asio::detail::io_control::non_blocking_io non_blocking_io;
typedef boost::asio::detail::io_control::bytes_readable bytes_readable;
protected:
~descriptor_base()
;
};
}
}
}
namespace boost {
namespace asio {
namespace posix {
template <typename DescriptorService>
class basic_descriptor
: public basic_io_object<DescriptorService>,
public descriptor_base
{
public:
typedef typename DescriptorService::native_handle_type native_type;
typedef typename DescriptorService::native_handle_type native_handle_type;
typedef basic_descriptor<DescriptorService> lowest_layer_type;
explicit basic_descriptor(boost::asio::io_service& io_service)
;
basic_descriptor(boost::asio::io_service& io_service,
const native_handle_type& native_descriptor)
;
basic_descriptor(basic_descriptor&& other)
;
basic_descriptor& operator=(basic_descriptor&& other)
;
lowest_layer_type& lowest_layer()
;
const lowest_layer_type& lowest_layer() const
;
void assign(const native_handle_type& native_descriptor)
;
boost::system::error_code assign(const native_handle_type& native_descriptor,
boost::system::error_code& ec)
;
bool is_open() const
;
void close()
;
boost::system::error_code close(boost::system::error_code& ec)
;
native_type native()
;
native_handle_type native_handle()
;
native_handle_type release()
;
void cancel()
;
boost::system::error_code cancel(boost::system::error_code& ec)
;
template <typename IoControlCommand>
void io_control(IoControlCommand& command)
;
template <typename IoControlCommand>
boost::system::error_code io_control(IoControlCommand& command,
boost::system::error_code& ec)
;
bool non_blocking() const
;
void non_blocking(bool mode)
;
boost::system::error_code non_blocking(
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking() const
;
void native_non_blocking(bool mode)
;
boost::system::error_code native_non_blocking(
bool mode, boost::system::error_code& ec)
;
protected:
~basic_descriptor()
;
};
}
}
}
#define BOOST_ASIO_POSIX_BASIC_STREAM_DESCRIPTOR_HPP
#define BOOST_ASIO_POSIX_STREAM_DESCRIPTOR_SERVICE_HPP
namespace boost {
namespace asio {
namespace posix {
class stream_descriptor_service
: public boost::asio::detail::service_base<stream_descriptor_service>
{
public:
private:
typedef detail::reactive_descriptor_service service_impl_type;
public:
typedef service_impl_type::implementation_type implementation_type;
typedef service_impl_type::native_handle_type native_type;
typedef service_impl_type::native_handle_type native_handle_type;
explicit stream_descriptor_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
stream_descriptor_service& other_service,
implementation_type& other_impl)
;
void destroy(implementation_type& impl)
;
boost::system::error_code assign(implementation_type& impl,
const native_handle_type& native_descriptor,
boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_type native(implementation_type& impl)
;
native_handle_type native_handle(implementation_type& impl)
;
native_handle_type release(implementation_type& impl)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
template <typename IoControlCommand>
boost::system::error_code io_control(implementation_type& impl,
IoControlCommand& command, boost::system::error_code& ec)
;
bool non_blocking(const implementation_type& impl) const
;
boost::system::error_code non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const implementation_type& impl) const
;
boost::system::error_code native_non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t write_some(implementation_type& impl,
const ConstBufferSequence& buffers, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(implementation_type& impl,
const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t read_some(implementation_type& impl,
const MutableBufferSequence& buffers, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(implementation_type& impl,
const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
}
namespace boost {
namespace asio {
namespace posix {
template <typename StreamDescriptorService = stream_descriptor_service>
class basic_stream_descriptor
: public basic_descriptor<StreamDescriptorService>
{
public:
typedef typename StreamDescriptorService::native_handle_type native_type;
typedef typename StreamDescriptorService::native_handle_type
native_handle_type;
explicit basic_stream_descriptor(boost::asio::io_service& io_service)
;
basic_stream_descriptor(boost::asio::io_service& io_service,
const native_handle_type& native_descriptor)
;
basic_stream_descriptor(basic_stream_descriptor&& other)
;
basic_stream_descriptor& operator=(basic_stream_descriptor&& other)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
};
}
}
}
#define BOOST_ASIO_POSIX_STREAM_DESCRIPTOR_HPP
namespace boost {
namespace asio {
namespace posix {
typedef basic_stream_descriptor<> stream_descriptor;
}
}
}
#define BOOST_ASIO_READ_HPP
namespace boost {
namespace asio {
template <typename SyncReadStream, typename MutableBufferSequence>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers);
template <typename SyncReadStream, typename MutableBufferSequence>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
boost::system::error_code& ec);
template <typename SyncReadStream, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
CompletionCondition completion_condition);
template <typename SyncReadStream, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
CompletionCondition completion_condition, boost::system::error_code& ec);
template <typename SyncReadStream, typename Allocator>
std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b);
template <typename SyncReadStream, typename Allocator>
std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
boost::system::error_code& ec);
template <typename SyncReadStream, typename Allocator,
typename CompletionCondition>
std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition);
template <typename SyncReadStream, typename Allocator,
typename CompletionCondition>
std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition, boost::system::error_code& ec);
template <typename AsyncReadStream, typename MutableBufferSequence,
typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
ReadHandler&& handler);
template <typename AsyncReadStream, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
CompletionCondition completion_condition,
ReadHandler&& handler);
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
ReadHandler&& handler);
template <typename AsyncReadStream, typename Allocator,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition,
ReadHandler&& handler);
}
}
#define BOOST_ASIO_IMPL_READ_HPP
namespace boost {
namespace asio {
template <typename SyncReadStream, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
CompletionCondition completion_condition, boost::system::error_code& ec)
;
template <typename SyncReadStream, typename MutableBufferSequence>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers)
;
template <typename SyncReadStream, typename MutableBufferSequence>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename SyncReadStream, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
CompletionCondition completion_condition)
;
template <typename SyncReadStream, typename Allocator,
typename CompletionCondition>
std::size_t read(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition, boost::system::error_code& ec)
;
template <typename SyncReadStream, typename Allocator>
std::size_t read(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b)
;
template <typename SyncReadStream, typename Allocator>
std::size_t read(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
boost::system::error_code& ec)
;
template <typename SyncReadStream, typename Allocator,
typename CompletionCondition>
std::size_t read(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition)
;
namespace detail
{
template <typename AsyncReadStream, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
class read_op
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_op(AsyncReadStream& stream, const MutableBufferSequence& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_op(const read_op& other)
;
read_op(read_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::asio::detail::consuming_buffers<
mutable_buffer, MutableBufferSequence> buffers_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncReadStream,
typename CompletionCondition, typename ReadHandler>
class read_op<AsyncReadStream, boost::asio::mutable_buffers_1,
CompletionCondition, ReadHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_op(AsyncReadStream& stream,
const boost::asio::mutable_buffers_1& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_op(const read_op& other)
;
read_op(read_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::asio::mutable_buffer buffer_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename Elem,
typename CompletionCondition, typename ReadHandler>
class read_op<AsyncReadStream, boost::array<Elem, 2>,
CompletionCondition, ReadHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_op(AsyncReadStream& stream, const boost::array<Elem, 2>& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_op(const read_op& other)
;
read_op(read_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::array<Elem, 2> buffers_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename Elem,
typename CompletionCondition, typename ReadHandler>
class read_op<AsyncReadStream, std::array<Elem, 2>,
CompletionCondition, ReadHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_op(AsyncReadStream& stream, const std::array<Elem, 2>& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_op(const read_op& other)
;
read_op(read_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
std::array<Elem, 2> buffers_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_op<AsyncReadStream, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_op<AsyncReadStream, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
bool asio_handler_is_continuation(
read_op<AsyncReadStream, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
void asio_handler_invoke(Function& function,
read_op<AsyncReadStream, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_op<AsyncReadStream, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
}
template <typename AsyncReadStream, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
CompletionCondition completion_condition,
ReadHandler&& handler)
;
template <typename AsyncReadStream, typename MutableBufferSequence,
typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
namespace detail
{
template <typename AsyncReadStream, typename Allocator,
typename CompletionCondition, typename ReadHandler>
class read_streambuf_op
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_streambuf_op(AsyncReadStream& stream,
basic_streambuf<Allocator>& streambuf,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_streambuf_op(const read_streambuf_op& other)
;
read_streambuf_op(read_streambuf_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::asio::basic_streambuf<Allocator>& streambuf_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename Allocator,
typename CompletionCondition, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_streambuf_op<AsyncReadStream, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator,
typename CompletionCondition, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_streambuf_op<AsyncReadStream, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator,
typename CompletionCondition, typename ReadHandler>
bool asio_handler_is_continuation(
read_streambuf_op<AsyncReadStream, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream,
typename Allocator, typename CompletionCondition, typename ReadHandler>
void asio_handler_invoke(Function& function,
read_streambuf_op<AsyncReadStream, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream,
typename Allocator, typename CompletionCondition, typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_streambuf_op<AsyncReadStream, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
}
template <typename AsyncReadStream, typename Allocator,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition,
ReadHandler&& handler)
;
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
ReadHandler&& handler)
;
}
}
#define BOOST_ASIO_READ_AT_HPP
namespace boost {
namespace asio {
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers);
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
boost::system::error_code& ec);
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition);
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition, boost::system::error_code& ec);
template <typename SyncRandomAccessReadDevice, typename Allocator>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, basic_streambuf<Allocator>& b);
template <typename SyncRandomAccessReadDevice, typename Allocator>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, basic_streambuf<Allocator>& b,
boost::system::error_code& ec);
template <typename SyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition);
template <typename SyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition, boost::system::error_code& ec);
template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
const MutableBufferSequence& buffers,
ReadHandler&& handler);
template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition,
ReadHandler&& handler);
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
basic_streambuf<Allocator>& b, ReadHandler&& handler);
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d,
uint64_t offset, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition,
ReadHandler&& handler);
}
}
#define BOOST_ASIO_IMPL_READ_AT_HPP
namespace boost {
namespace asio {
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition, boost::system::error_code& ec)
;
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers)
;
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition)
;
template <typename SyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition, boost::system::error_code& ec)
;
template <typename SyncRandomAccessReadDevice, typename Allocator>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, boost::asio::basic_streambuf<Allocator>& b)
;
template <typename SyncRandomAccessReadDevice, typename Allocator>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
boost::system::error_code& ec)
;
template <typename SyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition)
;
namespace detail
{
template <typename AsyncRandomAccessReadDevice,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
class read_at_op
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_at_op(AsyncRandomAccessReadDevice& device,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_at_op(const read_at_op& other)
;
read_at_op(read_at_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncRandomAccessReadDevice& device_;
uint64_t offset_;
boost::asio::detail::consuming_buffers<
mutable_buffer, MutableBufferSequence> buffers_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncRandomAccessReadDevice,
typename CompletionCondition, typename ReadHandler>
class read_at_op<AsyncRandomAccessReadDevice,
boost::asio::mutable_buffers_1, CompletionCondition, ReadHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_at_op(AsyncRandomAccessReadDevice& device,
uint64_t offset, const boost::asio::mutable_buffers_1& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_at_op(const read_at_op& other)
;
read_at_op(read_at_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncRandomAccessReadDevice& device_;
uint64_t offset_;
boost::asio::mutable_buffer buffer_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncRandomAccessReadDevice, typename Elem,
typename CompletionCondition, typename ReadHandler>
class read_at_op<AsyncRandomAccessReadDevice, boost::array<Elem, 2>,
CompletionCondition, ReadHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_at_op(AsyncRandomAccessReadDevice& device,
uint64_t offset, const boost::array<Elem, 2>& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_at_op(const read_at_op& other)
;
read_at_op(read_at_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncRandomAccessReadDevice& device_;
uint64_t offset_;
boost::array<Elem, 2> buffers_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncRandomAccessReadDevice, typename Elem,
typename CompletionCondition, typename ReadHandler>
class read_at_op<AsyncRandomAccessReadDevice, std::array<Elem, 2>,
CompletionCondition, ReadHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_at_op(AsyncRandomAccessReadDevice& device,
uint64_t offset, const std::array<Elem, 2>& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_at_op(const read_at_op& other)
;
read_at_op(read_at_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncRandomAccessReadDevice& device_;
uint64_t offset_;
std::array<Elem, 2> buffers_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncRandomAccessReadDevice,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncRandomAccessReadDevice,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncRandomAccessReadDevice,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
bool asio_handler_is_continuation(
read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncRandomAccessReadDevice,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
void asio_handler_invoke(Function& function,
read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncRandomAccessReadDevice,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncRandomAccessReadDevice,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
read_at_op<AsyncRandomAccessReadDevice,
MutableBufferSequence, CompletionCondition, ReadHandler>
make_read_at_op(AsyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition, ReadHandler handler)
;
}
template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition,
ReadHandler&& handler)
;
template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
namespace detail
{
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition, typename ReadHandler>
class read_at_streambuf_op
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_at_streambuf_op(AsyncRandomAccessReadDevice& device,
uint64_t offset, basic_streambuf<Allocator>& streambuf,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_at_streambuf_op(const read_at_streambuf_op& other)
;
read_at_streambuf_op(read_at_streambuf_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncRandomAccessReadDevice& device_;
uint64_t offset_;
boost::asio::basic_streambuf<Allocator>& streambuf_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition, typename ReadHandler>
bool asio_handler_is_continuation(
read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncRandomAccessReadDevice,
typename Allocator, typename CompletionCondition, typename ReadHandler>
void asio_handler_invoke(Function& function,
read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncRandomAccessReadDevice,
typename Allocator, typename CompletionCondition, typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
}
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d,
uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition,
ReadHandler&& handler)
;
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d,
uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
ReadHandler&& handler)
;
}
}
#define BOOST_ASIO_READ_UNTIL_HPP
#define BOOST_ASIO_DETAIL_REGEX_FWD_HPP
#define BOOST_REGEX_FWD_HPP
#define BOOST_REGEX_CONFIG_HPP
#define BOOST_REGEX_USER_CONFIG <boost/regex/user.hpp>
#define BOOST_RE_VERSION 320
#define BOOST_REGEX_CONFIG_CWCHAR_HPP
#undef __need_mbstate_t
#undef __need_wint_t
namespace std{
extern "C"{
}
}
#define BOOST_REGEX_DECL
#define BOOST_LIB_NAME boost_regex
#undef BOOST_LIB_NAME
#define BOOST_REGEX_CALL
#define BOOST_REGEX_CCALL
#define BOOST_REGEX_USE_CPP_LOCALE
#define BOOST_REGEX_MAX_STATE_COUNT 100000000
#define BOOST_REGEX_NOEH_ASSERT(x)
#define BOOST_REGEX_NON_RECURSIVE
#define BOOST_REGEX_BLOCKSIZE 4096
#define BOOST_REGEX_MAX_BLOCKS 1024
#define BOOST_REGEX_MAX_CACHE_BLOCKS 16
namespace boost{ namespace re_detail{
void* get_mem_block();
void put_mem_block(void*);
}}
#define BOOST_REGEX_FWD_HPP_INCLUDED
namespace boost{
template <class charT>
class cpp_regex_traits;
template <class charT>
struct c_regex_traits;
template <class charT>
class w32_regex_traits;
template <class charT, class implementationT = cpp_regex_traits<charT> >
struct regex_traits;
template <class charT, class traits = regex_traits<charT> >
class basic_regex;
typedef basic_regex<char, regex_traits<char> > regex;
typedef basic_regex<wchar_t, regex_traits<wchar_t> > wregex;
}
#define BOOST_REGEX_V4_MATCH_FLAGS
namespace boost{
namespace regex_constants{
typedef enum _match_flags
{
match_default = 0,
match_not_bol = 1,
match_not_eol = match_not_bol << 1,
match_not_bob = match_not_eol << 1,
match_not_eob = match_not_bob << 1,
match_not_bow = match_not_eob << 1,
match_not_eow = match_not_bow << 1,
match_not_dot_newline = match_not_eow << 1,
match_not_dot_null = match_not_dot_newline << 1,
match_prev_avail = match_not_dot_null << 1,
match_init = match_prev_avail << 1,
match_any = match_init << 1,
match_not_null = match_any << 1,
match_continuous = match_not_null << 1,
match_partial = match_continuous << 1,
match_stop = match_partial << 1,
match_not_initial_null = match_stop,
match_all = match_stop << 1,
match_perl = match_all << 1,
match_posix = match_perl << 1,
match_nosubs = match_posix << 1,
match_extra = match_nosubs << 1,
match_single_line = match_extra << 1,
match_unused1 = match_single_line << 1,
match_unused2 = match_unused1 << 1,
match_unused3 = match_unused2 << 1,
match_max = match_unused3,
format_perl = 0,
format_default = 0,
format_sed = match_max << 1,
format_all = format_sed << 1,
format_no_copy = format_all << 1,
format_first_only = format_no_copy << 1,
format_is_if = format_first_only << 1,
format_literal = format_is_if << 1
} match_flags;
typedef match_flags match_flag_type;
match_flags operator&(match_flags m1, match_flags m2)
;
match_flags operator|(match_flags m1, match_flags m2)
;
match_flags operator^(match_flags m1, match_flags m2)
;
match_flags operator~(match_flags m1)
;
match_flags& operator&=(match_flags& m1, match_flags m2)
;
match_flags& operator|=(match_flags& m1, match_flags m2)
;
match_flags& operator^=(match_flags& m1, match_flags m2)
;
}
using regex_constants::match_flag_type;
using regex_constants::match_default;
using regex_constants::match_not_bol;
using regex_constants::match_not_eol;
using regex_constants::match_not_bob;
using regex_constants::match_not_eob;
using regex_constants::match_not_bow;
using regex_constants::match_not_eow;
using regex_constants::match_not_dot_newline;
using regex_constants::match_not_dot_null;
using regex_constants::match_prev_avail;
using regex_constants::match_any;
using regex_constants::match_not_null;
using regex_constants::match_continuous;
using regex_constants::match_partial;
using regex_constants::match_all;
using regex_constants::match_perl;
using regex_constants::match_posix;
using regex_constants::match_nosubs;
using regex_constants::match_extra;
using regex_constants::match_single_line;
using regex_constants::format_all;
using regex_constants::format_sed;
using regex_constants::format_perl;
using regex_constants::format_default;
using regex_constants::format_no_copy;
using regex_constants::format_first_only;
}
namespace boost {
template <class BidiIterator>
struct sub_match;
template <class BidiIterator, class Allocator>
class match_results;
}
namespace boost {
namespace asio {
namespace detail
{
char (&has_result_type_helper(...))[2];
template <typename T>
char has_result_type_helper(T*, typename T::result_type* = 0);
template <typename T>
struct has_result_type
{
enum { value = (sizeof((has_result_type_helper)((T*)(0))) == 1) };
};
}
template <typename T>
struct is_match_condition
{
enum
{
value = boost::asio::is_function<
typename boost::asio::remove_pointer<T>::type>::value
|| detail::has_result_type<T>::value
};
};
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, char delim);
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, char delim,
boost::system::error_code& ec);
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const std::string& delim);
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const std::string& delim,
boost::system::error_code& ec);
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr);
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
boost::system::error_code& ec);
template <typename SyncReadStream, typename Allocator, typename MatchCondition>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, MatchCondition match_condition,
typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
template <typename SyncReadStream, typename Allocator, typename MatchCondition>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
MatchCondition match_condition, boost::system::error_code& ec,
typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
char delim, ReadHandler&& handler);
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const std::string& delim,
ReadHandler&& handler);
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
ReadHandler&& handler);
template <typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
MatchCondition match_condition, ReadHandler&& handler,
typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
}
}
#define BOOST_ASIO_IMPL_READ_UNTIL_HPP
namespace boost {
namespace asio {
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, char delim)
;
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, char delim,
boost::system::error_code& ec)
;
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const std::string& delim)
;
namespace detail
{
template <typename Iterator1, typename Iterator2>
std::pair<Iterator1, bool> partial_search(
Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2)
;
}
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const std::string& delim,
boost::system::error_code& ec)
;
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr)
;
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
boost::system::error_code& ec)
;
template <typename SyncReadStream, typename Allocator, typename MatchCondition>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
MatchCondition match_condition, boost::system::error_code& ec,
typename enable_if<is_match_condition<MatchCondition>::value>::type*)
;
template <typename SyncReadStream, typename Allocator, typename MatchCondition>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, MatchCondition match_condition,
typename enable_if<is_match_condition<MatchCondition>::value>::type*)
;
namespace detail
{
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
class read_until_delim_op
{
public:
read_until_delim_op(AsyncReadStream& stream,
boost::asio::basic_streambuf<Allocator>& streambuf,
char delim, ReadHandler& handler)
;
read_until_delim_op(const read_until_delim_op& other)
;
read_until_delim_op(read_until_delim_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::asio::basic_streambuf<Allocator>& streambuf_;
char delim_;
int start_;
std::size_t search_position_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_until_delim_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_until_delim_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
bool asio_handler_is_continuation(
read_until_delim_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream, typename Allocator,
typename ReadHandler>
void asio_handler_invoke(Function& function,
read_until_delim_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream, typename Allocator,
typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_until_delim_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
}
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, char delim,
ReadHandler&& handler)
;
namespace detail
{
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
class read_until_delim_string_op
{
public:
read_until_delim_string_op(AsyncReadStream& stream,
boost::asio::basic_streambuf<Allocator>& streambuf,
const std::string& delim, ReadHandler& handler)
;
read_until_delim_string_op(const read_until_delim_string_op& other)
;
read_until_delim_string_op(read_until_delim_string_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::asio::basic_streambuf<Allocator>& streambuf_;
std::string delim_;
int start_;
std::size_t search_position_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_until_delim_string_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_until_delim_string_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
bool asio_handler_is_continuation(
read_until_delim_string_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream,
typename Allocator, typename ReadHandler>
void asio_handler_invoke(Function& function,
read_until_delim_string_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream,
typename Allocator, typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_until_delim_string_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
}
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const std::string& delim,
ReadHandler&& handler)
;
namespace detail
{
template <typename AsyncReadStream, typename Allocator,
typename RegEx, typename ReadHandler>
class read_until_expr_op
{
public:
read_until_expr_op(AsyncReadStream& stream,
boost::asio::basic_streambuf<Allocator>& streambuf,
const boost::regex& expr, ReadHandler& handler)
;
read_until_expr_op(const read_until_expr_op& other)
;
read_until_expr_op(read_until_expr_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::asio::basic_streambuf<Allocator>& streambuf_;
RegEx expr_;
int start_;
std::size_t search_position_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename Allocator,
typename RegEx, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_until_expr_op<AsyncReadStream,
Allocator, RegEx, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator,
typename RegEx, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_until_expr_op<AsyncReadStream,
Allocator, RegEx, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator,
typename RegEx, typename ReadHandler>
bool asio_handler_is_continuation(
read_until_expr_op<AsyncReadStream,
Allocator, RegEx, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream, typename Allocator,
typename RegEx, typename ReadHandler>
void asio_handler_invoke(Function& function,
read_until_expr_op<AsyncReadStream,
Allocator, RegEx, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream, typename Allocator,
typename RegEx, typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_until_expr_op<AsyncReadStream,
Allocator, RegEx, ReadHandler>* this_handler)
;
}
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
ReadHandler&& handler)
;
namespace detail
{
template <typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
class read_until_match_op
{
public:
read_until_match_op(AsyncReadStream& stream,
boost::asio::basic_streambuf<Allocator>& streambuf,
MatchCondition match_condition, ReadHandler& handler)
;
read_until_match_op(const read_until_match_op& other)
;
read_until_match_op(read_until_match_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::asio::basic_streambuf<Allocator>& streambuf_;
MatchCondition match_condition_;
int start_;
std::size_t search_position_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_until_match_op<AsyncReadStream,
Allocator, MatchCondition, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_until_match_op<AsyncReadStream,
Allocator, MatchCondition, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
bool asio_handler_is_continuation(
read_until_match_op<AsyncReadStream,
Allocator, MatchCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
void asio_handler_invoke(Function& function,
read_until_match_op<AsyncReadStream,
Allocator, MatchCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_until_match_op<AsyncReadStream,
Allocator, MatchCondition, ReadHandler>* this_handler)
;
}
template <typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
MatchCondition match_condition, ReadHandler&& handler,
typename enable_if<is_match_condition<MatchCondition>::value>::type*)
;
}
}
#define BOOST_ASIO_SERIAL_PORT_HPP
namespace boost {
namespace asio {
typedef basic_serial_port<> serial_port;
}
}
#define BOOST_ASIO_SIGNAL_SET_HPP
namespace boost {
namespace asio {
typedef basic_signal_set<> signal_set;
}
}
#define BOOST_ASIO_STRAND_HPP
#define BOOST_ASIO_DETAIL_STRAND_SERVICE_HPP
namespace boost {
namespace asio {
namespace detail {
class strand_service
: public boost::asio::detail::service_base<strand_service>
{
private:
struct on_do_complete_exit;
struct on_dispatch_exit;
public:
class strand_impl
: public operation
{
public:
strand_impl();
private:
friend class strand_service;
friend struct on_do_complete_exit;
friend struct on_dispatch_exit;
boost::asio::detail::mutex mutex_;
bool locked_;
op_queue<operation> waiting_queue_;
op_queue<operation> ready_queue_;
};
typedef strand_impl* implementation_type;
inline explicit strand_service(boost::asio::io_service& io_service);
inline void shutdown_service();
inline void construct(implementation_type& impl);
template <typename Handler>
void dispatch(implementation_type& impl, Handler& handler);
template <typename Handler>
void post(implementation_type& impl, Handler& handler);
inline bool running_in_this_thread(
const implementation_type& impl) const;
private:
inline bool do_dispatch(implementation_type& impl, operation* op);
inline void do_post(implementation_type& impl,
operation* op, bool is_continuation);
inline static void do_complete(io_service_impl* owner,
operation* base, const boost::system::error_code& ec,
std::size_t bytes_transferred);
io_service_impl& io_service_;
boost::asio::detail::mutex mutex_;
enum { num_implementations = 193 };
scoped_ptr<strand_impl> implementations_[num_implementations];
std::size_t salt_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_STRAND_SERVICE_HPP
namespace boost {
namespace asio {
namespace detail {
struct strand_service::on_dispatch_exit
{
io_service_impl* io_service_;
strand_impl* impl_;
~on_dispatch_exit()
;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_STRAND_SERVICE_IPP
namespace boost {
namespace asio {
namespace detail {
struct strand_service::on_do_complete_exit
{
io_service_impl* owner_;
strand_impl* impl_;
~on_do_complete_exit()
;
};
bool strand_service::running_in_this_thread(
const implementation_type& impl) const
{
return call_stack<strand_impl>::contains(impl) != 0;
}
bool strand_service::do_dispatch(implementation_type& impl, operation* op)
{
bool can_dispatch = io_service_.can_dispatch();
impl->mutex_.lock();
if (can_dispatch && !impl->locked_)
{
impl->locked_ = true;
impl->mutex_.unlock();
return true;
}
if (impl->locked_)
{
impl->waiting_queue_.push(op);
impl->mutex_.unlock();
}
else
{
impl->locked_ = true;
impl->mutex_.unlock();
impl->ready_queue_.push(op);
io_service_.post_immediate_completion(impl, false);
}
return false;
}
}
}
}
namespace boost {
namespace asio {
class io_service::strand
{
public:
explicit strand(boost::asio::io_service& io_service)
;
~strand()
;
boost::asio::io_service& get_io_service()
;
template <typename CompletionHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<CompletionHandler, void ()>::type>::type
dispatch(CompletionHandler&& handler)
;
template <typename CompletionHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<CompletionHandler, void ()>::type>::type
post(CompletionHandler&& handler)
;
template <typename Handler>
detail::wrapped_handler<strand, Handler, detail::is_continuation_if_running>
wrap(Handler handler)
;
bool running_in_this_thread() const
;
private:
boost::asio::detail::strand_service& service_;
boost::asio::detail::strand_service::implementation_type impl_;
};
typedef boost::asio::io_service::strand strand;
}
}
#define BOOST_ASIO_STREAMBUF_HPP
namespace boost {
namespace asio {
typedef basic_streambuf<> streambuf;
}
}
#define BOOST_ASIO_VERSION_HPP
#define BOOST_ASIO_VERSION 101001
#define BOOST_ASIO_WINDOWS_BASIC_HANDLE_HPP
#define BOOST_ASIO_WINDOWS_BASIC_OBJECT_HANDLE_HPP
#define BOOST_ASIO_WINDOWS_BASIC_RANDOM_ACCESS_HANDLE_HPP
#define BOOST_ASIO_WINDOWS_BASIC_STREAM_HANDLE_HPP
#define BOOST_ASIO_WINDOWS_OBJECT_HANDLE_HPP
#define BOOST_ASIO_WINDOWS_OBJECT_HANDLE_SERVICE_HPP
#define BOOST_ASIO_WINDOWS_OVERLAPPED_PTR_HPP
#define BOOST_ASIO_WINDOWS_RANDOM_ACCESS_HANDLE_HPP
#define BOOST_ASIO_WINDOWS_RANDOM_ACCESS_HANDLE_SERVICE_HPP
#define BOOST_ASIO_WINDOWS_STREAM_HANDLE_HPP
#define BOOST_ASIO_WINDOWS_STREAM_HANDLE_SERVICE_HPP
#define BOOST_ASIO_WRITE_AT_HPP
namespace boost {
namespace asio {
template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
uint64_t offset, const ConstBufferSequence& buffers);
template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
uint64_t offset, const ConstBufferSequence& buffers,
boost::system::error_code& ec);
template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
typename CompletionCondition>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
uint64_t offset, const ConstBufferSequence& buffers,
CompletionCondition completion_condition);
template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
typename CompletionCondition>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
uint64_t offset, const ConstBufferSequence& buffers,
CompletionCondition completion_condition, boost::system::error_code& ec);
template <typename SyncRandomAccessWriteDevice, typename Allocator>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
uint64_t offset, basic_streambuf<Allocator>& b);
template <typename SyncRandomAccessWriteDevice, typename Allocator>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
uint64_t offset, basic_streambuf<Allocator>& b,
boost::system::error_code& ec);
template <typename SyncRandomAccessWriteDevice, typename Allocator,
typename CompletionCondition>
std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
basic_streambuf<Allocator>& b, CompletionCondition completion_condition);
template <typename SyncRandomAccessWriteDevice, typename Allocator,
typename CompletionCondition>
std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
boost::system::error_code& ec);
template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
const ConstBufferSequence& buffers,
WriteHandler&& handler);
template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
typename CompletionCondition, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_at(AsyncRandomAccessWriteDevice& d,
uint64_t offset, const ConstBufferSequence& buffers,
CompletionCondition completion_condition,
WriteHandler&& handler);
template <typename AsyncRandomAccessWriteDevice, typename Allocator,
typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
basic_streambuf<Allocator>& b, WriteHandler&& handler);
template <typename AsyncRandomAccessWriteDevice, typename Allocator,
typename CompletionCondition, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
WriteHandler&& handler);
}
}
int main(int, char**argv)
;
// this should reproduce the crash:
// /usr/lib/creduce/clang_delta --transformation=replace-function-def-with-decl --counter=239 /home/b/src/WebWhois/src/bug/clang_delta_crash_tmp_file6vMNnx.cc
#define __cplusplus 201103L
#define __GNUC__ 5
#define __GNUC_MINOR__ 0
#define __GNUC_PATCHLEVEL__ 0
#define __VERSION__ "5.0.0 20141001 (experimental) [fixups revision 12b2b6a:0acec45:61bcd046b7d40b28fc3e140b32d29f170581737d]"
#define __ATOMIC_RELAXED 0
#define __ATOMIC_SEQ_CST 5
#define __ATOMIC_ACQUIRE 2
#define __ATOMIC_RELEASE 3
#define __ATOMIC_ACQ_REL 4
#define __ATOMIC_CONSUME 1
#define __FINITE_MATH_ONLY__ 0
#define _LP64 1
#define __LP64__ 1
#define __SIZEOF_INT__ 4
#define __SIZEOF_LONG__ 8
#define __SIZEOF_LONG_LONG__ 8
#define __SIZEOF_SHORT__ 2
#define __SIZEOF_FLOAT__ 4
#define __SIZEOF_DOUBLE__ 8
#define __SIZEOF_LONG_DOUBLE__ 16
#define __SIZEOF_SIZE_T__ 8
#define __CHAR_BIT__ 8
#define __BIGGEST_ALIGNMENT__ 16
#define __ORDER_LITTLE_ENDIAN__ 1234
#define __ORDER_BIG_ENDIAN__ 4321
#define __ORDER_PDP_ENDIAN__ 3412
#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
#define __FLOAT_WORD_ORDER__ __ORDER_LITTLE_ENDIAN__
#define __SIZEOF_POINTER__ 8
#define __GNUG__ 5
#define __SIZE_TYPE__ long unsigned int
#define __PTRDIFF_TYPE__ long int
#define __WCHAR_TYPE__ int
#define __WINT_TYPE__ unsigned int
#define __INTMAX_TYPE__ long int
#define __UINTMAX_TYPE__ long unsigned int
#define __CHAR16_TYPE__ short unsigned int
#define __CHAR32_TYPE__ unsigned int
#define __SIG_ATOMIC_TYPE__ int
#define __INT8_TYPE__ signed char
#define __INT16_TYPE__ short int
#define __INT32_TYPE__ int
#define __INT64_TYPE__ long int
#define __UINT8_TYPE__ unsigned char
#define __UINT16_TYPE__ short unsigned int
#define __UINT32_TYPE__ unsigned int
#define __UINT64_TYPE__ long unsigned int
#define __INT_LEAST8_TYPE__ signed char
#define __INT_LEAST16_TYPE__ short int
#define __INT_LEAST32_TYPE__ int
#define __INT_LEAST64_TYPE__ long int
#define __UINT_LEAST8_TYPE__ unsigned char
#define __UINT_LEAST16_TYPE__ short unsigned int
#define __UINT_LEAST32_TYPE__ unsigned int
#define __UINT_LEAST64_TYPE__ long unsigned int
#define __INT_FAST8_TYPE__ signed char
#define __INT_FAST16_TYPE__ long int
#define __INT_FAST32_TYPE__ long int
#define __INT_FAST64_TYPE__ long int
#define __UINT_FAST8_TYPE__ unsigned char
#define __UINT_FAST16_TYPE__ long unsigned int
#define __UINT_FAST32_TYPE__ long unsigned int
#define __UINT_FAST64_TYPE__ long unsigned int
#define __INTPTR_TYPE__ long int
#define __UINTPTR_TYPE__ long unsigned int
#define __GXX_WEAK__ 1
#define __DEPRECATED 1
#define __GXX_RTTI 1
#define __GXX_EXPERIMENTAL_CXX0X__ 1
#define __EXCEPTIONS 1
#define __GXX_ABI_VERSION 999999
#define __SCHAR_MAX__ 0x7f
#define __SHRT_MAX__ 0x7fff
#define __INT_MAX__ 0x7fffffff
#define __LONG_MAX__ 0x7fffffffffffffffL
#define __LONG_LONG_MAX__ 0x7fffffffffffffffLL
#define __WCHAR_MAX__ 0x7fffffff
#define __WCHAR_MIN__ (-__WCHAR_MAX__ - 1)
#define __WINT_MAX__ 0xffffffffU
#define __WINT_MIN__ 0U
#define __PTRDIFF_MAX__ 0x7fffffffffffffffL
#define __SIZE_MAX__ 0xffffffffffffffffUL
#define __INTMAX_MAX__ 0x7fffffffffffffffL
#define __INTMAX_C(c) c ## L
#define __UINTMAX_MAX__ 0xffffffffffffffffUL
#define __UINTMAX_C(c) c ## UL
#define __SIG_ATOMIC_MAX__ 0x7fffffff
#define __SIG_ATOMIC_MIN__ (-__SIG_ATOMIC_MAX__ - 1)
#define __INT8_MAX__ 0x7f
#define __INT16_MAX__ 0x7fff
#define __INT32_MAX__ 0x7fffffff
#define __INT64_MAX__ 0x7fffffffffffffffL
#define __UINT8_MAX__ 0xff
#define __UINT16_MAX__ 0xffff
#define __UINT32_MAX__ 0xffffffffU
#define __UINT64_MAX__ 0xffffffffffffffffUL
#define __INT_LEAST8_MAX__ 0x7f
#define __INT8_C(c) c
#define __INT_LEAST16_MAX__ 0x7fff
#define __INT16_C(c) c
#define __INT_LEAST32_MAX__ 0x7fffffff
#define __INT32_C(c) c
#define __INT_LEAST64_MAX__ 0x7fffffffffffffffL
#define __INT64_C(c) c ## L
#define __UINT_LEAST8_MAX__ 0xff
#define __UINT8_C(c) c
#define __UINT_LEAST16_MAX__ 0xffff
#define __UINT16_C(c) c
#define __UINT_LEAST32_MAX__ 0xffffffffU
#define __UINT32_C(c) c ## U
#define __UINT_LEAST64_MAX__ 0xffffffffffffffffUL
#define __UINT64_C(c) c ## UL
#define __INT_FAST8_MAX__ 0x7f
#define __INT_FAST16_MAX__ 0x7fffffffffffffffL
#define __INT_FAST32_MAX__ 0x7fffffffffffffffL
#define __INT_FAST64_MAX__ 0x7fffffffffffffffL
#define __UINT_FAST8_MAX__ 0xff
#define __UINT_FAST16_MAX__ 0xffffffffffffffffUL
#define __UINT_FAST32_MAX__ 0xffffffffffffffffUL
#define __UINT_FAST64_MAX__ 0xffffffffffffffffUL
#define __INTPTR_MAX__ 0x7fffffffffffffffL
#define __UINTPTR_MAX__ 0xffffffffffffffffUL
#define __GCC_IEC_559 2
#define __GCC_IEC_559_COMPLEX 2
#define __FLT_EVAL_METHOD__ 0
#define __DEC_EVAL_METHOD__ 2
#define __FLT_RADIX__ 2
#define __FLT_MANT_DIG__ 24
#define __FLT_DIG__ 6
#define __FLT_MIN_EXP__ (-125)
#define __FLT_MIN_10_EXP__ (-37)
#define __FLT_MAX_EXP__ 128
#define __FLT_MAX_10_EXP__ 38
#define __FLT_DECIMAL_DIG__ 9
#define __FLT_MAX__ 3.40282346638528859812e+38F
#define __FLT_MIN__ 1.17549435082228750797e-38F
#define __FLT_EPSILON__ 1.19209289550781250000e-7F
#define __FLT_DENORM_MIN__ 1.40129846432481707092e-45F
#define __FLT_HAS_DENORM__ 1
#define __FLT_HAS_INFINITY__ 1
#define __FLT_HAS_QUIET_NAN__ 1
#define __DBL_MANT_DIG__ 53
#define __DBL_DIG__ 15
#define __DBL_MIN_EXP__ (-1021)
#define __DBL_MIN_10_EXP__ (-307)
#define __DBL_MAX_EXP__ 1024
#define __DBL_MAX_10_EXP__ 308
#define __DBL_DECIMAL_DIG__ 17
#define __DBL_MAX__ double(1.79769313486231570815e+308L)
#define __DBL_MIN__ double(2.22507385850720138309e-308L)
#define __DBL_EPSILON__ double(2.22044604925031308085e-16L)
#define __DBL_DENORM_MIN__ double(4.94065645841246544177e-324L)
#define __DBL_HAS_DENORM__ 1
#define __DBL_HAS_INFINITY__ 1
#define __DBL_HAS_QUIET_NAN__ 1
#define __LDBL_MANT_DIG__ 64
#define __LDBL_DIG__ 18
#define __LDBL_MIN_EXP__ (-16381)
#define __LDBL_MIN_10_EXP__ (-4931)
#define __LDBL_MAX_EXP__ 16384
#define __LDBL_MAX_10_EXP__ 4932
#define __DECIMAL_DIG__ 21
#define __LDBL_MAX__ 1.18973149535723176502e+4932L
#define __LDBL_MIN__ 3.36210314311209350626e-4932L
#define __LDBL_EPSILON__ 1.08420217248550443401e-19L
#define __LDBL_DENORM_MIN__ 3.64519953188247460253e-4951L
#define __LDBL_HAS_DENORM__ 1
#define __LDBL_HAS_INFINITY__ 1
#define __LDBL_HAS_QUIET_NAN__ 1
#define __DEC32_MANT_DIG__ 7
#define __DEC32_MIN_EXP__ (-94)
#define __DEC32_MAX_EXP__ 97
#define __DEC32_MIN__ 1E-95DF
#define __DEC32_MAX__ 9.999999E96DF
#define __DEC32_EPSILON__ 1E-6DF
#define __DEC32_SUBNORMAL_MIN__ 0.000001E-95DF
#define __DEC64_MANT_DIG__ 16
#define __DEC64_MIN_EXP__ (-382)
#define __DEC64_MAX_EXP__ 385
#define __DEC64_MIN__ 1E-383DD
#define __DEC64_MAX__ 9.999999999999999E384DD
#define __DEC64_EPSILON__ 1E-15DD
#define __DEC64_SUBNORMAL_MIN__ 0.000000000000001E-383DD
#define __DEC128_MANT_DIG__ 34
#define __DEC128_MIN_EXP__ (-6142)
#define __DEC128_MAX_EXP__ 6145
#define __DEC128_MIN__ 1E-6143DL
#define __DEC128_MAX__ 9.999999999999999999999999999999999E6144DL
#define __DEC128_EPSILON__ 1E-33DL
#define __DEC128_SUBNORMAL_MIN__ 0.000000000000000000000000000000001E-6143DL
#define __REGISTER_PREFIX__
#define __USER_LABEL_PREFIX__
#define __GNUC_STDC_INLINE__ 1
#define __NO_INLINE__ 1
#define __STRICT_ANSI__ 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 __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_TEST_AND_SET_TRUEVAL 1
#define __GCC_ATOMIC_POINTER_LOCK_FREE 2
#define __GCC_HAVE_DWARF2_CFI_ASM 1
#define __PRAGMA_REDEFINE_EXTNAME 1
#define __SIZEOF_INT128__ 16
#define __SIZEOF_WCHAR_T__ 4
#define __SIZEOF_WINT_T__ 4
#define __SIZEOF_PTRDIFF_T__ 8
#define __amd64 1
#define __amd64__ 1
#define __x86_64 1
#define __x86_64__ 1
#define __SIZEOF_FLOAT80__ 16
#define __SIZEOF_FLOAT128__ 16
#define __ATOMIC_HLE_ACQUIRE 65536
#define __ATOMIC_HLE_RELEASE 131072
#define __k8 1
#define __k8__ 1
#define __tune_corei7_avx__ 1
#define __tune_sandybridge__ 1
#define __code_model_small__ 1
#define __MMX__ 1
#define __SSE__ 1
#define __SSE2__ 1
#define __FXSR__ 1
#define __SSE_MATH__ 1
#define __SSE2_MATH__ 1
#define __gnu_linux__ 1
#define __linux 1
#define __linux__ 1
#define __unix 1
#define __unix__ 1
#define __ELF__ 1
#define __DECIMAL_BID_FORMAT__ 1
#define _GNU_SOURCE 1
#define NDEBUG 1
#undef DEBUG
#define _STDC_PREDEF_H 1
#define BOOST_ASIO_HPP
#define BOOST_ASIO_ASYNC_RESULT_HPP
#define BOOST_ASIO_DETAIL_CONFIG_HPP
#define BOOST_CONFIG_HPP
#define BOOST_USER_CONFIG <boost/config/user.hpp>
#define BOOST_COMPILER_CONFIG "boost/config/compiler/gcc.hpp"
#define BOOST_GCC (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
#define BOOST_HAS_PRAGMA_ONCE
#define BOOST_HAS_LONG_LONG
#define BOOST_HAS_NRVO
#define BOOST_LIKELY(x) __builtin_expect(x, 1)
#define BOOST_UNLIKELY(x) __builtin_expect(x, 0)
#define BOOST_SYMBOL_EXPORT __attribute__((__visibility__("default")))
#define BOOST_SYMBOL_IMPORT
#define BOOST_SYMBOL_VISIBLE __attribute__((__visibility__("default")))
#define BOOST_HAS_INT128
#define BOOST_HAS_DECLTYPE
#define BOOST_HAS_RVALUE_REFS
#define BOOST_HAS_STATIC_ASSERT
#define BOOST_HAS_VARIADIC_TMPL
#define BOOST_COMPILER "GNU C++ version " __VERSION__
#define _GLIBCXX_CSTDDEF 1
#define _GLIBCXX_CXX_CONFIG_H 1
#define __GLIBCXX__ 20141001
#define _GLIBCXX_PURE __attribute__ ((__pure__))
#define _GLIBCXX_CONST __attribute__ ((__const__))
#define _GLIBCXX_NORETURN __attribute__ ((__noreturn__))
#define _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY 1
#define _GLIBCXX_VISIBILITY(V) __attribute__ ((__visibility__ (#V)))
#define _GLIBCXX_USE_DEPRECATED 1
#define _GLIBCXX_DEPRECATED __attribute__ ((__deprecated__))
#define _GLIBCXX_ABI_TAG_CXX11 __attribute ((__abi_tag__ ("cxx11")))
#define _GLIBCXX_CONSTEXPR constexpr
#define _GLIBCXX_USE_CONSTEXPR constexpr
#define _GLIBCXX_NOEXCEPT noexcept
#define _GLIBCXX_USE_NOEXCEPT noexcept
#define _GLIBCXX_THROW(_EXC)
#define _GLIBCXX_NOTHROW _GLIBCXX_USE_NOEXCEPT
#define _GLIBCXX_THROW_OR_ABORT(_EXC) (throw (_EXC))
#define _GLIBCXX_EXTERN_TEMPLATE 1
namespace std
{
typedef long unsigned int size_t;
typedef long int ptrdiff_t;
typedef decltype(nullptr) nullptr_t;
}
#define _GLIBCXX_INLINE_VERSION 0
#define _GLIBCXX_BEGIN_NAMESPACE_VERSION
#define _GLIBCXX_END_NAMESPACE_VERSION
#define _GLIBCXX_STD_A std
#define _GLIBCXX_STD_C std
#define _GLIBCXX_BEGIN_NAMESPACE_ALGO
#define _GLIBCXX_END_NAMESPACE_ALGO
#define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
#define _GLIBCXX_END_NAMESPACE_CONTAINER
#undef _GLIBCXX_LONG_DOUBLE_COMPAT
#define _GLIBCXX_NAMESPACE_LDBL
#define _GLIBCXX_BEGIN_NAMESPACE_LDBL
#define _GLIBCXX_END_NAMESPACE_LDBL
#define __glibcxx_assert(_Condition)
#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_OS_DEFINES 1
#define __NO_CTYPE 1
#define _FEATURES_H 1
#undef __USE_ISOC11
#undef __USE_ISOC99
#undef __USE_ISOC95
#undef __USE_ISOCXX11
#undef __USE_POSIX
#undef __USE_POSIX2
#undef __USE_POSIX199309
#undef __USE_POSIX199506
#undef __USE_XOPEN
#undef __USE_XOPEN_EXTENDED
#undef __USE_UNIX98
#undef __USE_XOPEN2K
#undef __USE_XOPEN2KXSI
#undef __USE_XOPEN2K8
#undef __USE_XOPEN2K8XSI
#undef __USE_LARGEFILE
#undef __USE_LARGEFILE64
#undef __USE_FILE_OFFSET64
#undef __USE_BSD
#undef __USE_SVID
#undef __USE_MISC
#undef __USE_ATFILE
#undef __USE_GNU
#undef __USE_REENTRANT
#undef __USE_FORTIFY_LEVEL
#undef __KERNEL_STRICT_NAMES
#define __KERNEL_STRICT_NAMES
#define __GNUC_PREREQ(maj,min) ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
#undef _ISOC95_SOURCE
#define _ISOC95_SOURCE 1
#undef _ISOC99_SOURCE
#define _ISOC99_SOURCE 1
#undef _ISOC11_SOURCE
#define _ISOC11_SOURCE 1
#undef _POSIX_SOURCE
#define _POSIX_SOURCE 1
#undef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 200809L
#undef _XOPEN_SOURCE
#define _XOPEN_SOURCE 700
#undef _XOPEN_SOURCE_EXTENDED
#define _XOPEN_SOURCE_EXTENDED 1
#undef _LARGEFILE64_SOURCE
#define _LARGEFILE64_SOURCE 1
#undef _DEFAULT_SOURCE
#define _DEFAULT_SOURCE 1
#undef _BSD_SOURCE
#define _BSD_SOURCE 1
#undef _SVID_SOURCE
#define _SVID_SOURCE 1
#undef _ATFILE_SOURCE
#define _ATFILE_SOURCE 1
#undef _DEFAULT_SOURCE
#define _DEFAULT_SOURCE 1
#undef _BSD_SOURCE
#define _BSD_SOURCE 1
#undef _SVID_SOURCE
#define _SVID_SOURCE 1
#define __USE_ISOC11 1
#define __USE_ISOC99 1
#define __USE_ISOC95 1
#define __USE_ISOCXX11 1
#undef _POSIX_SOURCE
#define _POSIX_SOURCE 1
#undef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 200809L
#define __USE_POSIX 1
#define __USE_POSIX2 1
#define __USE_POSIX199309 1
#define __USE_POSIX199506 1
#define __USE_XOPEN2K 1
#undef __USE_ISOC95
#define __USE_ISOC95 1
#undef __USE_ISOC99
#define __USE_ISOC99 1
#define __USE_XOPEN2K8 1
#undef _ATFILE_SOURCE
#define _ATFILE_SOURCE 1
#define __USE_XOPEN 1
#define __USE_XOPEN_EXTENDED 1
#define __USE_UNIX98 1
#undef _LARGEFILE_SOURCE
#define _LARGEFILE_SOURCE 1
#define __USE_XOPEN2K8 1
#define __USE_XOPEN2K8XSI 1
#define __USE_XOPEN2K 1
#define __USE_XOPEN2KXSI 1
#undef __USE_ISOC95
#define __USE_ISOC95 1
#undef __USE_ISOC99
#define __USE_ISOC99 1
#define __USE_LARGEFILE 1
#define __USE_LARGEFILE64 1
#define __USE_MISC 1
#define __USE_BSD 1
#define __USE_SVID 1
#define __USE_ATFILE 1
#define __USE_GNU 1
#define __USE_FORTIFY_LEVEL 0
#undef __GNU_LIBRARY__
#define __GNU_LIBRARY__ 6
#define __GLIBC__ 2
#define __GLIBC_MINOR__ 19
#define __GLIBC_PREREQ(maj,min) ((__GLIBC__ << 16) + __GLIBC_MINOR__ >= ((maj) << 16) + (min))
#define _SYS_CDEFS_H 1
#undef __P
#undef __PMT
#define __LEAF , __leaf__
#define __LEAF_ATTR __attribute__ ((__leaf__))
#define __THROW throw ()
#define __THROWNL throw ()
#define __NTH(fct) __LEAF_ATTR fct throw ()
#define __P(args) args
#define __PMT(args) args
#define __CONCAT(x,y) x ## y
#define __STRING(x) #x
#define __ptr_t void *
#define __long_double_t long double
#define __BEGIN_DECLS extern "C" {
#define __END_DECLS }
#define __BEGIN_NAMESPACE_STD
#define __END_NAMESPACE_STD
#define __USING_NAMESPACE_STD(name)
#define __BEGIN_NAMESPACE_C99
#define __END_NAMESPACE_C99
#define __USING_NAMESPACE_C99(name)
#define __bos(ptr) __builtin_object_size (ptr, __USE_FORTIFY_LEVEL > 1)
#define __bos0(ptr) __builtin_object_size (ptr, 0)
#define __fortify_function __extern_always_inline __attribute_artificial__
#define __warndecl(name,msg) extern void name (void) __attribute__((__warning__ (msg)))
#define __warnattr(msg) __attribute__((__warning__ (msg)))
#define __errordecl(name,msg) extern void name (void) __attribute__((__error__ (msg)))
#define __flexarr []
#define __REDIRECT(name,proto,alias) name proto __asm__ (__ASMNAME (#alias))
#define __REDIRECT_NTH(name,proto,alias) name proto __THROW __asm__ (__ASMNAME (#alias))
#define __REDIRECT_NTHNL(name,proto,alias) name proto __THROWNL __asm__ (__ASMNAME (#alias))
#define __ASMNAME(cname) __ASMNAME2 (__USER_LABEL_PREFIX__, cname)
#define __ASMNAME2(prefix,cname) __STRING (prefix) cname
#define __attribute_malloc__ __attribute__ ((__malloc__))
#define __attribute_alloc_size__(params) __attribute__ ((__alloc_size__ params))
#define __attribute_pure__ __attribute__ ((__pure__))
#define __attribute_const__ __attribute__ ((__const__))
#define __attribute_used__ __attribute__ ((__used__))
#define __attribute_noinline__ __attribute__ ((__noinline__))
#define __attribute_deprecated__ __attribute__ ((__deprecated__))
#define __attribute_format_arg__(x) __attribute__ ((__format_arg__ (x)))
#define __attribute_format_strfmon__(a,b) __attribute__ ((__format__ (__strfmon__, a, b)))
#define __nonnull(params) __attribute__ ((__nonnull__ params))
#define __attribute_warn_unused_result__ __attribute__ ((__warn_unused_result__))
#define __wur
#define __always_inline __inline __attribute__ ((__always_inline__))
#define __attribute_artificial__ __attribute__ ((__artificial__))
#define __extern_inline extern __inline __attribute__ ((__gnu_inline__))
#define __extern_always_inline extern __always_inline __attribute__ ((__gnu_inline__))
#define __va_arg_pack() __builtin_va_arg_pack ()
#define __va_arg_pack_len() __builtin_va_arg_pack_len ()
#define __restrict_arr
#define __glibc_unlikely(cond) __builtin_expect ((cond), 0)
#define __glibc_likely(cond) __builtin_expect ((cond), 1)
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
#define __LDBL_REDIR1(name,proto,alias) name proto
#define __LDBL_REDIR(name,proto) name proto
#define __LDBL_REDIR1_NTH(name,proto,alias) name proto __THROW
#define __LDBL_REDIR_NTH(name,proto) name proto __THROW
#define __LDBL_REDIR_DECL(name)
#define __REDIRECT_LDBL(name,proto,alias) __REDIRECT (name, proto, alias)
#define __REDIRECT_NTH_LDBL(name,proto,alias) __REDIRECT_NTH (name, proto, alias)
#define __stub_bdflush
#define __stub_chflags
#define __stub_fattach
#define __stub_fchflags
#define __stub_fdetach
#define __stub_getmsg
#define __stub_gtty
#define __stub_lchmod
#define __stub_putmsg
#define __stub_revoke
#define __stub_setlogin
#define __stub_sigreturn
#define __stub_sstk
#define __stub_stty
#undef _GLIBCXX_HAVE_GETS
#define _GLIBCXX_CPU_DEFINES 1
#define _GLIBCXX_PSEUDO_VISIBILITY(V)
#define _GLIBCXX_WEAK_DEFINITION
#define _GLIBCXX_FAST_MATH 0
#define __N(msgid) (msgid)
#undef min
#undef max
#define _GLIBCXX_HAVE_ACOSF 1
#define _GLIBCXX_HAVE_ACOSL 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_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_EXECINFO_H 1
#define _GLIBCXX_HAVE_EXPF 1
#define _GLIBCXX_HAVE_EXPL 1
#define _GLIBCXX_HAVE_FABSF 1
#define _GLIBCXX_HAVE_FABSL 1
#define _GLIBCXX_HAVE_FENV_H 1
#define _GLIBCXX_HAVE_FINITE 1
#define _GLIBCXX_HAVE_FINITEF 1
#define _GLIBCXX_HAVE_FINITEL 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
#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
#define _GLIBCXX_HAVE_ISINF 1
#define _GLIBCXX_HAVE_ISINFF 1
#define _GLIBCXX_HAVE_ISINFL 1
#define _GLIBCXX_HAVE_ISNAN 1
#define _GLIBCXX_HAVE_ISNANF 1
#define _GLIBCXX_HAVE_ISNANL 1
#define _GLIBCXX_HAVE_ISWBLANK 1
#define _GLIBCXX_HAVE_LC_MESSAGES 1
#define _GLIBCXX_HAVE_LDEXPF 1
#define _GLIBCXX_HAVE_LDEXPL 1
#define _GLIBCXX_HAVE_LIBINTL_H 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
#define _GLIBCXX_HAVE_MBSTATE_T 1
#define _GLIBCXX_HAVE_MEMORY_H 1
#define _GLIBCXX_HAVE_MODF 1
#define _GLIBCXX_HAVE_MODFF 1
#define _GLIBCXX_HAVE_MODFL 1
#define _GLIBCXX_HAVE_POLL 1
#define _GLIBCXX_HAVE_POWF 1
#define _GLIBCXX_HAVE_POWL 1
#define _GLIBCXX_HAVE_QUICK_EXIT 1
#define _GLIBCXX_HAVE_SETENV 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_L 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_STRXFRM_L 1
#define _GLIBCXX_HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT 1
#define _GLIBCXX_HAVE_SYS_IOCTL_H 1
#define _GLIBCXX_HAVE_SYS_IPC_H 1
#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_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_UNISTD_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
#define _GLIBCXX_HAVE___CXA_THREAD_ATEXIT_IMPL 1
#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"
#define STDC_HEADERS 1
#define _GLIBCXX_ATOMIC_BUILTINS 1
#define _GLIBCXX_FULLY_DYNAMIC_STRING 0
#define _GLIBCXX_HAS_GTHREADS 1
#define _GLIBCXX_HOSTED 1
#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
#define _GLIBCXX_USE_C99 1
#define _GLIBCXX_USE_C99_COMPLEX 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 1
#define _GLIBCXX_USE_C99_MATH_TR1 1
#define _GLIBCXX_USE_C99_STDINT_TR1 1
#define _GLIBCXX_USE_CLOCK_MONOTONIC 1
#define _GLIBCXX_USE_CLOCK_REALTIME 1
#define _GLIBCXX_USE_DECIMAL_FLOAT 1
#define _GLIBCXX_USE_FLOAT128 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
#define _GLIBCXX_USE_NLS 1
#define _GLIBCXX_USE_RANDOM_TR1 1
#define _GLIBCXX_USE_SCHED_YIELD 1
#define _GLIBCXX_USE_SC_NPROCESSORS_ONLN 1
#define _GLIBCXX_USE_TMPNAM 1
#define _GLIBCXX_USE_WCHAR_T 1
#define _GLIBCXX_VERBOSE 1
#define _GLIBCXX_X86_RDRAND 1
#define _GTHREAD_USE_MUTEX_TIMEDLOCK 1
#define _STDDEF_H
#define _STDDEF_H_
#define _ANSI_STDDEF_H
#define _PTRDIFF_T
#define _T_PTRDIFF_
#define _T_PTRDIFF
#define __PTRDIFF_T
#define _PTRDIFF_T_
#define _BSD_PTRDIFF_T_
#define ___int_ptrdiff_t_h
#define _GCC_PTRDIFF_T
#define _PTRDIFF_T_DECLARED
typedef long int ptrdiff_t;
#undef __need_ptrdiff_t
#define __size_t__
#define __SIZE_T__
#define _SIZE_T
#define _SYS_SIZE_T_H
#define _T_SIZE_
#define _T_SIZE
#define __SIZE_T
#define _SIZE_T_
#define _BSD_SIZE_T_
#define _SIZE_T_DEFINED_
#define _SIZE_T_DEFINED
#define _BSD_SIZE_T_DEFINED_
#define _SIZE_T_DECLARED
#define ___int_size_t_h
#define _GCC_SIZE_T
#define _SIZET_
#define __size_t
typedef long unsigned int size_t;
#undef __need_size_t
#define __wchar_t__
#define __WCHAR_T__
#define _WCHAR_T
#define _T_WCHAR_
#define _T_WCHAR
#define __WCHAR_T
#define _WCHAR_T_
#define _BSD_WCHAR_T_
#define _WCHAR_T_DEFINED_
#define _WCHAR_T_DEFINED
#define _WCHAR_T_H
#define ___int_wchar_t_h
#define __INT_WCHAR_T_H
#define _GCC_WCHAR_T
#define _WCHAR_T_DECLARED
#undef _BSD_WCHAR_T_
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define _GCC_MAX_ALIGN_T
typedef struct {
long long __max_align_ll __attribute__((__aligned__(__alignof__(long long))));
long double __max_align_ld __attribute__((__aligned__(__alignof__(long double))));
} max_align_t;
#define _GXX_NULLPTR_T
typedef decltype(nullptr) nullptr_t;
namespace std
{
using ::max_align_t;
}
#define BOOST_CONFIG_UTILITY
#define BOOST_TR1_NO_RECURSION
#define BOOST_CONFIG_NO_UTILITY_RECURSION
#define _GLIBCXX_UTILITY 1
#define _STL_RELOPS_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
namespace rel_ops
{
template <class _Tp>
bool
operator!=(const _Tp& __x, const _Tp& __y)
;
template <class _Tp>
bool
operator>(const _Tp& __x, const _Tp& __y)
;
template <class _Tp>
bool
operator<=(const _Tp& __x, const _Tp& __y)
;
template <class _Tp>
bool
operator>=(const _Tp& __x, const _Tp& __y)
;
}
}
#define _STL_PAIR_H 1
#define _MOVE_H 1
#define _CONCEPT_CHECK_H 1
#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)
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp>
inline _Tp*
__addressof(_Tp& __r) noexcept
{
return reinterpret_cast<_Tp*>
(&const_cast<char&>(reinterpret_cast<const volatile char&>(__r)));
}
}
#define _GLIBCXX_TYPE_TRAITS 1
namespace std
{
typedef short unsigned int uint_least16_t;
typedef unsigned int uint_least32_t;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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 ;
};
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, 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>
{ };
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<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 { };
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 { };
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_standard_layout
: public integral_constant<bool, __is_standard_layout(_Tp)>
{ };
template<typename _Tp>
struct is_pod
: public integral_constant<bool, __is_pod(_Tp)>
{ };
template<typename _Tp>
struct is_literal_type
: public integral_constant<bool, __is_literal_type(_Tp)>
{ };
template<typename _Tp>
struct is_empty
: public integral_constant<bool, __is_empty(_Tp)>
{ };
template<typename _Tp>
struct is_polymorphic
: public integral_constant<bool, __is_polymorphic(_Tp)>
{ };
template<typename _Tp>
struct is_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>>>::type
{ };
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>>>::type
{ };
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>>::type
{ };
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>>::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
{ };
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>>::type
{ };
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 _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>> 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>
>>>::type
{ };
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>>::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>>::type
{ };
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...>>::type
{ };
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>>::type
{ };
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>
struct is_trivially_destructible
: public __and_<is_destructible<_Tp>, integral_constant<bool,
__has_trivial_destructor(_Tp)>>::type
{ };
template<typename _Tp>
struct has_trivial_default_constructor
: public integral_constant<bool, __has_trivial_constructor(_Tp)>
{ };
template<typename _Tp>
struct has_trivial_copy_constructor
: public integral_constant<bool, __has_trivial_copy(_Tp)>
{ };
template<typename _Tp>
struct has_trivial_copy_assign
: public integral_constant<bool, __has_trivial_assign(_Tp)>
{ };
template<typename _Tp>
struct has_virtual_destructor
: public integral_constant<bool, __has_virtual_destructor(_Tp)>
{ };
template<typename _Tp>
struct alignment_of
: public integral_constant<std::size_t, __alignof__(_Tp)> { };
template<typename>
struct rank
: public integral_constant<std::size_t, 0> { };
template<typename _Tp, std::size_t _Size>
struct rank<_Tp[_Size]>
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
template<typename _Tp>
struct rank<_Tp[]>
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
template<typename, unsigned _Uint>
struct extent
: public integral_constant<std::size_t, 0> { };
template<typename _Tp, unsigned _Uint, std::size_t _Size>
struct extent<_Tp[_Size], _Uint>
: public integral_constant<std::size_t,
_Uint == 0 ? _Size : extent<_Tp,
_Uint - 1>::value>
{ };
template<typename _Tp, unsigned _Uint>
struct extent<_Tp[], _Uint>
: public integral_constant<std::size_t,
_Uint == 0 ? 0 : extent<_Tp,
_Uint - 1>::value>
{ };
template<typename, typename>
struct is_same
: public false_type { };
template<typename _Tp>
struct is_same<_Tp, _Tp>
: public true_type { };
template<typename _Base, typename _Derived>
struct is_base_of
: public integral_constant<bool, __is_base_of(_Base, _Derived)>
{ };
template<typename _From, typename _To,
bool = __or_<is_void<_From>, is_function<_To>,
is_array<_To>>::value>
struct __is_convertible_helper
{ typedef typename is_void<_To>::type type; };
template<typename _From, typename _To>
class __is_convertible_helper<_From, _To, false>
{
template<typename _To1>
static void __test_aux(_To1);
template<typename _From1, typename _To1,
typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
static true_type
__test(int);
template<typename, typename>
static false_type
__test(...);
public:
typedef decltype(__test<_From, _To>(0)) type;
};
template<typename _From, typename _To>
struct is_convertible
: public __is_convertible_helper<_From, _To>::type
{ };
template<typename _Tp>
struct remove_const
{ typedef _Tp type; };
template<typename _Tp>
struct remove_const<_Tp const>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_volatile
{ typedef _Tp type; };
template<typename _Tp>
struct remove_volatile<_Tp volatile>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_cv
{
typedef typename
remove_const<typename remove_volatile<_Tp>::type>::type type;
};
template<typename _Tp>
struct add_const
{ typedef _Tp const type; };
template<typename _Tp>
struct add_volatile
{ typedef _Tp volatile type; };
template<typename _Tp>
struct add_cv
{
typedef typename
add_const<typename add_volatile<_Tp>::type>::type type;
};
template<typename _Tp>
struct remove_reference
{ typedef _Tp type; };
template<typename _Tp>
struct remove_reference<_Tp&>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_reference<_Tp&&>
{ typedef _Tp type; };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __add_lvalue_reference_helper
{ typedef _Tp type; };
template<typename _Tp>
struct __add_lvalue_reference_helper<_Tp, true>
{ typedef _Tp& type; };
template<typename _Tp>
struct add_lvalue_reference
: public __add_lvalue_reference_helper<_Tp>
{ };
template<typename _Tp, bool = __is_referenceable<_Tp>::value>
struct __add_rvalue_reference_helper
{ typedef _Tp type; };
template<typename _Tp>
struct __add_rvalue_reference_helper<_Tp, true>
{ typedef _Tp&& type; };
template<typename _Tp>
struct add_rvalue_reference
: public __add_rvalue_reference_helper<_Tp>
{ };
template<typename _Unqualified, bool _IsConst, bool _IsVol>
struct __cv_selector;
template<typename _Unqualified>
struct __cv_selector<_Unqualified, false, false>
{ typedef _Unqualified __type; };
template<typename _Unqualified>
struct __cv_selector<_Unqualified, false, true>
{ typedef volatile _Unqualified __type; };
template<typename _Unqualified>
struct __cv_selector<_Unqualified, true, false>
{ typedef const _Unqualified __type; };
template<typename _Unqualified>
struct __cv_selector<_Unqualified, true, true>
{ typedef const volatile _Unqualified __type; };
template<typename _Qualified, typename _Unqualified,
bool _IsConst = is_const<_Qualified>::value,
bool _IsVol = is_volatile<_Qualified>::value>
class __match_cv_qualifiers
{
typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
public:
typedef typename __match::__type __type;
};
template<typename _Tp>
struct __make_unsigned
{ typedef _Tp __type; };
template<>
struct __make_unsigned<char>
{ typedef unsigned char __type; };
template<>
struct __make_unsigned<signed char>
{ typedef unsigned char __type; };
template<>
struct __make_unsigned<short>
{ typedef unsigned short __type; };
template<>
struct __make_unsigned<int>
{ typedef unsigned int __type; };
template<>
struct __make_unsigned<long>
{ typedef unsigned long __type; };
template<>
struct __make_unsigned<long long>
{ typedef unsigned long long __type; };
template<>
struct __make_unsigned<wchar_t> : __make_unsigned<int>
{ };
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);
typedef conditional<__b2, unsigned int, unsigned long> __cond2;
typedef typename __cond2::type __cond2_type;
typedef conditional<__b1, unsigned short, __cond2_type> __cond1;
typedef typename __cond1::type __cond1_type;
public:
typedef typename conditional<__b0, __smallest, __cond1_type>::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<char16_t> : __make_signed<uint_least16_t>
{ };
template<>
struct __make_signed<char32_t> : __make_signed<uint_least32_t>
{ };
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 signed char __smallest;
static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
static const bool __b1 = sizeof(_Tp) <= sizeof(signed short);
static const bool __b2 = sizeof(_Tp) <= sizeof(signed int);
typedef conditional<__b2, signed int, signed long> __cond2;
typedef typename __cond2::type __cond2_type;
typedef conditional<__b1, signed short, __cond2_type> __cond1;
typedef typename __cond1::type __cond1_type;
public:
typedef typename conditional<__b0, __smallest, __cond1_type>::type __type;
};
template<typename _Tp>
struct make_signed
{ typedef typename __make_signed_selector<_Tp>::__type type; };
template<>
struct make_signed<bool>;
template<typename _Tp>
struct remove_extent
{ typedef _Tp type; };
template<typename _Tp, std::size_t _Size>
struct remove_extent<_Tp[_Size]>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_extent<_Tp[]>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_all_extents
{ typedef _Tp type; };
template<typename _Tp, std::size_t _Size>
struct remove_all_extents<_Tp[_Size]>
{ typedef typename remove_all_extents<_Tp>::type type; };
template<typename _Tp>
struct remove_all_extents<_Tp[]>
{ typedef typename remove_all_extents<_Tp>::type type; };
template<typename _Tp, typename>
struct __remove_pointer_helper
{ typedef _Tp type; };
template<typename _Tp, typename _Up>
struct __remove_pointer_helper<_Tp, _Up*>
{ typedef _Up type; };
template<typename _Tp>
struct remove_pointer
: public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type>
{ };
template<typename _Tp, bool = __or_<__is_referenceable<_Tp>,
is_void<_Tp>>::value>
struct __add_pointer_helper
{ typedef _Tp type; };
template<typename _Tp>
struct __add_pointer_helper<_Tp, true>
{ typedef typename remove_reference<_Tp>::type* type; };
template<typename _Tp>
struct add_pointer
: public __add_pointer_helper<_Tp>
{ };
template<std::size_t _Len>
struct __aligned_storage_msa
{
union __type
{
unsigned char __data[_Len];
struct __attribute__((__aligned__)) { } __align;
};
};
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;
};
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;
struct __result_of_memfun_ref_impl
{
template<typename _Fp, typename _Tp1, typename... _Args>
static __success_type<decltype(
(std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
)> _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 __success_type<decltype(
((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
)> _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 __success_type<decltype(
std::declval<_Tp1>().*std::declval<_Fp>()
)> _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 __success_type<decltype(
(*std::declval<_Tp1>()).*std::declval<_Fp>()
)> _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<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, _Arg>
{ };
template<typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
: public __result_of_memfun<typename decay<_MemPtr>::type, _Arg, _Args...>
{ };
struct __result_of_other_impl
{
template<typename _Fn, typename... _Args>
static __success_type<decltype(
std::declval<_Fn>()(std::declval<_Args>()...)
)> _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 result_of<_Functor(_ArgTypes...)>
: 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
{ };
#define _GLIBCXX_HAS_NESTED_TYPE(_NTYPE) template<typename _Tp> class __has_ ##_NTYPE ##_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::_NTYPE>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_ ##_NTYPE : public __has_ ##_NTYPE ##_helper <typename remove_cv<_Tp>::type>::type { };
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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 { };
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); }
template<typename _Tp>
inline _Tp*
addressof(_Tp& __r) noexcept
{ return std::__addressof(__r); }
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")))
{
template<typename _Tp>
inline void
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 void
swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
noexcept(noexcept(swap(*__a, *__b)))
{
for (size_t __n = 0; __n < _Nm; ++__n)
swap(__a[__n], __b[__n]);
}
}
namespace std __attribute__ ((__visibility__ ("default")))
{
struct piecewise_construct_t { };
constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
template<typename...>
class tuple;
template<std::size_t...>
struct _Index_tuple;
template<class _T1, class _T2>
struct pair
{
typedef _T1 first_type;
typedef _T2 second_type;
_T1 first;
_T2 second;
constexpr pair()
: first(), second() { }
constexpr pair(const _T1& __a, const _T2& __b)
: first(__a), second(__b) { }
template<class _U1, class _U2, class = typename
enable_if<__and_<is_convertible<const _U1&, _T1>,
is_convertible<const _U2&, _T2>>::value>::type>
constexpr pair(const pair<_U1, _U2>& __p)
: first(__p.first), second(__p.second) { }
constexpr pair(const pair&) = default;
constexpr pair(pair&&) = default;
template<class _U1, class = typename
enable_if<is_convertible<_U1, _T1>::value>::type>
constexpr pair(_U1&& __x, const _T2& __y)
: first(std::forward<_U1>(__x)), second(__y) { }
template<class _U2, class = typename
enable_if<is_convertible<_U2, _T2>::value>::type>
constexpr pair(const _T1& __x, _U2&& __y)
: first(__x), second(std::forward<_U2>(__y)) { }
template<class _U1, class _U2, class = typename
enable_if<__and_<is_convertible<_U1, _T1>,
is_convertible<_U2, _T2>>::value>::type>
constexpr pair(_U1&& __x, _U2&& __y)
: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
template<class _U1, class _U2, class = typename
enable_if<__and_<is_convertible<_U1, _T1>,
is_convertible<_U2, _T2>>::value>::type>
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=(const pair& __p)
;
pair&
operator=(pair&& __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<class _U1, class _U2>
pair&
operator=(const pair<_U1, _U2>& __p)
{
first = __p.first;
second = __p.second;
return *this;
}
template<class _U1, class _U2>
pair&
operator=(pair<_U1, _U2>&& __p)
{
first = std::forward<_U1>(__p.first);
second = std::forward<_U2>(__p.second);
return *this;
}
void
swap(pair& __p)
noexcept(noexcept(swap(first, __p.first))
&& noexcept(swap(second, __p.second)))
{
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<class _T1, class _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<class _T1, class _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<class _T1, class _T2>
inline constexpr bool
operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x == __y); }
template<class _T1, class _T2>
inline constexpr bool
operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return __y < __x; }
template<class _T1, class _T2>
inline constexpr bool
operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__y < __x); }
template<class _T1, class _T2>
inline constexpr bool
operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{ return !(__x < __y); }
template<class _T1, class _T2>
inline void
swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
template<class _T1, class _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));
}
}
#define _INITIALIZER_LIST
#pragma GCC visibility push(default)
namespace std
{
template<class _E>
class initializer_list
{
public:
typedef _E value_type;
typedef const _E& reference;
typedef const _E& const_reference;
typedef size_t size_type;
typedef const _E* iterator;
typedef const _E* const_iterator;
private:
iterator _M_array;
size_type _M_len;
constexpr initializer_list(const_iterator __a, size_type __l)
: _M_array(__a), _M_len(__l) { }
public:
constexpr initializer_list() noexcept
: _M_array(0), _M_len(0) { }
constexpr size_type
size() const noexcept { return _M_len; }
constexpr const_iterator
begin() const noexcept { return _M_array; }
constexpr const_iterator
end() const noexcept { return begin() + size(); }
};
template<class _Tp>
constexpr const _Tp*
begin(initializer_list<_Tp> __ils) noexcept
{ return __ils.begin(); }
template<class _Tp>
constexpr const _Tp*
end(initializer_list<_Tp> __ils) noexcept
{ return __ils.end(); }
}
#pragma GCC visibility pop
namespace std __attribute__ ((__visibility__ ("default")))
{
template<class _Tp>
class tuple_size;
template<std::size_t _Int, class _Tp>
class tuple_element;
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); }
template<size_t... _Indexes>
struct _Index_tuple
{
typedef _Index_tuple<_Indexes..., sizeof...(_Indexes)> __next;
};
template<size_t _Num>
struct _Build_index_tuple
{
typedef typename _Build_index_tuple<_Num - 1>::__type::__next __type;
};
template<>
struct _Build_index_tuple<0>
{
typedef _Index_tuple<> __type;
};
}
#undef BOOST_TR1_NO_RECURSION
#undef BOOST_CONFIG_NO_UTILITY_RECURSION
#define BOOST_STDLIB_CONFIG "boost/config/stdlib/libstdcpp3.hpp"
#define BOOST_GNU_STDLIB 1
#define BOOST_STDLIB "GNU libstdc++ version " BOOST_STRINGIZE(__GLIBCXX__)
#define BOOST_HAS_THREADS
#define _UNISTD_H 1
extern "C" {
#define _POSIX_VERSION 200809L
#define __POSIX2_THIS_VERSION 200809L
#define _POSIX2_VERSION __POSIX2_THIS_VERSION
#define _POSIX2_C_BIND __POSIX2_THIS_VERSION
#define _POSIX2_C_DEV __POSIX2_THIS_VERSION
#define _POSIX2_SW_DEV __POSIX2_THIS_VERSION
#define _POSIX2_LOCALEDEF __POSIX2_THIS_VERSION
#define _XOPEN_VERSION 700
#define _XOPEN_XCU_VERSION 4
#define _XOPEN_XPG2 1
#define _XOPEN_XPG3 1
#define _XOPEN_XPG4 1
#define _XOPEN_UNIX 1
#define _XOPEN_CRYPT 1
#define _XOPEN_ENH_I18N 1
#define _XOPEN_LEGACY 1
#define _BITS_POSIX_OPT_H 1
#define _POSIX_JOB_CONTROL 1
#define _POSIX_SAVED_IDS 1
#define _POSIX_PRIORITY_SCHEDULING 200809L
#define _POSIX_SYNCHRONIZED_IO 200809L
#define _POSIX_FSYNC 200809L
#define _POSIX_MAPPED_FILES 200809L
#define _POSIX_MEMLOCK 200809L
#define _POSIX_MEMLOCK_RANGE 200809L
#define _POSIX_MEMORY_PROTECTION 200809L
#define _POSIX_CHOWN_RESTRICTED 0
#define _POSIX_VDISABLE '\0'
#define _POSIX_NO_TRUNC 1
#define _XOPEN_REALTIME 1
#define _XOPEN_REALTIME_THREADS 1
#define _XOPEN_SHM 1
#define _POSIX_THREADS 200809L
#define _POSIX_REENTRANT_FUNCTIONS 1
#define _POSIX_THREAD_SAFE_FUNCTIONS 200809L
#define _POSIX_THREAD_PRIORITY_SCHEDULING 200809L
#define _POSIX_THREAD_ATTR_STACKSIZE 200809L
#define _POSIX_THREAD_ATTR_STACKADDR 200809L
#define _POSIX_THREAD_PRIO_INHERIT 200809L
#define _POSIX_THREAD_PRIO_PROTECT 200809L
#define _POSIX_THREAD_ROBUST_PRIO_INHERIT 200809L
#define _POSIX_THREAD_ROBUST_PRIO_PROTECT -1
#define _POSIX_SEMAPHORES 200809L
#define _POSIX_REALTIME_SIGNALS 200809L
#define _POSIX_ASYNCHRONOUS_IO 200809L
#define _POSIX_ASYNC_IO 1
#define _LFS_ASYNCHRONOUS_IO 1
#define _POSIX_PRIORITIZED_IO 200809L
#define _LFS64_ASYNCHRONOUS_IO 1
#define _LFS_LARGEFILE 1
#define _LFS64_LARGEFILE 1
#define _LFS64_STDIO 1
#define _POSIX_SHARED_MEMORY_OBJECTS 200809L
#define _POSIX_CPUTIME 0
#define _POSIX_THREAD_CPUTIME 0
#define _POSIX_REGEXP 1
#define _POSIX_READER_WRITER_LOCKS 200809L
#define _POSIX_SHELL 1
#define _POSIX_TIMEOUTS 200809L
#define _POSIX_SPIN_LOCKS 200809L
#define _POSIX_SPAWN 200809L
#define _POSIX_TIMERS 200809L
#define _POSIX_BARRIERS 200809L
#define _POSIX_MESSAGE_PASSING 200809L
#define _POSIX_THREAD_PROCESS_SHARED 200809L
#define _POSIX_MONOTONIC_CLOCK 0
#define _POSIX_CLOCK_SELECTION 200809L
#define _POSIX_ADVISORY_INFO 200809L
#define _POSIX_IPV6 200809L
#define _POSIX_RAW_SOCKETS 200809L
#define _POSIX2_CHAR_TERM 200809L
#define _POSIX_SPORADIC_SERVER -1
#define _POSIX_THREAD_SPORADIC_SERVER -1
#define _POSIX_TRACE -1
#define _POSIX_TRACE_EVENT_FILTER -1
#define _POSIX_TRACE_INHERIT -1
#define _POSIX_TRACE_LOG -1
#define _POSIX_TYPED_MEMORY_OBJECTS -1
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
#define _POSIX_V7_LPBIG_OFFBIG -1
#define _POSIX_V6_LPBIG_OFFBIG -1
#define _XBS5_LPBIG_OFFBIG -1
#define _POSIX_V7_LP64_OFF64 1
#define _POSIX_V6_LP64_OFF64 1
#define _XBS5_LP64_OFF64 1
#define __ILP32_OFF32_CFLAGS "-m32"
#define __ILP32_OFF32_LDFLAGS "-m32"
#define __ILP32_OFFBIG_CFLAGS "-m32 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64"
#define __ILP32_OFFBIG_LDFLAGS "-m32"
#define __LP64_OFF64_CFLAGS "-m64"
#define __LP64_OFF64_LDFLAGS "-m64"
#define STDIN_FILENO 0
#define STDOUT_FILENO 1
#define STDERR_FILENO 2
#define _BITS_TYPES_H 1
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;
typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;
typedef signed long int __int64_t;
typedef unsigned long int __uint64_t;
typedef long int __quad_t;
typedef unsigned long int __u_quad_t;
#define __S16_TYPE short int
#define __U16_TYPE unsigned short int
#define __S32_TYPE int
#define __U32_TYPE unsigned int
#define __SLONGWORD_TYPE long int
#define __ULONGWORD_TYPE unsigned long int
#define __SQUAD_TYPE long int
#define __UQUAD_TYPE unsigned long int
#define __SWORD_TYPE long int
#define __UWORD_TYPE unsigned long int
#define __SLONG32_TYPE int
#define __ULONG32_TYPE unsigned int
#define __S64_TYPE long int
#define __U64_TYPE unsigned long int
#define __STD_TYPE typedef
#define _BITS_TYPESIZES_H 1
#define __SYSCALL_SLONG_TYPE __SLONGWORD_TYPE
#define __SYSCALL_ULONG_TYPE __ULONGWORD_TYPE
#define __DEV_T_TYPE __UQUAD_TYPE
#define __UID_T_TYPE __U32_TYPE
#define __GID_T_TYPE __U32_TYPE
#define __INO_T_TYPE __SYSCALL_ULONG_TYPE
#define __INO64_T_TYPE __UQUAD_TYPE
#define __MODE_T_TYPE __U32_TYPE
#define __NLINK_T_TYPE __SYSCALL_ULONG_TYPE
#define __FSWORD_T_TYPE __SYSCALL_SLONG_TYPE
#define __OFF_T_TYPE __SYSCALL_SLONG_TYPE
#define __OFF64_T_TYPE __SQUAD_TYPE
#define __PID_T_TYPE __S32_TYPE
#define __RLIM_T_TYPE __SYSCALL_ULONG_TYPE
#define __RLIM64_T_TYPE __UQUAD_TYPE
#define __BLKCNT_T_TYPE __SYSCALL_SLONG_TYPE
#define __BLKCNT64_T_TYPE __SQUAD_TYPE
#define __FSBLKCNT_T_TYPE __SYSCALL_ULONG_TYPE
#define __FSBLKCNT64_T_TYPE __UQUAD_TYPE
#define __FSFILCNT_T_TYPE __SYSCALL_ULONG_TYPE
#define __FSFILCNT64_T_TYPE __UQUAD_TYPE
#define __ID_T_TYPE __U32_TYPE
#define __CLOCK_T_TYPE __SYSCALL_SLONG_TYPE
#define __TIME_T_TYPE __SYSCALL_SLONG_TYPE
#define __USECONDS_T_TYPE __U32_TYPE
#define __SUSECONDS_T_TYPE __SYSCALL_SLONG_TYPE
#define __DADDR_T_TYPE __S32_TYPE
#define __KEY_T_TYPE __S32_TYPE
#define __CLOCKID_T_TYPE __S32_TYPE
#define __TIMER_T_TYPE void *
#define __BLKSIZE_T_TYPE __SYSCALL_SLONG_TYPE
#define __FSID_T_TYPE struct { int __val[2]; }
#define __SSIZE_T_TYPE __SWORD_TYPE
#define __OFF_T_MATCHES_OFF64_T 1
#define __INO_T_MATCHES_INO64_T 1
#define __FD_SETSIZE 1024
typedef unsigned long int __dev_t;
typedef unsigned int __uid_t;
typedef unsigned int __gid_t;
typedef unsigned long int __ino_t;
typedef unsigned long int __ino64_t;
typedef unsigned int __mode_t;
typedef unsigned long int __nlink_t;
typedef long int __off_t;
typedef long int __off64_t;
typedef int __pid_t;
typedef struct { int __val[2]; } __fsid_t;
typedef long int __clock_t;
typedef unsigned long int __rlim_t;
typedef unsigned long int __rlim64_t;
typedef unsigned int __id_t;
typedef long int __time_t;
typedef unsigned int __useconds_t;
typedef long int __suseconds_t;
typedef int __daddr_t;
typedef int __key_t;
typedef int __clockid_t;
typedef void * __timer_t;
typedef long int __blksize_t;
typedef long int __blkcnt_t;
typedef long int __blkcnt64_t;
typedef unsigned long int __fsblkcnt_t;
typedef unsigned long int __fsblkcnt64_t;
typedef unsigned long int __fsfilcnt_t;
typedef unsigned long int __fsfilcnt64_t;
typedef long int __fsword_t;
typedef long int __ssize_t;
typedef long int __syscall_slong_t;
typedef unsigned long int __syscall_ulong_t;
typedef __off64_t __loff_t;
typedef __quad_t *__qaddr_t;
typedef char *__caddr_t;
typedef long int __intptr_t;
typedef unsigned int __socklen_t;
#undef __STD_TYPE
typedef __ssize_t ssize_t;
#define __ssize_t_defined
#define __need_size_t
#define __need_NULL
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
typedef __gid_t gid_t;
#define __gid_t_defined
typedef __uid_t uid_t;
#define __uid_t_defined
typedef __off_t off_t;
#define __off_t_defined
typedef __off64_t off64_t;
#define __off64_t_defined
typedef __useconds_t useconds_t;
#define __useconds_t_defined
typedef __pid_t pid_t;
#define __pid_t_defined
typedef __intptr_t intptr_t;
#define __intptr_t_defined
typedef __socklen_t socklen_t;
#define __socklen_t_defined
#define R_OK 4
#define W_OK 2
#define X_OK 1
#define F_OK 0
extern int access (const char *__name, int __type) throw () __attribute__ ((__nonnull__ (1)));
extern int euidaccess (const char *__name, int __type)
throw () __attribute__ ((__nonnull__ (1)));
extern int eaccess (const char *__name, int __type)
throw () __attribute__ ((__nonnull__ (1)));
extern int faccessat (int __fd, const char *__file, int __type, int __flag)
throw () __attribute__ ((__nonnull__ (2))) ;
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2
#define SEEK_DATA 3
#define SEEK_HOLE 4
#define L_SET SEEK_SET
#define L_INCR SEEK_CUR
#define L_XTND SEEK_END
extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
throw ();
extern int close (int __fd);
extern ssize_t read (int __fd, void *__buf, size_t __nbytes) ;
extern ssize_t write (int __fd, const void *__buf, size_t __n) ;
extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
__off_t __offset) ;
extern ssize_t pwrite (int __fd, const void *__buf, size_t __n,
__off_t __offset) ;
extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
__off64_t __offset) ;
extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n,
__off64_t __offset) ;
extern int pipe (int __pipedes[2]) throw () ;
extern int pipe2 (int __pipedes[2], int __flags) throw () ;
extern unsigned int alarm (unsigned int __seconds) throw ();
extern unsigned int sleep (unsigned int __seconds);
extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
throw ();
extern int usleep (__useconds_t __useconds);
extern int pause (void);
extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int fchown (int __fd, __uid_t __owner, __gid_t __group) throw () ;
extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int fchownat (int __fd, const char *__file, __uid_t __owner,
__gid_t __group, int __flag)
throw () __attribute__ ((__nonnull__ (2))) ;
extern int chdir (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;
extern int fchdir (int __fd) throw () ;
extern char *getcwd (char *__buf, size_t __size) throw () ;
extern char *get_current_dir_name (void) throw ();
extern char *getwd (char *__buf)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) ;
extern int dup (int __fd) throw () ;
extern int dup2 (int __fd, int __fd2) throw ();
extern int dup3 (int __fd, int __fd2, int __flags) throw ();
extern char **__environ;
extern char **environ;
extern int execve (const char *__path, char *const __argv[],
char *const __envp[]) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
throw () __attribute__ ((__nonnull__ (2)));
extern int execv (const char *__path, char *const __argv[])
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execle (const char *__path, const char *__arg, ...)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execl (const char *__path, const char *__arg, ...)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execvp (const char *__file, char *const __argv[])
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execlp (const char *__file, const char *__arg, ...)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int execvpe (const char *__file, char *const __argv[],
char *const __envp[])
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int nice (int __inc) throw () ;
extern void _exit (int __status) __attribute__ ((__noreturn__));
enum
{
_PC_LINK_MAX,
#define _PC_LINK_MAX _PC_LINK_MAX
_PC_MAX_CANON,
#define _PC_MAX_CANON _PC_MAX_CANON
_PC_MAX_INPUT,
#define _PC_MAX_INPUT _PC_MAX_INPUT
_PC_NAME_MAX,
#define _PC_NAME_MAX _PC_NAME_MAX
_PC_PATH_MAX,
#define _PC_PATH_MAX _PC_PATH_MAX
_PC_PIPE_BUF,
#define _PC_PIPE_BUF _PC_PIPE_BUF
_PC_CHOWN_RESTRICTED,
#define _PC_CHOWN_RESTRICTED _PC_CHOWN_RESTRICTED
_PC_NO_TRUNC,
#define _PC_NO_TRUNC _PC_NO_TRUNC
_PC_VDISABLE,
#define _PC_VDISABLE _PC_VDISABLE
_PC_SYNC_IO,
#define _PC_SYNC_IO _PC_SYNC_IO
_PC_ASYNC_IO,
#define _PC_ASYNC_IO _PC_ASYNC_IO
_PC_PRIO_IO,
#define _PC_PRIO_IO _PC_PRIO_IO
_PC_SOCK_MAXBUF,
#define _PC_SOCK_MAXBUF _PC_SOCK_MAXBUF
_PC_FILESIZEBITS,
#define _PC_FILESIZEBITS _PC_FILESIZEBITS
_PC_REC_INCR_XFER_SIZE,
#define _PC_REC_INCR_XFER_SIZE _PC_REC_INCR_XFER_SIZE
_PC_REC_MAX_XFER_SIZE,
#define _PC_REC_MAX_XFER_SIZE _PC_REC_MAX_XFER_SIZE
_PC_REC_MIN_XFER_SIZE,
#define _PC_REC_MIN_XFER_SIZE _PC_REC_MIN_XFER_SIZE
_PC_REC_XFER_ALIGN,
#define _PC_REC_XFER_ALIGN _PC_REC_XFER_ALIGN
_PC_ALLOC_SIZE_MIN,
#define _PC_ALLOC_SIZE_MIN _PC_ALLOC_SIZE_MIN
_PC_SYMLINK_MAX,
#define _PC_SYMLINK_MAX _PC_SYMLINK_MAX
_PC_2_SYMLINKS
#define _PC_2_SYMLINKS _PC_2_SYMLINKS
};
enum
{
_SC_ARG_MAX,
#define _SC_ARG_MAX _SC_ARG_MAX
_SC_CHILD_MAX,
#define _SC_CHILD_MAX _SC_CHILD_MAX
_SC_CLK_TCK,
#define _SC_CLK_TCK _SC_CLK_TCK
_SC_NGROUPS_MAX,
#define _SC_NGROUPS_MAX _SC_NGROUPS_MAX
_SC_OPEN_MAX,
#define _SC_OPEN_MAX _SC_OPEN_MAX
_SC_STREAM_MAX,
#define _SC_STREAM_MAX _SC_STREAM_MAX
_SC_TZNAME_MAX,
#define _SC_TZNAME_MAX _SC_TZNAME_MAX
_SC_JOB_CONTROL,
#define _SC_JOB_CONTROL _SC_JOB_CONTROL
_SC_SAVED_IDS,
#define _SC_SAVED_IDS _SC_SAVED_IDS
_SC_REALTIME_SIGNALS,
#define _SC_REALTIME_SIGNALS _SC_REALTIME_SIGNALS
_SC_PRIORITY_SCHEDULING,
#define _SC_PRIORITY_SCHEDULING _SC_PRIORITY_SCHEDULING
_SC_TIMERS,
#define _SC_TIMERS _SC_TIMERS
_SC_ASYNCHRONOUS_IO,
#define _SC_ASYNCHRONOUS_IO _SC_ASYNCHRONOUS_IO
_SC_PRIORITIZED_IO,
#define _SC_PRIORITIZED_IO _SC_PRIORITIZED_IO
_SC_SYNCHRONIZED_IO,
#define _SC_SYNCHRONIZED_IO _SC_SYNCHRONIZED_IO
_SC_FSYNC,
#define _SC_FSYNC _SC_FSYNC
_SC_MAPPED_FILES,
#define _SC_MAPPED_FILES _SC_MAPPED_FILES
_SC_MEMLOCK,
#define _SC_MEMLOCK _SC_MEMLOCK
_SC_MEMLOCK_RANGE,
#define _SC_MEMLOCK_RANGE _SC_MEMLOCK_RANGE
_SC_MEMORY_PROTECTION,
#define _SC_MEMORY_PROTECTION _SC_MEMORY_PROTECTION
_SC_MESSAGE_PASSING,
#define _SC_MESSAGE_PASSING _SC_MESSAGE_PASSING
_SC_SEMAPHORES,
#define _SC_SEMAPHORES _SC_SEMAPHORES
_SC_SHARED_MEMORY_OBJECTS,
#define _SC_SHARED_MEMORY_OBJECTS _SC_SHARED_MEMORY_OBJECTS
_SC_AIO_LISTIO_MAX,
#define _SC_AIO_LISTIO_MAX _SC_AIO_LISTIO_MAX
_SC_AIO_MAX,
#define _SC_AIO_MAX _SC_AIO_MAX
_SC_AIO_PRIO_DELTA_MAX,
#define _SC_AIO_PRIO_DELTA_MAX _SC_AIO_PRIO_DELTA_MAX
_SC_DELAYTIMER_MAX,
#define _SC_DELAYTIMER_MAX _SC_DELAYTIMER_MAX
_SC_MQ_OPEN_MAX,
#define _SC_MQ_OPEN_MAX _SC_MQ_OPEN_MAX
_SC_MQ_PRIO_MAX,
#define _SC_MQ_PRIO_MAX _SC_MQ_PRIO_MAX
_SC_VERSION,
#define _SC_VERSION _SC_VERSION
_SC_PAGESIZE,
#define _SC_PAGESIZE _SC_PAGESIZE
#define _SC_PAGE_SIZE _SC_PAGESIZE
_SC_RTSIG_MAX,
#define _SC_RTSIG_MAX _SC_RTSIG_MAX
_SC_SEM_NSEMS_MAX,
#define _SC_SEM_NSEMS_MAX _SC_SEM_NSEMS_MAX
_SC_SEM_VALUE_MAX,
#define _SC_SEM_VALUE_MAX _SC_SEM_VALUE_MAX
_SC_SIGQUEUE_MAX,
#define _SC_SIGQUEUE_MAX _SC_SIGQUEUE_MAX
_SC_TIMER_MAX,
#define _SC_TIMER_MAX _SC_TIMER_MAX
_SC_BC_BASE_MAX,
#define _SC_BC_BASE_MAX _SC_BC_BASE_MAX
_SC_BC_DIM_MAX,
#define _SC_BC_DIM_MAX _SC_BC_DIM_MAX
_SC_BC_SCALE_MAX,
#define _SC_BC_SCALE_MAX _SC_BC_SCALE_MAX
_SC_BC_STRING_MAX,
#define _SC_BC_STRING_MAX _SC_BC_STRING_MAX
_SC_COLL_WEIGHTS_MAX,
#define _SC_COLL_WEIGHTS_MAX _SC_COLL_WEIGHTS_MAX
_SC_EQUIV_CLASS_MAX,
#define _SC_EQUIV_CLASS_MAX _SC_EQUIV_CLASS_MAX
_SC_EXPR_NEST_MAX,
#define _SC_EXPR_NEST_MAX _SC_EXPR_NEST_MAX
_SC_LINE_MAX,
#define _SC_LINE_MAX _SC_LINE_MAX
_SC_RE_DUP_MAX,
#define _SC_RE_DUP_MAX _SC_RE_DUP_MAX
_SC_CHARCLASS_NAME_MAX,
#define _SC_CHARCLASS_NAME_MAX _SC_CHARCLASS_NAME_MAX
_SC_2_VERSION,
#define _SC_2_VERSION _SC_2_VERSION
_SC_2_C_BIND,
#define _SC_2_C_BIND _SC_2_C_BIND
_SC_2_C_DEV,
#define _SC_2_C_DEV _SC_2_C_DEV
_SC_2_FORT_DEV,
#define _SC_2_FORT_DEV _SC_2_FORT_DEV
_SC_2_FORT_RUN,
#define _SC_2_FORT_RUN _SC_2_FORT_RUN
_SC_2_SW_DEV,
#define _SC_2_SW_DEV _SC_2_SW_DEV
_SC_2_LOCALEDEF,
#define _SC_2_LOCALEDEF _SC_2_LOCALEDEF
_SC_PII,
#define _SC_PII _SC_PII
_SC_PII_XTI,
#define _SC_PII_XTI _SC_PII_XTI
_SC_PII_SOCKET,
#define _SC_PII_SOCKET _SC_PII_SOCKET
_SC_PII_INTERNET,
#define _SC_PII_INTERNET _SC_PII_INTERNET
_SC_PII_OSI,
#define _SC_PII_OSI _SC_PII_OSI
_SC_POLL,
#define _SC_POLL _SC_POLL
_SC_SELECT,
#define _SC_SELECT _SC_SELECT
_SC_UIO_MAXIOV,
#define _SC_UIO_MAXIOV _SC_UIO_MAXIOV
_SC_IOV_MAX = _SC_UIO_MAXIOV,
#define _SC_IOV_MAX _SC_IOV_MAX
_SC_PII_INTERNET_STREAM,
#define _SC_PII_INTERNET_STREAM _SC_PII_INTERNET_STREAM
_SC_PII_INTERNET_DGRAM,
#define _SC_PII_INTERNET_DGRAM _SC_PII_INTERNET_DGRAM
_SC_PII_OSI_COTS,
#define _SC_PII_OSI_COTS _SC_PII_OSI_COTS
_SC_PII_OSI_CLTS,
#define _SC_PII_OSI_CLTS _SC_PII_OSI_CLTS
_SC_PII_OSI_M,
#define _SC_PII_OSI_M _SC_PII_OSI_M
_SC_T_IOV_MAX,
#define _SC_T_IOV_MAX _SC_T_IOV_MAX
_SC_THREADS,
#define _SC_THREADS _SC_THREADS
_SC_THREAD_SAFE_FUNCTIONS,
#define _SC_THREAD_SAFE_FUNCTIONS _SC_THREAD_SAFE_FUNCTIONS
_SC_GETGR_R_SIZE_MAX,
#define _SC_GETGR_R_SIZE_MAX _SC_GETGR_R_SIZE_MAX
_SC_GETPW_R_SIZE_MAX,
#define _SC_GETPW_R_SIZE_MAX _SC_GETPW_R_SIZE_MAX
_SC_LOGIN_NAME_MAX,
#define _SC_LOGIN_NAME_MAX _SC_LOGIN_NAME_MAX
_SC_TTY_NAME_MAX,
#define _SC_TTY_NAME_MAX _SC_TTY_NAME_MAX
_SC_THREAD_DESTRUCTOR_ITERATIONS,
#define _SC_THREAD_DESTRUCTOR_ITERATIONS _SC_THREAD_DESTRUCTOR_ITERATIONS
_SC_THREAD_KEYS_MAX,
#define _SC_THREAD_KEYS_MAX _SC_THREAD_KEYS_MAX
_SC_THREAD_STACK_MIN,
#define _SC_THREAD_STACK_MIN _SC_THREAD_STACK_MIN
_SC_THREAD_THREADS_MAX,
#define _SC_THREAD_THREADS_MAX _SC_THREAD_THREADS_MAX
_SC_THREAD_ATTR_STACKADDR,
#define _SC_THREAD_ATTR_STACKADDR _SC_THREAD_ATTR_STACKADDR
_SC_THREAD_ATTR_STACKSIZE,
#define _SC_THREAD_ATTR_STACKSIZE _SC_THREAD_ATTR_STACKSIZE
_SC_THREAD_PRIORITY_SCHEDULING,
#define _SC_THREAD_PRIORITY_SCHEDULING _SC_THREAD_PRIORITY_SCHEDULING
_SC_THREAD_PRIO_INHERIT,
#define _SC_THREAD_PRIO_INHERIT _SC_THREAD_PRIO_INHERIT
_SC_THREAD_PRIO_PROTECT,
#define _SC_THREAD_PRIO_PROTECT _SC_THREAD_PRIO_PROTECT
_SC_THREAD_PROCESS_SHARED,
#define _SC_THREAD_PROCESS_SHARED _SC_THREAD_PROCESS_SHARED
_SC_NPROCESSORS_CONF,
#define _SC_NPROCESSORS_CONF _SC_NPROCESSORS_CONF
_SC_NPROCESSORS_ONLN,
#define _SC_NPROCESSORS_ONLN _SC_NPROCESSORS_ONLN
_SC_PHYS_PAGES,
#define _SC_PHYS_PAGES _SC_PHYS_PAGES
_SC_AVPHYS_PAGES,
#define _SC_AVPHYS_PAGES _SC_AVPHYS_PAGES
_SC_ATEXIT_MAX,
#define _SC_ATEXIT_MAX _SC_ATEXIT_MAX
_SC_PASS_MAX,
#define _SC_PASS_MAX _SC_PASS_MAX
_SC_XOPEN_VERSION,
#define _SC_XOPEN_VERSION _SC_XOPEN_VERSION
_SC_XOPEN_XCU_VERSION,
#define _SC_XOPEN_XCU_VERSION _SC_XOPEN_XCU_VERSION
_SC_XOPEN_UNIX,
#define _SC_XOPEN_UNIX _SC_XOPEN_UNIX
_SC_XOPEN_CRYPT,
#define _SC_XOPEN_CRYPT _SC_XOPEN_CRYPT
_SC_XOPEN_ENH_I18N,
#define _SC_XOPEN_ENH_I18N _SC_XOPEN_ENH_I18N
_SC_XOPEN_SHM,
#define _SC_XOPEN_SHM _SC_XOPEN_SHM
_SC_2_CHAR_TERM,
#define _SC_2_CHAR_TERM _SC_2_CHAR_TERM
_SC_2_C_VERSION,
#define _SC_2_C_VERSION _SC_2_C_VERSION
_SC_2_UPE,
#define _SC_2_UPE _SC_2_UPE
_SC_XOPEN_XPG2,
#define _SC_XOPEN_XPG2 _SC_XOPEN_XPG2
_SC_XOPEN_XPG3,
#define _SC_XOPEN_XPG3 _SC_XOPEN_XPG3
_SC_XOPEN_XPG4,
#define _SC_XOPEN_XPG4 _SC_XOPEN_XPG4
_SC_CHAR_BIT,
#define _SC_CHAR_BIT _SC_CHAR_BIT
_SC_CHAR_MAX,
#define _SC_CHAR_MAX _SC_CHAR_MAX
_SC_CHAR_MIN,
#define _SC_CHAR_MIN _SC_CHAR_MIN
_SC_INT_MAX,
#define _SC_INT_MAX _SC_INT_MAX
_SC_INT_MIN,
#define _SC_INT_MIN _SC_INT_MIN
_SC_LONG_BIT,
#define _SC_LONG_BIT _SC_LONG_BIT
_SC_WORD_BIT,
#define _SC_WORD_BIT _SC_WORD_BIT
_SC_MB_LEN_MAX,
#define _SC_MB_LEN_MAX _SC_MB_LEN_MAX
_SC_NZERO,
#define _SC_NZERO _SC_NZERO
_SC_SSIZE_MAX,
#define _SC_SSIZE_MAX _SC_SSIZE_MAX
_SC_SCHAR_MAX,
#define _SC_SCHAR_MAX _SC_SCHAR_MAX
_SC_SCHAR_MIN,
#define _SC_SCHAR_MIN _SC_SCHAR_MIN
_SC_SHRT_MAX,
#define _SC_SHRT_MAX _SC_SHRT_MAX
_SC_SHRT_MIN,
#define _SC_SHRT_MIN _SC_SHRT_MIN
_SC_UCHAR_MAX,
#define _SC_UCHAR_MAX _SC_UCHAR_MAX
_SC_UINT_MAX,
#define _SC_UINT_MAX _SC_UINT_MAX
_SC_ULONG_MAX,
#define _SC_ULONG_MAX _SC_ULONG_MAX
_SC_USHRT_MAX,
#define _SC_USHRT_MAX _SC_USHRT_MAX
_SC_NL_ARGMAX,
#define _SC_NL_ARGMAX _SC_NL_ARGMAX
_SC_NL_LANGMAX,
#define _SC_NL_LANGMAX _SC_NL_LANGMAX
_SC_NL_MSGMAX,
#define _SC_NL_MSGMAX _SC_NL_MSGMAX
_SC_NL_NMAX,
#define _SC_NL_NMAX _SC_NL_NMAX
_SC_NL_SETMAX,
#define _SC_NL_SETMAX _SC_NL_SETMAX
_SC_NL_TEXTMAX,
#define _SC_NL_TEXTMAX _SC_NL_TEXTMAX
_SC_XBS5_ILP32_OFF32,
#define _SC_XBS5_ILP32_OFF32 _SC_XBS5_ILP32_OFF32
_SC_XBS5_ILP32_OFFBIG,
#define _SC_XBS5_ILP32_OFFBIG _SC_XBS5_ILP32_OFFBIG
_SC_XBS5_LP64_OFF64,
#define _SC_XBS5_LP64_OFF64 _SC_XBS5_LP64_OFF64
_SC_XBS5_LPBIG_OFFBIG,
#define _SC_XBS5_LPBIG_OFFBIG _SC_XBS5_LPBIG_OFFBIG
_SC_XOPEN_LEGACY,
#define _SC_XOPEN_LEGACY _SC_XOPEN_LEGACY
_SC_XOPEN_REALTIME,
#define _SC_XOPEN_REALTIME _SC_XOPEN_REALTIME
_SC_XOPEN_REALTIME_THREADS,
#define _SC_XOPEN_REALTIME_THREADS _SC_XOPEN_REALTIME_THREADS
_SC_ADVISORY_INFO,
#define _SC_ADVISORY_INFO _SC_ADVISORY_INFO
_SC_BARRIERS,
#define _SC_BARRIERS _SC_BARRIERS
_SC_BASE,
#define _SC_BASE _SC_BASE
_SC_C_LANG_SUPPORT,
#define _SC_C_LANG_SUPPORT _SC_C_LANG_SUPPORT
_SC_C_LANG_SUPPORT_R,
#define _SC_C_LANG_SUPPORT_R _SC_C_LANG_SUPPORT_R
_SC_CLOCK_SELECTION,
#define _SC_CLOCK_SELECTION _SC_CLOCK_SELECTION
_SC_CPUTIME,
#define _SC_CPUTIME _SC_CPUTIME
_SC_THREAD_CPUTIME,
#define _SC_THREAD_CPUTIME _SC_THREAD_CPUTIME
_SC_DEVICE_IO,
#define _SC_DEVICE_IO _SC_DEVICE_IO
_SC_DEVICE_SPECIFIC,
#define _SC_DEVICE_SPECIFIC _SC_DEVICE_SPECIFIC
_SC_DEVICE_SPECIFIC_R,
#define _SC_DEVICE_SPECIFIC_R _SC_DEVICE_SPECIFIC_R
_SC_FD_MGMT,
#define _SC_FD_MGMT _SC_FD_MGMT
_SC_FIFO,
#define _SC_FIFO _SC_FIFO
_SC_PIPE,
#define _SC_PIPE _SC_PIPE
_SC_FILE_ATTRIBUTES,
#define _SC_FILE_ATTRIBUTES _SC_FILE_ATTRIBUTES
_SC_FILE_LOCKING,
#define _SC_FILE_LOCKING _SC_FILE_LOCKING
_SC_FILE_SYSTEM,
#define _SC_FILE_SYSTEM _SC_FILE_SYSTEM
_SC_MONOTONIC_CLOCK,
#define _SC_MONOTONIC_CLOCK _SC_MONOTONIC_CLOCK
_SC_MULTI_PROCESS,
#define _SC_MULTI_PROCESS _SC_MULTI_PROCESS
_SC_SINGLE_PROCESS,
#define _SC_SINGLE_PROCESS _SC_SINGLE_PROCESS
_SC_NETWORKING,
#define _SC_NETWORKING _SC_NETWORKING
_SC_READER_WRITER_LOCKS,
#define _SC_READER_WRITER_LOCKS _SC_READER_WRITER_LOCKS
_SC_SPIN_LOCKS,
#define _SC_SPIN_LOCKS _SC_SPIN_LOCKS
_SC_REGEXP,
#define _SC_REGEXP _SC_REGEXP
_SC_REGEX_VERSION,
#define _SC_REGEX_VERSION _SC_REGEX_VERSION
_SC_SHELL,
#define _SC_SHELL _SC_SHELL
_SC_SIGNALS,
#define _SC_SIGNALS _SC_SIGNALS
_SC_SPAWN,
#define _SC_SPAWN _SC_SPAWN
_SC_SPORADIC_SERVER,
#define _SC_SPORADIC_SERVER _SC_SPORADIC_SERVER
_SC_THREAD_SPORADIC_SERVER,
#define _SC_THREAD_SPORADIC_SERVER _SC_THREAD_SPORADIC_SERVER
_SC_SYSTEM_DATABASE,
#define _SC_SYSTEM_DATABASE _SC_SYSTEM_DATABASE
_SC_SYSTEM_DATABASE_R,
#define _SC_SYSTEM_DATABASE_R _SC_SYSTEM_DATABASE_R
_SC_TIMEOUTS,
#define _SC_TIMEOUTS _SC_TIMEOUTS
_SC_TYPED_MEMORY_OBJECTS,
#define _SC_TYPED_MEMORY_OBJECTS _SC_TYPED_MEMORY_OBJECTS
_SC_USER_GROUPS,
#define _SC_USER_GROUPS _SC_USER_GROUPS
_SC_USER_GROUPS_R,
#define _SC_USER_GROUPS_R _SC_USER_GROUPS_R
_SC_2_PBS,
#define _SC_2_PBS _SC_2_PBS
_SC_2_PBS_ACCOUNTING,
#define _SC_2_PBS_ACCOUNTING _SC_2_PBS_ACCOUNTING
_SC_2_PBS_LOCATE,
#define _SC_2_PBS_LOCATE _SC_2_PBS_LOCATE
_SC_2_PBS_MESSAGE,
#define _SC_2_PBS_MESSAGE _SC_2_PBS_MESSAGE
_SC_2_PBS_TRACK,
#define _SC_2_PBS_TRACK _SC_2_PBS_TRACK
_SC_SYMLOOP_MAX,
#define _SC_SYMLOOP_MAX _SC_SYMLOOP_MAX
_SC_STREAMS,
#define _SC_STREAMS _SC_STREAMS
_SC_2_PBS_CHECKPOINT,
#define _SC_2_PBS_CHECKPOINT _SC_2_PBS_CHECKPOINT
_SC_V6_ILP32_OFF32,
#define _SC_V6_ILP32_OFF32 _SC_V6_ILP32_OFF32
_SC_V6_ILP32_OFFBIG,
#define _SC_V6_ILP32_OFFBIG _SC_V6_ILP32_OFFBIG
_SC_V6_LP64_OFF64,
#define _SC_V6_LP64_OFF64 _SC_V6_LP64_OFF64
_SC_V6_LPBIG_OFFBIG,
#define _SC_V6_LPBIG_OFFBIG _SC_V6_LPBIG_OFFBIG
_SC_HOST_NAME_MAX,
#define _SC_HOST_NAME_MAX _SC_HOST_NAME_MAX
_SC_TRACE,
#define _SC_TRACE _SC_TRACE
_SC_TRACE_EVENT_FILTER,
#define _SC_TRACE_EVENT_FILTER _SC_TRACE_EVENT_FILTER
_SC_TRACE_INHERIT,
#define _SC_TRACE_INHERIT _SC_TRACE_INHERIT
_SC_TRACE_LOG,
#define _SC_TRACE_LOG _SC_TRACE_LOG
_SC_LEVEL1_ICACHE_SIZE,
#define _SC_LEVEL1_ICACHE_SIZE _SC_LEVEL1_ICACHE_SIZE
_SC_LEVEL1_ICACHE_ASSOC,
#define _SC_LEVEL1_ICACHE_ASSOC _SC_LEVEL1_ICACHE_ASSOC
_SC_LEVEL1_ICACHE_LINESIZE,
#define _SC_LEVEL1_ICACHE_LINESIZE _SC_LEVEL1_ICACHE_LINESIZE
_SC_LEVEL1_DCACHE_SIZE,
#define _SC_LEVEL1_DCACHE_SIZE _SC_LEVEL1_DCACHE_SIZE
_SC_LEVEL1_DCACHE_ASSOC,
#define _SC_LEVEL1_DCACHE_ASSOC _SC_LEVEL1_DCACHE_ASSOC
_SC_LEVEL1_DCACHE_LINESIZE,
#define _SC_LEVEL1_DCACHE_LINESIZE _SC_LEVEL1_DCACHE_LINESIZE
_SC_LEVEL2_CACHE_SIZE,
#define _SC_LEVEL2_CACHE_SIZE _SC_LEVEL2_CACHE_SIZE
_SC_LEVEL2_CACHE_ASSOC,
#define _SC_LEVEL2_CACHE_ASSOC _SC_LEVEL2_CACHE_ASSOC
_SC_LEVEL2_CACHE_LINESIZE,
#define _SC_LEVEL2_CACHE_LINESIZE _SC_LEVEL2_CACHE_LINESIZE
_SC_LEVEL3_CACHE_SIZE,
#define _SC_LEVEL3_CACHE_SIZE _SC_LEVEL3_CACHE_SIZE
_SC_LEVEL3_CACHE_ASSOC,
#define _SC_LEVEL3_CACHE_ASSOC _SC_LEVEL3_CACHE_ASSOC
_SC_LEVEL3_CACHE_LINESIZE,
#define _SC_LEVEL3_CACHE_LINESIZE _SC_LEVEL3_CACHE_LINESIZE
_SC_LEVEL4_CACHE_SIZE,
#define _SC_LEVEL4_CACHE_SIZE _SC_LEVEL4_CACHE_SIZE
_SC_LEVEL4_CACHE_ASSOC,
#define _SC_LEVEL4_CACHE_ASSOC _SC_LEVEL4_CACHE_ASSOC
_SC_LEVEL4_CACHE_LINESIZE,
#define _SC_LEVEL4_CACHE_LINESIZE _SC_LEVEL4_CACHE_LINESIZE
_SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
#define _SC_IPV6 _SC_IPV6
_SC_RAW_SOCKETS,
#define _SC_RAW_SOCKETS _SC_RAW_SOCKETS
_SC_V7_ILP32_OFF32,
#define _SC_V7_ILP32_OFF32 _SC_V7_ILP32_OFF32
_SC_V7_ILP32_OFFBIG,
#define _SC_V7_ILP32_OFFBIG _SC_V7_ILP32_OFFBIG
_SC_V7_LP64_OFF64,
#define _SC_V7_LP64_OFF64 _SC_V7_LP64_OFF64
_SC_V7_LPBIG_OFFBIG,
#define _SC_V7_LPBIG_OFFBIG _SC_V7_LPBIG_OFFBIG
_SC_SS_REPL_MAX,
#define _SC_SS_REPL_MAX _SC_SS_REPL_MAX
_SC_TRACE_EVENT_NAME_MAX,
#define _SC_TRACE_EVENT_NAME_MAX _SC_TRACE_EVENT_NAME_MAX
_SC_TRACE_NAME_MAX,
#define _SC_TRACE_NAME_MAX _SC_TRACE_NAME_MAX
_SC_TRACE_SYS_MAX,
#define _SC_TRACE_SYS_MAX _SC_TRACE_SYS_MAX
_SC_TRACE_USER_EVENT_MAX,
#define _SC_TRACE_USER_EVENT_MAX _SC_TRACE_USER_EVENT_MAX
_SC_XOPEN_STREAMS,
#define _SC_XOPEN_STREAMS _SC_XOPEN_STREAMS
_SC_THREAD_ROBUST_PRIO_INHERIT,
#define _SC_THREAD_ROBUST_PRIO_INHERIT _SC_THREAD_ROBUST_PRIO_INHERIT
_SC_THREAD_ROBUST_PRIO_PROTECT
#define _SC_THREAD_ROBUST_PRIO_PROTECT _SC_THREAD_ROBUST_PRIO_PROTECT
};
enum
{
_CS_PATH,
#define _CS_PATH _CS_PATH
_CS_V6_WIDTH_RESTRICTED_ENVS,
#define _CS_V6_WIDTH_RESTRICTED_ENVS _CS_V6_WIDTH_RESTRICTED_ENVS
#define _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS _CS_V6_WIDTH_RESTRICTED_ENVS
_CS_GNU_LIBC_VERSION,
#define _CS_GNU_LIBC_VERSION _CS_GNU_LIBC_VERSION
_CS_GNU_LIBPTHREAD_VERSION,
#define _CS_GNU_LIBPTHREAD_VERSION _CS_GNU_LIBPTHREAD_VERSION
_CS_V5_WIDTH_RESTRICTED_ENVS,
#define _CS_V5_WIDTH_RESTRICTED_ENVS _CS_V5_WIDTH_RESTRICTED_ENVS
#define _CS_POSIX_V5_WIDTH_RESTRICTED_ENVS _CS_V5_WIDTH_RESTRICTED_ENVS
_CS_V7_WIDTH_RESTRICTED_ENVS,
#define _CS_V7_WIDTH_RESTRICTED_ENVS _CS_V7_WIDTH_RESTRICTED_ENVS
#define _CS_POSIX_V7_WIDTH_RESTRICTED_ENVS _CS_V7_WIDTH_RESTRICTED_ENVS
_CS_LFS_CFLAGS = 1000,
#define _CS_LFS_CFLAGS _CS_LFS_CFLAGS
_CS_LFS_LDFLAGS,
#define _CS_LFS_LDFLAGS _CS_LFS_LDFLAGS
_CS_LFS_LIBS,
#define _CS_LFS_LIBS _CS_LFS_LIBS
_CS_LFS_LINTFLAGS,
#define _CS_LFS_LINTFLAGS _CS_LFS_LINTFLAGS
_CS_LFS64_CFLAGS,
#define _CS_LFS64_CFLAGS _CS_LFS64_CFLAGS
_CS_LFS64_LDFLAGS,
#define _CS_LFS64_LDFLAGS _CS_LFS64_LDFLAGS
_CS_LFS64_LIBS,
#define _CS_LFS64_LIBS _CS_LFS64_LIBS
_CS_LFS64_LINTFLAGS,
#define _CS_LFS64_LINTFLAGS _CS_LFS64_LINTFLAGS
_CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
#define _CS_XBS5_ILP32_OFF32_CFLAGS _CS_XBS5_ILP32_OFF32_CFLAGS
_CS_XBS5_ILP32_OFF32_LDFLAGS,
#define _CS_XBS5_ILP32_OFF32_LDFLAGS _CS_XBS5_ILP32_OFF32_LDFLAGS
_CS_XBS5_ILP32_OFF32_LIBS,
#define _CS_XBS5_ILP32_OFF32_LIBS _CS_XBS5_ILP32_OFF32_LIBS
_CS_XBS5_ILP32_OFF32_LINTFLAGS,
#define _CS_XBS5_ILP32_OFF32_LINTFLAGS _CS_XBS5_ILP32_OFF32_LINTFLAGS
_CS_XBS5_ILP32_OFFBIG_CFLAGS,
#define _CS_XBS5_ILP32_OFFBIG_CFLAGS _CS_XBS5_ILP32_OFFBIG_CFLAGS
_CS_XBS5_ILP32_OFFBIG_LDFLAGS,
#define _CS_XBS5_ILP32_OFFBIG_LDFLAGS _CS_XBS5_ILP32_OFFBIG_LDFLAGS
_CS_XBS5_ILP32_OFFBIG_LIBS,
#define _CS_XBS5_ILP32_OFFBIG_LIBS _CS_XBS5_ILP32_OFFBIG_LIBS
_CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
#define _CS_XBS5_ILP32_OFFBIG_LINTFLAGS _CS_XBS5_ILP32_OFFBIG_LINTFLAGS
_CS_XBS5_LP64_OFF64_CFLAGS,
#define _CS_XBS5_LP64_OFF64_CFLAGS _CS_XBS5_LP64_OFF64_CFLAGS
_CS_XBS5_LP64_OFF64_LDFLAGS,
#define _CS_XBS5_LP64_OFF64_LDFLAGS _CS_XBS5_LP64_OFF64_LDFLAGS
_CS_XBS5_LP64_OFF64_LIBS,
#define _CS_XBS5_LP64_OFF64_LIBS _CS_XBS5_LP64_OFF64_LIBS
_CS_XBS5_LP64_OFF64_LINTFLAGS,
#define _CS_XBS5_LP64_OFF64_LINTFLAGS _CS_XBS5_LP64_OFF64_LINTFLAGS
_CS_XBS5_LPBIG_OFFBIG_CFLAGS,
#define _CS_XBS5_LPBIG_OFFBIG_CFLAGS _CS_XBS5_LPBIG_OFFBIG_CFLAGS
_CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
#define _CS_XBS5_LPBIG_OFFBIG_LDFLAGS _CS_XBS5_LPBIG_OFFBIG_LDFLAGS
_CS_XBS5_LPBIG_OFFBIG_LIBS,
#define _CS_XBS5_LPBIG_OFFBIG_LIBS _CS_XBS5_LPBIG_OFFBIG_LIBS
_CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
#define _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
_CS_POSIX_V6_ILP32_OFF32_CFLAGS,
#define _CS_POSIX_V6_ILP32_OFF32_CFLAGS _CS_POSIX_V6_ILP32_OFF32_CFLAGS
_CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
#define _CS_POSIX_V6_ILP32_OFF32_LDFLAGS _CS_POSIX_V6_ILP32_OFF32_LDFLAGS
_CS_POSIX_V6_ILP32_OFF32_LIBS,
#define _CS_POSIX_V6_ILP32_OFF32_LIBS _CS_POSIX_V6_ILP32_OFF32_LIBS
_CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
#define _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS
_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
#define _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS
_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
#define _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS
_CS_POSIX_V6_ILP32_OFFBIG_LIBS,
#define _CS_POSIX_V6_ILP32_OFFBIG_LIBS _CS_POSIX_V6_ILP32_OFFBIG_LIBS
_CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
#define _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS
_CS_POSIX_V6_LP64_OFF64_CFLAGS,
#define _CS_POSIX_V6_LP64_OFF64_CFLAGS _CS_POSIX_V6_LP64_OFF64_CFLAGS
_CS_POSIX_V6_LP64_OFF64_LDFLAGS,
#define _CS_POSIX_V6_LP64_OFF64_LDFLAGS _CS_POSIX_V6_LP64_OFF64_LDFLAGS
_CS_POSIX_V6_LP64_OFF64_LIBS,
#define _CS_POSIX_V6_LP64_OFF64_LIBS _CS_POSIX_V6_LP64_OFF64_LIBS
_CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
#define _CS_POSIX_V6_LP64_OFF64_LINTFLAGS _CS_POSIX_V6_LP64_OFF64_LINTFLAGS
_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
#define _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS
_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
#define _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS
_CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
#define _CS_POSIX_V6_LPBIG_OFFBIG_LIBS _CS_POSIX_V6_LPBIG_OFFBIG_LIBS
_CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,
#define _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS
_CS_POSIX_V7_ILP32_OFF32_CFLAGS,
#define _CS_POSIX_V7_ILP32_OFF32_CFLAGS _CS_POSIX_V7_ILP32_OFF32_CFLAGS
_CS_POSIX_V7_ILP32_OFF32_LDFLAGS,
#define _CS_POSIX_V7_ILP32_OFF32_LDFLAGS _CS_POSIX_V7_ILP32_OFF32_LDFLAGS
_CS_POSIX_V7_ILP32_OFF32_LIBS,
#define _CS_POSIX_V7_ILP32_OFF32_LIBS _CS_POSIX_V7_ILP32_OFF32_LIBS
_CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,
#define _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS
_CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,
#define _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS
_CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,
#define _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS
_CS_POSIX_V7_ILP32_OFFBIG_LIBS,
#define _CS_POSIX_V7_ILP32_OFFBIG_LIBS _CS_POSIX_V7_ILP32_OFFBIG_LIBS
_CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,
#define _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS
_CS_POSIX_V7_LP64_OFF64_CFLAGS,
#define _CS_POSIX_V7_LP64_OFF64_CFLAGS _CS_POSIX_V7_LP64_OFF64_CFLAGS
_CS_POSIX_V7_LP64_OFF64_LDFLAGS,
#define _CS_POSIX_V7_LP64_OFF64_LDFLAGS _CS_POSIX_V7_LP64_OFF64_LDFLAGS
_CS_POSIX_V7_LP64_OFF64_LIBS,
#define _CS_POSIX_V7_LP64_OFF64_LIBS _CS_POSIX_V7_LP64_OFF64_LIBS
_CS_POSIX_V7_LP64_OFF64_LINTFLAGS,
#define _CS_POSIX_V7_LP64_OFF64_LINTFLAGS _CS_POSIX_V7_LP64_OFF64_LINTFLAGS
_CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,
#define _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS
_CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,
#define _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS
_CS_POSIX_V7_LPBIG_OFFBIG_LIBS,
#define _CS_POSIX_V7_LPBIG_OFFBIG_LIBS _CS_POSIX_V7_LPBIG_OFFBIG_LIBS
_CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS,
#define _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS
_CS_V6_ENV,
#define _CS_V6_ENV _CS_V6_ENV
_CS_V7_ENV
#define _CS_V7_ENV _CS_V7_ENV
};
extern long int pathconf (const char *__path, int __name)
throw () __attribute__ ((__nonnull__ (1)));
extern long int fpathconf (int __fd, int __name) throw ();
extern long int sysconf (int __name) throw ();
extern size_t confstr (int __name, char *__buf, size_t __len) throw ();
extern __pid_t getpid (void) throw ();
extern __pid_t getppid (void) throw ();
extern __pid_t getpgrp (void) throw ();
extern __pid_t __getpgid (__pid_t __pid) throw ();
extern __pid_t getpgid (__pid_t __pid) throw ();
extern int setpgid (__pid_t __pid, __pid_t __pgid) throw ();
extern int setpgrp (void) throw ();
extern __pid_t setsid (void) throw ();
extern __pid_t getsid (__pid_t __pid) throw ();
extern __uid_t getuid (void) throw ();
extern __uid_t geteuid (void) throw ();
extern __gid_t getgid (void) throw ();
extern __gid_t getegid (void) throw ();
extern int getgroups (int __size, __gid_t __list[]) throw () ;
extern int group_member (__gid_t __gid) throw ();
extern int setuid (__uid_t __uid) throw () ;
extern int setreuid (__uid_t __ruid, __uid_t __euid) throw () ;
extern int seteuid (__uid_t __uid) throw () ;
extern int setgid (__gid_t __gid) throw () ;
extern int setregid (__gid_t __rgid, __gid_t __egid) throw () ;
extern int setegid (__gid_t __gid) throw () ;
extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
throw ();
extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
throw ();
extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
throw () ;
extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
throw () ;
extern __pid_t fork (void) throw ();
extern __pid_t vfork (void) throw ();
extern char *ttyname (int __fd) throw ();
extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2))) ;
extern int isatty (int __fd) throw ();
extern int ttyslot (void) throw ();
extern int link (const char *__from, const char *__to)
throw () __attribute__ ((__nonnull__ (1, 2))) ;
extern int linkat (int __fromfd, const char *__from, int __tofd,
const char *__to, int __flags)
throw () __attribute__ ((__nonnull__ (2, 4))) ;
extern int symlink (const char *__from, const char *__to)
throw () __attribute__ ((__nonnull__ (1, 2))) ;
extern ssize_t readlink (const char *__restrict __path,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (1, 2))) ;
extern int symlinkat (const char *__from, int __tofd,
const char *__to) throw () __attribute__ ((__nonnull__ (1, 3))) ;
extern ssize_t readlinkat (int __fd, const char *__restrict __path,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (2, 3))) ;
extern int unlink (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
extern int unlinkat (int __fd, const char *__name, int __flag)
throw () __attribute__ ((__nonnull__ (2)));
extern int rmdir (const char *__path) throw () __attribute__ ((__nonnull__ (1)));
extern __pid_t tcgetpgrp (int __fd) throw ();
extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) throw ();
extern char *getlogin (void);
extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)));
extern int setlogin (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
#define __need_getopt
extern "C" {
extern char *optarg;
extern int optind;
extern int opterr;
extern int optopt;
extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
throw ();
}
#undef __need_getopt
extern int gethostname (char *__name, size_t __len) throw () __attribute__ ((__nonnull__ (1)));
extern int sethostname (const char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int sethostid (long int __id) throw () ;
extern int getdomainname (char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int setdomainname (const char *__name, size_t __len)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int vhangup (void) throw ();
extern int revoke (const char *__file) throw () __attribute__ ((__nonnull__ (1))) ;
extern int profil (unsigned short int *__sample_buffer, size_t __size,
size_t __offset, unsigned int __scale)
throw () __attribute__ ((__nonnull__ (1)));
extern int acct (const char *__name) throw ();
extern char *getusershell (void) throw ();
extern void endusershell (void) throw ();
extern void setusershell (void) throw ();
extern int daemon (int __nochdir, int __noclose) throw () ;
extern int chroot (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;
extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1)));
extern int fsync (int __fd);
extern int syncfs (int __fd) throw ();
extern long int gethostid (void);
extern void sync (void) throw ();
extern int getpagesize (void) throw () __attribute__ ((__const__));
extern int getdtablesize (void) throw ();
extern int truncate (const char *__file, __off_t __length)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int truncate64 (const char *__file, __off64_t __length)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int ftruncate (int __fd, __off_t __length) throw () ;
extern int ftruncate64 (int __fd, __off64_t __length) throw () ;
extern int brk (void *__addr) throw () ;
extern void *sbrk (intptr_t __delta) throw ();
extern long int syscall (long int __sysno, ...) throw ();
#define F_ULOCK 0
#define F_LOCK 1
#define F_TLOCK 2
#define F_TEST 3
extern int lockf (int __fd, int __cmd, __off_t __len) ;
extern int lockf64 (int __fd, int __cmd, __off64_t __len) ;
#define TEMP_FAILURE_RETRY(expression) (__extension__ ({ long int __result; do __result = (long int) (expression); while (__result == -1L && errno == EINTR); __result; }))
extern int fdatasync (int __fildes);
extern char *crypt (const char *__key, const char *__salt)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void encrypt (char *__glibc_block, int __edflag)
throw () __attribute__ ((__nonnull__ (1)));
extern void swab (const void *__restrict __from, void *__restrict __to,
ssize_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
}
#define BOOST_STD_EXTENSION_NAMESPACE __gnu_cxx
#define BOOST_HAS_SLIST
#define BOOST_HAS_HASH
#define BOOST_SLIST_HEADER <ext/slist>
#define BOOST_HASH_SET_HEADER <backward/hash_set>
#define BOOST_HASH_MAP_HEADER <backward/hash_map>
#define BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG
#define BOOST_HAS_TR1_COMPLEX_OVERLOADS
#define BOOST_NO_CXX11_HDR_THREAD
#define BOOST_NO_CXX11_HDR_TYPE_TRAITS
#define BOOST_NO_CXX11_HDR_CODECVT
#define BOOST_NO_CXX11_ATOMIC_SMART_PTR
#define BOOST_PLATFORM_CONFIG "boost/config/platform/linux.hpp"
#define BOOST_PLATFORM "linux"
#define _GLIBCXX_CSTDLIB 1
#define __need_size_t
#define __need_wchar_t
#define __need_NULL
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
extern "C" {
#define _STDLIB_H 1
#define WNOHANG 1
#define WUNTRACED 2
#define WSTOPPED 2
#define WEXITED 4
#define WCONTINUED 8
#define WNOWAIT 0x01000000
#define __WNOTHREAD 0x20000000
#define __WALL 0x40000000
#define __WCLONE 0x80000000
#define __ENUM_IDTYPE_T 1
#undef P_ALL
#undef P_PID
#undef P_PGID
typedef enum
{
P_ALL,
P_PID,
P_PGID
} idtype_t;
#define __WEXITSTATUS(status) (((status) & 0xff00) >> 8)
#define __WTERMSIG(status) ((status) & 0x7f)
#define __WSTOPSIG(status) __WEXITSTATUS(status)
#define __WIFEXITED(status) (__WTERMSIG(status) == 0)
#define __WIFSIGNALED(status) (((signed char) (((status) & 0x7f) + 1) >> 1) > 0)
#define __WIFSTOPPED(status) (((status) & 0xff) == 0x7f)
#define __WIFCONTINUED(status) ((status) == __W_CONTINUED)
#define __WCOREDUMP(status) ((status) & __WCOREFLAG)
#define __W_EXITCODE(ret,sig) ((ret) << 8 | (sig))
#define __W_STOPCODE(sig) ((sig) << 8 | 0x7f)
#define __W_CONTINUED 0xffff
#define __WCOREFLAG 0x80
#define _ENDIAN_H 1
#define __LITTLE_ENDIAN 1234
#define __BIG_ENDIAN 4321
#define __PDP_ENDIAN 3412
#define __BYTE_ORDER __LITTLE_ENDIAN
#define __FLOAT_WORD_ORDER __BYTE_ORDER
#define LITTLE_ENDIAN __LITTLE_ENDIAN
#define BIG_ENDIAN __BIG_ENDIAN
#define PDP_ENDIAN __PDP_ENDIAN
#define BYTE_ORDER __BYTE_ORDER
#define __LONG_LONG_PAIR(HI,LO) LO, HI
#define _BITS_BYTESWAP_H 1
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
#define __bswap_constant_16(x) ((unsigned short int) ((((x) >> 8) & 0xff) | (((x) & 0xff) << 8)))
#define __bswap_16(x) (__extension__ ({ unsigned short int __v, __x = (unsigned short int) (x); if (__builtin_constant_p (__x)) __v = __bswap_constant_16 (__x); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; }))
#define __bswap_constant_32(x) ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | (((x) & 0x0000ff00) << 8) | (((x) & 0x000000ff) << 24))
static unsigned int
__bswap_32 (unsigned int __bsx)
;
#define __bswap_constant_64(x) (__extension__ ((((x) & 0xff00000000000000ull) >> 56) | (((x) & 0x00ff000000000000ull) >> 40) | (((x) & 0x0000ff0000000000ull) >> 24) | (((x) & 0x000000ff00000000ull) >> 8) | (((x) & 0x00000000ff000000ull) << 8) | (((x) & 0x0000000000ff0000ull) << 24) | (((x) & 0x000000000000ff00ull) << 40) | (((x) & 0x00000000000000ffull) << 56)))
static __uint64_t
__bswap_64 (__uint64_t __bsx)
;
#define htobe16(x) __bswap_16 (x)
#define htole16(x) (x)
#define be16toh(x) __bswap_16 (x)
#define le16toh(x) (x)
#define htobe32(x) __bswap_32 (x)
#define htole32(x) (x)
#define be32toh(x) __bswap_32 (x)
#define le32toh(x) (x)
#define htobe64(x) __bswap_64 (x)
#define htole64(x) (x)
#define be64toh(x) __bswap_64 (x)
#define le64toh(x) (x)
union wait
{
int w_status;
struct
{
unsigned int __w_termsig:7;
unsigned int __w_coredump:1;
unsigned int __w_retcode:8;
unsigned int:16;
} __wait_terminated;
struct
{
unsigned int __w_stopval:8;
unsigned int __w_stopsig:8;
unsigned int:16;
} __wait_stopped;
};
#define w_termsig __wait_terminated.__w_termsig
#define w_coredump __wait_terminated.__w_coredump
#define w_retcode __wait_terminated.__w_retcode
#define w_stopsig __wait_stopped.__w_stopsig
#define w_stopval __wait_stopped.__w_stopval
#define __WAIT_INT(status) (*(int *) &(status))
#define __WAIT_STATUS void *
#define __WAIT_STATUS_DEFN void *
#define WEXITSTATUS(status) __WEXITSTATUS (__WAIT_INT (status))
#define WTERMSIG(status) __WTERMSIG (__WAIT_INT (status))
#define WSTOPSIG(status) __WSTOPSIG (__WAIT_INT (status))
#define WIFEXITED(status) __WIFEXITED (__WAIT_INT (status))
#define WIFSIGNALED(status) __WIFSIGNALED (__WAIT_INT (status))
#define WIFSTOPPED(status) __WIFSTOPPED (__WAIT_INT (status))
#define WIFCONTINUED(status) __WIFCONTINUED (__WAIT_INT (status))
typedef struct
{
int quot;
int rem;
} div_t;
typedef struct
{
long int quot;
long int rem;
} ldiv_t;
#define __ldiv_t_defined 1
__extension__ typedef struct
{
long long int quot;
long long int rem;
} lldiv_t;
#define __lldiv_t_defined 1
#define RAND_MAX 2147483647
#define EXIT_FAILURE 1
#define EXIT_SUCCESS 0
#define MB_CUR_MAX (__ctype_get_mb_cur_max ())
extern size_t __ctype_get_mb_cur_max (void) throw () ;
extern double atof (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern int atoi (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern long int atol (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
__extension__ extern long long int atoll (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern double strtod (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
extern float strtof (const char *__restrict __nptr,
char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1)));
extern long double strtold (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
extern long int strtol (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
extern unsigned long int strtoul (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern long long int strtoq (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern unsigned long long int strtouq (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern long long int strtoll (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern unsigned long long int strtoull (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
#define _XLOCALE_H 1
typedef struct __locale_struct
{
struct __locale_data *__locales[13];
const unsigned short int *__ctype_b;
const int *__ctype_tolower;
const int *__ctype_toupper;
const char *__names[13];
} *__locale_t;
typedef __locale_t locale_t;
extern long int strtol_l (const char *__restrict __nptr,
char **__restrict __endptr, int __base,
__locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4)));
extern unsigned long int strtoul_l (const char *__restrict __nptr,
char **__restrict __endptr,
int __base, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4)));
__extension__
extern long long int strtoll_l (const char *__restrict __nptr,
char **__restrict __endptr, int __base,
__locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4)));
__extension__
extern unsigned long long int strtoull_l (const char *__restrict __nptr,
char **__restrict __endptr,
int __base, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4)));
extern double strtod_l (const char *__restrict __nptr,
char **__restrict __endptr, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern float strtof_l (const char *__restrict __nptr,
char **__restrict __endptr, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern long double strtold_l (const char *__restrict __nptr,
char **__restrict __endptr,
__locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern char *l64a (long int __n) throw () ;
extern long int a64l (const char *__s)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
#define _SYS_TYPES_H 1
extern "C" {
typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;
#define __u_char_defined
typedef __loff_t loff_t;
typedef __ino_t ino_t;
#define __ino_t_defined
typedef __ino64_t ino64_t;
#define __ino64_t_defined
typedef __dev_t dev_t;
#define __dev_t_defined
typedef __mode_t mode_t;
#define __mode_t_defined
typedef __nlink_t nlink_t;
#define __nlink_t_defined
typedef __id_t id_t;
#define __id_t_defined
typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;
#define __daddr_t_defined
typedef __key_t key_t;
#define __key_t_defined
#define __need_clock_t
#define __need_time_t
#define __need_timer_t
#define __need_clockid_t
#define __clock_t_defined 1
typedef __clock_t clock_t;
#undef __need_clock_t
#define __time_t_defined 1
typedef __time_t time_t;
#undef __need_time_t
#define __clockid_t_defined 1
typedef __clockid_t clockid_t;
#undef __clockid_time_t
#define __timer_t_defined 1
typedef __timer_t timer_t;
#undef __need_timer_t
#undef __need_timespec
typedef __suseconds_t suseconds_t;
#define __suseconds_t_defined
#define __need_size_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
#define __intN_t(N,MODE) typedef int int ##N ##_t __attribute__ ((__mode__ (MODE)))
#define __u_intN_t(N,MODE) typedef unsigned int u_int ##N ##_t __attribute__ ((__mode__ (MODE)))
#define __int8_t_defined
typedef int int8_t __attribute__ ((__mode__ (__QI__)));
typedef int int16_t __attribute__ ((__mode__ (__HI__)));
typedef int int32_t __attribute__ ((__mode__ (__SI__)));
typedef int int64_t __attribute__ ((__mode__ (__DI__)));
typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
typedef int register_t __attribute__ ((__mode__ (__word__)));
#define __BIT_TYPES_DEFINED__ 1
#define _SYS_SELECT_H 1
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
#define __FD_ZERO_STOS "stosq"
#define __FD_ZERO(fdsp) do { int __d0, __d1; __asm__ __volatile__ ("cld; rep; " __FD_ZERO_STOS : "=c" (__d0), "=D" (__d1) : "a" (0), "0" (sizeof (fd_set) / sizeof (__fd_mask)), "1" (&__FDS_BITS (fdsp)[0]) : "memory"); } while (0)
#define __FD_SET(d,set) ((void) (__FDS_BITS (set)[__FD_ELT (d)] |= __FD_MASK (d)))
#define __FD_CLR(d,set) ((void) (__FDS_BITS (set)[__FD_ELT (d)] &= ~__FD_MASK (d)))
#define __FD_ISSET(d,set) ((__FDS_BITS (set)[__FD_ELT (d)] & __FD_MASK (d)) != 0)
#define _SIGSET_H_types 1
typedef int __sig_atomic_t;
#define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int)))
typedef struct
{
unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
} __sigset_t;
#define __sigset_t_defined
typedef __sigset_t sigset_t;
#define __need_time_t
#define __need_timespec
#undef __need_clock_t
#undef __need_time_t
#undef __clockid_time_t
#undef __need_timer_t
#define __timespec_defined 1
struct timespec
{
__time_t tv_sec;
__syscall_slong_t tv_nsec;
};
#undef __need_timespec
#define __need_timeval
#define _STRUCT_TIMEVAL 1
struct timeval
{
__time_t tv_sec;
__suseconds_t tv_usec;
};
#undef __need_timeval
typedef long int __fd_mask;
#undef __NFDBITS
#define __NFDBITS (8 * (int) sizeof (__fd_mask))
#define __FD_ELT(d) ((d) / __NFDBITS)
#define __FD_MASK(d) ((__fd_mask) 1 << ((d) % __NFDBITS))
typedef struct
{
__fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
#define __FDS_BITS(set) ((set)->fds_bits)
} fd_set;
#define FD_SETSIZE __FD_SETSIZE
typedef __fd_mask fd_mask;
#define NFDBITS __NFDBITS
#define FD_SET(fd,fdsetp) __FD_SET (fd, fdsetp)
#define FD_CLR(fd,fdsetp) __FD_CLR (fd, fdsetp)
#define FD_ISSET(fd,fdsetp) __FD_ISSET (fd, fdsetp)
#define FD_ZERO(fdsetp) __FD_ZERO (fdsetp)
extern "C" {
extern int select (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
struct timeval *__restrict __timeout);
extern int pselect (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
const struct timespec *__restrict __timeout,
const __sigset_t *__restrict __sigmask);
}
#define _SYS_SYSMACROS_H 1
extern "C" {
__extension__
extern unsigned int gnu_dev_major (unsigned long long int __dev)
throw () __attribute__ ((__const__));
__extension__
extern unsigned int gnu_dev_minor (unsigned long long int __dev)
throw () __attribute__ ((__const__));
__extension__
extern unsigned long long int gnu_dev_makedev (unsigned int __major,
unsigned int __minor)
throw () __attribute__ ((__const__));
}
#define major(dev) gnu_dev_major (dev)
#define minor(dev) gnu_dev_minor (dev)
#define makedev(maj,min) gnu_dev_makedev (maj, min)
typedef __blksize_t blksize_t;
#define __blksize_t_defined
typedef __blkcnt_t blkcnt_t;
#define __blkcnt_t_defined
typedef __fsblkcnt_t fsblkcnt_t;
#define __fsblkcnt_t_defined
typedef __fsfilcnt_t fsfilcnt_t;
#define __fsfilcnt_t_defined
typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;
#define _BITS_PTHREADTYPES_H 1
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
#define __SIZEOF_PTHREAD_ATTR_T 56
#define __SIZEOF_PTHREAD_MUTEX_T 40
#define __SIZEOF_PTHREAD_MUTEXATTR_T 4
#define __SIZEOF_PTHREAD_COND_T 48
#define __SIZEOF_PTHREAD_CONDATTR_T 4
#define __SIZEOF_PTHREAD_RWLOCK_T 56
#define __SIZEOF_PTHREAD_RWLOCKATTR_T 8
#define __SIZEOF_PTHREAD_BARRIER_T 32
#define __SIZEOF_PTHREAD_BARRIERATTR_T 4
typedef unsigned long int pthread_t;
union pthread_attr_t
{
char __size[56];
long int __align;
};
typedef union pthread_attr_t pthread_attr_t;
#define __have_pthread_attr_t 1
typedef struct __pthread_internal_list
{
struct __pthread_internal_list *__prev;
struct __pthread_internal_list *__next;
} __pthread_list_t;
typedef union
{
struct __pthread_mutex_s
{
int __lock;
unsigned int __count;
int __owner;
unsigned int __nusers;
int __kind;
short __spins;
short __elision;
__pthread_list_t __list;
#define __PTHREAD_MUTEX_HAVE_PREV 1
#define __PTHREAD_MUTEX_HAVE_ELISION 1
} __data;
char __size[40];
long int __align;
} pthread_mutex_t;
typedef union
{
char __size[4];
int __align;
} pthread_mutexattr_t;
typedef union
{
struct
{
int __lock;
unsigned int __futex;
__extension__ unsigned long long int __total_seq;
__extension__ unsigned long long int __wakeup_seq;
__extension__ unsigned long long int __woken_seq;
void *__mutex;
unsigned int __nwaiters;
unsigned int __broadcast_seq;
} __data;
char __size[48];
__extension__ long long int __align;
} pthread_cond_t;
typedef union
{
char __size[4];
int __align;
} pthread_condattr_t;
typedef unsigned int pthread_key_t;
typedef int pthread_once_t;
typedef union
{
struct
{
int __lock;
unsigned int __nr_readers;
unsigned int __readers_wakeup;
unsigned int __writer_wakeup;
unsigned int __nr_readers_queued;
unsigned int __nr_writers_queued;
int __writer;
int __shared;
unsigned long int __pad1;
unsigned long int __pad2;
unsigned int __flags;
#define __PTHREAD_RWLOCK_INT_FLAGS_SHARED 1
} __data;
char __size[56];
long int __align;
} pthread_rwlock_t;
typedef union
{
char __size[8];
long int __align;
} pthread_rwlockattr_t;
typedef volatile int pthread_spinlock_t;
typedef union
{
char __size[32];
long int __align;
} pthread_barrier_t;
typedef union
{
char __size[4];
int __align;
} pthread_barrierattr_t;
}
extern long int random (void) throw ();
extern void srandom (unsigned int __seed) throw ();
extern char *initstate (unsigned int __seed, char *__statebuf,
size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));
extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));
struct random_data
{
int32_t *fptr;
int32_t *rptr;
int32_t *state;
int rand_type;
int rand_deg;
int rand_sep;
int32_t *end_ptr;
};
extern int random_r (struct random_data *__restrict __buf,
int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int srandom_r (unsigned int __seed, struct random_data *__buf)
throw () __attribute__ ((__nonnull__ (2)));
extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
size_t __statelen,
struct random_data *__restrict __buf)
throw () __attribute__ ((__nonnull__ (2, 4)));
extern int setstate_r (char *__restrict __statebuf,
struct random_data *__restrict __buf)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int rand (void) throw ();
extern void srand (unsigned int __seed) throw ();
extern int rand_r (unsigned int *__seed) throw ();
extern double drand48 (void) throw ();
extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));
extern long int lrand48 (void) throw ();
extern long int nrand48 (unsigned short int __xsubi[3])
throw () __attribute__ ((__nonnull__ (1)));
extern long int mrand48 (void) throw ();
extern long int jrand48 (unsigned short int __xsubi[3])
throw () __attribute__ ((__nonnull__ (1)));
extern void srand48 (long int __seedval) throw ();
extern unsigned short int *seed48 (unsigned short int __seed16v[3])
throw () __attribute__ ((__nonnull__ (1)));
extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));
struct drand48_data
{
unsigned short int __x[3];
unsigned short int __old_x[3];
unsigned short int __c;
unsigned short int __init;
__extension__ unsigned long long int __a;
};
extern int drand48_r (struct drand48_data *__restrict __buffer,
double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int erand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int lrand48_r (struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int nrand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int mrand48_r (struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int jrand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
throw () __attribute__ ((__nonnull__ (2)));
extern int seed48_r (unsigned short int __seed16v[3],
struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int lcong48_r (unsigned short int __param[7],
struct drand48_data *__buffer)
throw () __attribute__ ((__nonnull__ (1, 2)));
#define __malloc_and_calloc_defined
extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
extern void *calloc (size_t __nmemb, size_t __size)
throw () __attribute__ ((__malloc__)) ;
extern void *realloc (void *__ptr, size_t __size)
throw () __attribute__ ((__warn_unused_result__));
extern void free (void *__ptr) throw ();
extern void cfree (void *__ptr) throw ();
#define _ALLOCA_H 1
#define __need_size_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
extern "C" {
#undef alloca
extern void *alloca (size_t __size) throw ();
#define alloca(size) __builtin_alloca (size)
}
extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
throw () __attribute__ ((__nonnull__ (1))) ;
extern void *aligned_alloc (size_t __alignment, size_t __size)
throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) ;
extern void abort (void) throw () __attribute__ ((__noreturn__));
extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));
extern "C++" int at_quick_exit (void (*__func) (void))
throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));
extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
throw () __attribute__ ((__nonnull__ (1)));
extern void exit (int __status) throw () __attribute__ ((__noreturn__));
extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__));
extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));
extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ;
extern char *secure_getenv (const char *__name)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));
extern int setenv (const char *__name, const char *__value, int __replace)
throw () __attribute__ ((__nonnull__ (2)));
extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
extern int clearenv (void) throw ();
extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
extern int mkstemps64 (char *__template, int __suffixlen)
__attribute__ ((__nonnull__ (1))) ;
extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
extern int mkostemps (char *__template, int __suffixlen, int __flags)
__attribute__ ((__nonnull__ (1))) ;
extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
__attribute__ ((__nonnull__ (1))) ;
extern int system (const char *__command) ;
extern char *canonicalize_file_name (const char *__name)
throw () __attribute__ ((__nonnull__ (1))) ;
extern char *realpath (const char *__restrict __name,
char *__restrict __resolved) throw () ;
#define __COMPAR_FN_T
typedef int (*__compar_fn_t) (const void *, const void *);
typedef __compar_fn_t comparison_fn_t;
typedef int (*__compar_d_fn_t) (const void *, const void *, void *);
extern void *bsearch (const void *__key, const void *__base,
size_t __nmemb, size_t __size, __compar_fn_t __compar)
__attribute__ ((__nonnull__ (1, 2, 5))) ;
extern void qsort (void *__base, size_t __nmemb, size_t __size,
__compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
__compar_d_fn_t __compar, void *__arg)
__attribute__ ((__nonnull__ (1, 4)));
extern int abs (int __x) throw () __attribute__ ((__const__)) ;
extern long int labs (long int __x) throw () __attribute__ ((__const__)) ;
__extension__ extern long long int llabs (long long int __x)
throw () __attribute__ ((__const__)) ;
extern div_t div (int __numer, int __denom)
throw () __attribute__ ((__const__)) ;
extern ldiv_t ldiv (long int __numer, long int __denom)
throw () __attribute__ ((__const__)) ;
__extension__ extern lldiv_t lldiv (long long int __numer,
long long int __denom)
throw () __attribute__ ((__const__)) ;
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *gcvt (double __value, int __ndigit, char *__buf)
throw () __attribute__ ((__nonnull__ (3))) ;
extern char *qecvt (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign)
throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qfcvt (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign)
throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qgcvt (long double __value, int __ndigit, char *__buf)
throw () __attribute__ ((__nonnull__ (3))) ;
extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign, char *__restrict __buf,
size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign, char *__restrict __buf,
size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qecvt_r (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qfcvt_r (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int mblen (const char *__s, size_t __n) throw ();
extern int mbtowc (wchar_t *__restrict __pwc,
const char *__restrict __s, size_t __n) throw ();
extern int wctomb (char *__s, wchar_t __wchar) throw ();
extern size_t mbstowcs (wchar_t *__restrict __pwcs,
const char *__restrict __s, size_t __n) throw ();
extern size_t wcstombs (char *__restrict __s,
const wchar_t *__restrict __pwcs, size_t __n)
throw ();
extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) ;
extern int getsubopt (char **__restrict __optionp,
char *const *__restrict __tokens,
char **__restrict __valuep)
throw () __attribute__ ((__nonnull__ (1, 2, 3))) ;
extern void setkey (const char *__key) throw () __attribute__ ((__nonnull__ (1)));
extern int posix_openpt (int __oflag) ;
extern int grantpt (int __fd) throw ();
extern int unlockpt (int __fd) throw ();
extern char *ptsname (int __fd) throw () ;
extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2)));
extern int getpt (void);
extern int getloadavg (double __loadavg[], int __nelem)
throw () __attribute__ ((__nonnull__ (1)));
#undef __need_malloc_and_calloc
}
#undef abort
#undef abs
#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
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::div_t;
using ::ldiv_t;
using ::abort;
using ::abs;
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;
long
abs(long __i) ;
ldiv_t
div(long __i, long __j) ;
long long
abs(long long __x) ;
}
#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;
lldiv_t
div(long long __n, long long __d)
;
using ::lldiv;
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;
}
#define BOOST_HAS_STDINT_H
#define BOOST_HAS_GETTIMEOFDAY
#define BOOST_HAS_NANOSLEEP
#define BOOST_HAS_UNISTD_H
#define BOOST_HAS_NL_TYPES_H
#define BOOST_HAS_STDINT_H
#define BOOST_HAS_DIRENT_H
#define BOOST_HAS_SIGACTION
#define BOOST_HAS_PTHREADS
#define BOOST_HAS_NANOSLEEP
#define BOOST_HAS_CLOCK_GETTIME
#define BOOST_HAS_SCHED_YIELD
#define BOOST_HAS_GETTIMEOFDAY
#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
#define BOOST_HAS_LOG1P
#define BOOST_HAS_EXPM1
#define BOOST_HAS_PTHREAD_YIELD
#define BOOST_CONFIG_SUFFIX_HPP
#define BOOST_NO_MS_INT64_NUMERIC_LIMITS
#define BOOST_MSVC6_MEMBER_TEMPLATES
#define BOOST_HAS_PARTIAL_STD_ALLOCATOR
#define BOOST_PREVENT_MACRO_SUBSTITUTION
#define BOOST_USING_STD_MIN() using std::min
#define BOOST_USING_STD_MAX() using std::max
#define BOOST_STATIC_CONSTANT(type,assignment) static const type assignment
#define BOOST_USE_FACET(Type,loc) std::use_facet< Type >(loc)
#define BOOST_HAS_FACET(Type,loc) std::has_facet< Type >(loc)
#define BOOST_NESTED_TEMPLATE template
#define BOOST_UNREACHABLE_RETURN(x)
#define BOOST_DEDUCED_TYPENAME typename
#define BOOST_CTOR_TYPENAME typename
namespace boost{
__extension__ typedef long long long_long_type;
__extension__ typedef unsigned long long ulong_long_type;
}
namespace boost{
__extension__ typedef __int128 int128_type;
__extension__ typedef unsigned __int128 uint128_type;
}
#define BOOST_EXPLICIT_TEMPLATE_TYPE(t)
#define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
#define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t,v)
#define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t,v)
#define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t)
#define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
#define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t,v)
#define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t,v)
#define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X)
#define BOOST_DO_STRINGIZE(X) #X
#define BOOST_JOIN(X,Y) BOOST_DO_JOIN( X, Y )
#define BOOST_DO_JOIN(X,Y) BOOST_DO_JOIN2(X,Y)
#define BOOST_DO_JOIN2(X,Y) X ##Y
#define BOOST_GPU_ENABLED
#define BOOST_FORCEINLINE inline __attribute__ ((__always_inline__))
#define BOOST_NOINLINE __attribute__ ((__noinline__))
#define BOOST_ALIGNMENT(x) alignas(x)
#define BOOST_DEFAULTED_FUNCTION(fun,body) fun = default;
#define BOOST_DELETED_FUNCTION(fun) fun = delete;
#define BOOST_NO_0X_HDR_CODECVT
#define BOOST_NO_0X_HDR_THREAD
#define BOOST_NO_0X_HDR_TYPE_TRAITS
#define BOOST_NOEXCEPT noexcept
#define BOOST_NOEXCEPT_OR_NOTHROW noexcept
#define BOOST_NOEXCEPT_IF(Predicate) noexcept((Predicate))
#define BOOST_NOEXCEPT_EXPR(Expression) noexcept((Expression))
#define BOOST_FALLTHROUGH ((void)0)
#define BOOST_CONSTEXPR constexpr
#define BOOST_CONSTEXPR_OR_CONST constexpr
#define BOOST_STATIC_CONSTEXPR static BOOST_CONSTEXPR_OR_CONST
#define BOOST_VERSION_HPP
#define BOOST_VERSION 105500
#define BOOST_LIB_VERSION "1_55"
#define BOOST_ASIO_HAS_BOOST_CONFIG 1
#define BOOST_ASIO_HEADER_ONLY 1
#define BOOST_ASIO_DECL inline
#define BOOST_ASIO_HAS_MOVE 1
#define BOOST_ASIO_MOVE_ARG(type) type&&
#define BOOST_ASIO_MOVE_CAST(type) static_cast<type&&>
#define BOOST_ASIO_MOVE_CAST2(type1,type2) static_cast<type1, type2&&>
#define BOOST_ASIO_HAS_VARIADIC_TEMPLATES 1
#define BOOST_ASIO_HAS_CONSTEXPR 1
#define BOOST_ASIO_CONSTEXPR constexpr
#define BOOST_ASIO_HAS_STD_SYSTEM_ERROR 1
#define BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT BOOST_NOEXCEPT
#define BOOST_ASIO_HAS_STD_ARRAY 1
#define BOOST_ASIO_HAS_STD_SHARED_PTR 1
#define BOOST_ASIO_HAS_STD_ATOMIC 1
#define BOOST_ASIO_HAS_STD_CHRONO 1
#define BOOST_ASIO_HAS_BOOST_CHRONO 1
#define BOOST_ASIO_HAS_BOOST_DATE_TIME 1
#define BOOST_ASIO_HAS_STD_ADDRESSOF 1
#define BOOST_ASIO_HAS_STD_FUNCTION 1
#define BOOST_ASIO_HAS_STD_TYPE_TRAITS 1
#define BOOST_ASIO_HAS_CSTDINT 1
#define BOOST_ASIO_HAS_STD_THREAD 1
#define BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR 1
#define LINUX_VERSION_CODE 200707
#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
#define BOOST_ASIO_HAS_EPOLL 1
#define BOOST_ASIO_HAS_EVENTFD 1
#define BOOST_ASIO_HAS_TIMERFD 1
#define BOOST_ASIO_HAS_SERIAL_PORT 1
#define BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR 1
#define BOOST_ASIO_HAS_LOCAL_SOCKETS 1
#define BOOST_ASIO_HAS_SIGACTION 1
#define BOOST_ASIO_HAS_SIGNAL 1
#define BOOST_ASIO_HAS_THREADS 1
#define BOOST_ASIO_HAS_PTHREADS 1
#define BOOST_ASIO_PREVENT_MACRO_SUBSTITUTION
#define BOOST_ASIO_STATIC_CONSTANT(type,assignment) BOOST_STATIC_CONSTANT(type, assignment)
#define BOOST_ASIO_HAS_BOOST_ARRAY 1
#define BOOST_ASIO_HAS_BOOST_ASSERT 1
#define BOOST_ASIO_HAS_BOOST_LIMITS 1
#define BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION 1
#define BOOST_ASIO_HAS_BOOST_REGEX 1
#define BOOST_ASIO_HAS_BOOST_BIND 1
#define BOOST_ASIO_HAS_BOOST_WORKAROUND 1
#define BOOST_ASIO_HAS_HANDLER_HOOKS 1
#define BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION 1
#define BOOST_ASIO_THREAD_KEYWORD __thread
#define BOOST_ASIO_HAS_SSIZE_T 1
#define BOOST_ASIO_HANDLER_TYPE_HPP
namespace boost {
namespace asio {
template <typename Handler, typename Signature>
struct handler_type
{
typedef Handler type;
};
template <typename Handler, typename Signature>
struct handler_type<const Handler, Signature>
: handler_type<Handler, Signature> {};
template <typename Handler, typename Signature>
struct handler_type<volatile Handler, Signature>
: handler_type<Handler, Signature> {};
template <typename Handler, typename Signature>
struct handler_type<const volatile Handler, Signature>
: handler_type<Handler, Signature> {};
template <typename Handler, typename Signature>
struct handler_type<const Handler&, Signature>
: handler_type<Handler, Signature> {};
template <typename Handler, typename Signature>
struct handler_type<volatile Handler&, Signature>
: handler_type<Handler, Signature> {};
template <typename Handler, typename Signature>
struct handler_type<const volatile Handler&, Signature>
: handler_type<Handler, Signature> {};
template <typename Handler, typename Signature>
struct handler_type<Handler&, Signature>
: handler_type<Handler, Signature> {};
template <typename Handler, typename Signature>
struct handler_type<Handler&&, Signature>
: handler_type<Handler, Signature> {};
template <typename ReturnType, typename Signature>
struct handler_type<ReturnType(), Signature>
: handler_type<ReturnType(*)(), Signature> {};
template <typename ReturnType, typename Arg1, typename Signature>
struct handler_type<ReturnType(Arg1), Signature>
: handler_type<ReturnType(*)(Arg1), Signature> {};
template <typename ReturnType, typename Arg1, typename Arg2, typename Signature>
struct handler_type<ReturnType(Arg1, Arg2), Signature>
: handler_type<ReturnType(*)(Arg1, Arg2), Signature> {};
template <typename ReturnType, typename Arg1, typename Arg2, typename Arg3,
typename Signature>
struct handler_type<ReturnType(Arg1, Arg2, Arg3), Signature>
: handler_type<ReturnType(*)(Arg1, Arg2, Arg3), Signature> {};
template <typename ReturnType, typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Signature>
struct handler_type<ReturnType(Arg1, Arg2, Arg3, Arg4), Signature>
: handler_type<ReturnType(*)(Arg1, Arg2, Arg3, Arg4), Signature> {};
template <typename ReturnType, typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5, typename Signature>
struct handler_type<ReturnType(Arg1, Arg2, Arg3, Arg4, Arg5), Signature>
: handler_type<ReturnType(*)(Arg1, Arg2, Arg3, Arg4, Arg5), Signature> {};
}
}
#define BOOST_ASIO_HANDLER_TYPE(h,sig) typename handler_type<h, sig>::type
namespace boost {
namespace asio {
template <typename Handler>
class async_result
{
public:
typedef void type;
explicit async_result(Handler&)
;
type get()
;
};
namespace detail {
template <typename Handler, typename Signature>
struct async_result_init
{
explicit async_result_init(Handler&& orig_handler)
;
typename handler_type<Handler, Signature>::type handler;
async_result<typename handler_type<Handler, Signature>::type> result;
};
template <typename Handler, typename Signature>
struct async_result_type_helper
{
typedef typename async_result<
typename handler_type<Handler, Signature>::type
>::type type;
};
}
}
}
#define BOOST_ASIO_INITFN_RESULT_TYPE(h,sig) typename ::boost::asio::async_result< typename ::boost::asio::handler_type<h, sig>::type>::type
#define BOOST_ASIO_BASIC_DATAGRAM_SOCKET_HPP
#define BOOST_ASIO_BASIC_SOCKET_HPP
#define BOOST_ASIO_BASIC_IO_OBJECT_HPP
#define BOOST_ASIO_IO_SERVICE_HPP
#define _GLIBCXX_STDEXCEPT 1
#define __EXCEPTION__
#pragma GCC visibility push(default)
#define _GLIBCXX_ATOMIC_LOCK_FREE_H 1
#define ATOMIC_BOOL_LOCK_FREE __GCC_ATOMIC_BOOL_LOCK_FREE
#define ATOMIC_CHAR_LOCK_FREE __GCC_ATOMIC_CHAR_LOCK_FREE
#define ATOMIC_WCHAR_T_LOCK_FREE __GCC_ATOMIC_WCHAR_T_LOCK_FREE
#define ATOMIC_CHAR16_T_LOCK_FREE __GCC_ATOMIC_CHAR16_T_LOCK_FREE
#define ATOMIC_CHAR32_T_LOCK_FREE __GCC_ATOMIC_CHAR32_T_LOCK_FREE
#define ATOMIC_SHORT_LOCK_FREE __GCC_ATOMIC_SHORT_LOCK_FREE
#define ATOMIC_INT_LOCK_FREE __GCC_ATOMIC_INT_LOCK_FREE
#define ATOMIC_LONG_LOCK_FREE __GCC_ATOMIC_LONG_LOCK_FREE
#define ATOMIC_LLONG_LOCK_FREE __GCC_ATOMIC_LLONG_LOCK_FREE
#define ATOMIC_POINTER_LOCK_FREE __GCC_ATOMIC_POINTER_LOCK_FREE
extern "C++" {
namespace std
{
class exception
{
public:
exception() noexcept { }
virtual ~exception() noexcept;
virtual const char* what() const noexcept;
};
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__));
bool uncaught_exception() noexcept __attribute__ ((__pure__));
}
namespace __gnu_cxx
{
void __verbose_terminate_handler();
}
}
#pragma GCC visibility pop
#define _EXCEPTION_PTR_H
#pragma GCC visibility push(default)
#define _EXCEPTION_DEFINES_H 1
#define __try try
#define __catch(X) catch(X)
#define __throw_exception_again throw
extern "C++" {
namespace std
{
class type_info;
namespace __exception_ptr
{
class exception_ptr;
}
using __exception_ptr::exception_ptr;
exception_ptr current_exception() noexcept;
void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__));
namespace __exception_ptr
{
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);
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; }
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;
explicit operator bool() const
;
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__));
void
swap(exception_ptr& __lhs, exception_ptr& __rhs)
;
}
template<typename _Ex>
exception_ptr
make_exception_ptr(_Ex __ex) noexcept
{
try
{
throw __ex;
}
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
#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)
;
explicit _Nested_exception(_Except&& __ex)
;
};
template<typename _Tp,
bool __with_nested = !__is_base_of(nested_exception, _Tp)>
struct _Throw_with_nested_impl
{
template<typename _Up>
static void _S_throw(_Up&& __t)
;
};
template<typename _Tp>
struct _Throw_with_nested_impl<_Tp, false>
{
template<typename _Up>
static void _S_throw(_Up&& __t)
;
};
template<typename _Tp, bool = __is_class(_Tp)>
struct _Throw_with_nested_helper : _Throw_with_nested_impl<_Tp>
{ };
template<typename _Tp>
struct _Throw_with_nested_helper<_Tp, false>
: _Throw_with_nested_impl<_Tp, false>
{ };
template<typename _Tp>
struct _Throw_with_nested_helper<_Tp&, false>
: _Throw_with_nested_helper<_Tp>
{ };
template<typename _Tp>
struct _Throw_with_nested_helper<_Tp&&, false>
: _Throw_with_nested_helper<_Tp>
{ };
template<typename _Tp>
[[noreturn]]
inline void
throw_with_nested(_Tp&& __t)
{
_Throw_with_nested_helper<_Tp>::_S_throw(static_cast<_Tp&&>(__t));
}
template<typename _Tp, bool = __is_polymorphic(_Tp)>
struct _Rethrow_if_nested_impl
{
static void _S_rethrow(const _Tp& __t)
{
if (auto __tp = dynamic_cast<const nested_exception*>(&__t))
__tp->rethrow_nested();
}
};
template<typename _Tp>
struct _Rethrow_if_nested_impl<_Tp, false>
{
static void _S_rethrow(const _Tp&) { }
};
template<typename _Ex>
void
rethrow_if_nested(const _Ex& __ex)
;
}
}
#pragma GCC visibility pop
#define _GLIBCXX_STRING 1
#define _STRINGFWD_H 1
#define _MEMORYFWD_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename>
class allocator;
template<>
class allocator<void>;
template<typename, typename>
struct uses_allocator;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<class _CharT>
struct char_traits;
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_string;
template<> struct char_traits<char>;
typedef basic_string<char> string;
template<> struct char_traits<wchar_t>;
typedef basic_string<wchar_t> wstring;
template<> struct char_traits<char16_t>;
template<> struct char_traits<char32_t>;
typedef basic_string<char16_t> u16string;
typedef basic_string<char32_t> u32string;
}
#define _CHAR_TRAITS_H 1
#define _STL_ALGOBASE_H 1
#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__));
}
#define _CPP_TYPE_TRAITS_H 1
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
template<typename _Iterator, typename _Container>
class __normal_iterator;
}
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;
};
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_normal_iterator
{
enum { __value = 0 };
typedef __false_type __type;
};
template<typename _Iterator, typename _Container>
struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
_Container> >
{
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>
class move_iterator;
template<typename _Iterator>
struct __is_move_iterator< move_iterator<_Iterator> >
{
enum { __value = 1 };
typedef __true_type __type;
};
}
#define _EXT_TYPE_TRAITS 1
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>
bool
__is_null_pointer(_Type* __ptr)
;
template<typename _Type>
bool
__is_null_pointer(_Type)
;
bool
__is_null_pointer(std::nullptr_t)
;
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;
};
}
#define _EXT_NUMERIC_TRAITS 1
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 : 64) * 643L / 2136);
static const bool __is_signed = true;
static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18);
static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
};
template<typename _Value>
const int __numeric_traits_floating<_Value>::__max_digits10;
template<typename _Value>
const bool __numeric_traits_floating<_Value>::__is_signed;
template<typename _Value>
const int __numeric_traits_floating<_Value>::__digits10;
template<typename _Value>
const int __numeric_traits_floating<_Value>::__max_exponent10;
template<typename _Value>
struct __numeric_traits
: public __conditional_type<std::__is_integer<_Value>::__value,
__numeric_traits_integer<_Value>,
__numeric_traits_floating<_Value> >::__type
{ };
}
#undef __glibcxx_floating
#undef __glibcxx_max_digits10
#undef __glibcxx_digits10
#undef __glibcxx_max_exponent10
#define _STL_ITERATOR_BASE_TYPES_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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 { };
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;
};
template<typename _Tp> class __has_iterator_category_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::iterator_category>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_iterator_category : public __has_iterator_category_helper <typename remove_cv<_Tp>::type>::type { };
template<typename _Iterator,
bool = __has_iterator_category<_Iterator>::value>
struct __iterator_traits { };
template<typename _Iterator>
struct __iterator_traits<_Iterator, true>
{
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> { };
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>
typename iterator_traits<_Iter>::iterator_category
__iterator_category(const _Iter&)
;
template<typename _Iterator, bool _HasBase>
struct _Iter_base
{
typedef _Iterator iterator_type;
static iterator_type _S_base(_Iterator __it)
;
};
template<typename _Iterator>
struct _Iter_base<_Iterator, true>
{
typedef typename _Iterator::iterator_type iterator_type;
static iterator_type _S_base(_Iterator __it)
;
};
template<typename _InIter>
using _RequireInputIter = typename
enable_if<is_convertible<typename
iterator_traits<_InIter>::iterator_category,
input_iterator_tag>::value>::type;
}
#define _STL_ITERATOR_BASE_FUNCS_H 1
#define _GLIBCXX_DEBUG_MACRO_SWITCH_H 1
namespace std
{
namespace __debug { }
}
namespace __gnu_debug
{
using namespace std::__debug;
}
#define _GLIBCXX_DEBUG_ASSERT(_Condition)
#define _GLIBCXX_DEBUG_PEDASSERT(_Condition)
#define _GLIBCXX_DEBUG_ONLY(_Statement) ;
#define __glibcxx_requires_cond(_Cond,_Msg)
#define __glibcxx_requires_valid_range(_First,_Last)
#define __glibcxx_requires_non_empty_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_nonempty()
#define __glibcxx_requires_string(_String)
#define __glibcxx_requires_string_len(_String,_Len)
#define __glibcxx_requires_subscript(_N)
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _InputIterator>
typename iterator_traits<_InputIterator>::difference_type
__distance(_InputIterator __first, _InputIterator __last,
input_iterator_tag)
;
template<typename _RandomAccessIterator>
typename iterator_traits<_RandomAccessIterator>::difference_type
__distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
random_access_iterator_tag)
;
template<typename _InputIterator>
typename iterator_traits<_InputIterator>::difference_type
distance(_InputIterator __first, _InputIterator __last)
;
template<typename _InputIterator, typename _Distance>
void
__advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
;
template<typename _BidirectionalIterator, typename _Distance>
void
__advance(_BidirectionalIterator& __i, _Distance __n,
bidirectional_iterator_tag)
;
template<typename _RandomAccessIterator, typename _Distance>
void
__advance(_RandomAccessIterator& __i, _Distance __n,
random_access_iterator_tag)
;
template<typename _InputIterator, typename _Distance>
void
advance(_InputIterator& __i, _Distance __n)
;
template<typename _ForwardIterator>
_ForwardIterator
next(_ForwardIterator __x, typename
iterator_traits<_ForwardIterator>::difference_type __n = 1)
;
template<typename _BidirectionalIterator>
_BidirectionalIterator
prev(_BidirectionalIterator __x, typename
iterator_traits<_BidirectionalIterator>::difference_type __n = 1)
;
}
#define _STL_ITERATOR_H 1
#define _PTR_TRAITS_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp> class __has_element_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::element_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_element_type : public __has_element_type_helper <typename remove_cv<_Tp>::type>::type { };
template<typename _Tp> class __has_difference_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::difference_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_difference_type : public __has_difference_type_helper <typename remove_cv<_Tp>::type>::type { };
template<typename _Tp, bool = __has_element_type<_Tp>::value>
struct __ptrtr_elt_type;
template<typename _Tp>
struct __ptrtr_elt_type<_Tp, true>
{
typedef typename _Tp::element_type __type;
};
template<template<typename, typename...> class _SomePtr, typename _Tp,
typename... _Args>
struct __ptrtr_elt_type<_SomePtr<_Tp, _Args...>, false>
{
typedef _Tp __type;
};
template<typename _Tp, bool = __has_difference_type<_Tp>::value>
struct __ptrtr_diff_type
{
typedef typename _Tp::difference_type __type;
};
template<typename _Tp>
struct __ptrtr_diff_type<_Tp, false>
{
typedef ptrdiff_t __type;
};
template<typename _Ptr, typename _Up>
class __ptrtr_rebind_helper
{
template<typename _Ptr2, typename _Up2>
static constexpr true_type
_S_chk(typename _Ptr2::template rebind<_Up2>*);
template<typename, typename>
static constexpr false_type
_S_chk(...);
public:
using __type = decltype(_S_chk<_Ptr, _Up>(nullptr));
};
template<typename _Tp, typename _Up,
bool = __ptrtr_rebind_helper<_Tp, _Up>::__type::value>
struct __ptrtr_rebind;
template<typename _Tp, typename _Up>
struct __ptrtr_rebind<_Tp, _Up, true>
{
typedef typename _Tp::template rebind<_Up> __type;
};
template<template<typename, typename...> class _SomePtr, typename _Up,
typename _Tp, typename... _Args>
struct __ptrtr_rebind<_SomePtr<_Tp, _Args...>, _Up, false>
{
typedef _SomePtr<_Up, _Args...> __type;
};
template<typename _Tp, typename = typename remove_cv<_Tp>::type>
struct __ptrtr_not_void
{
typedef _Tp __type;
};
template<typename _Tp>
struct __ptrtr_not_void<_Tp, void>
{
struct __type { };
};
template<typename _Ptr>
class __ptrtr_pointer_to
{
typedef typename __ptrtr_elt_type<_Ptr>::__type __orig_type;
typedef typename __ptrtr_not_void<__orig_type>::__type __element_type;
public:
static _Ptr pointer_to(__element_type& __e)
;
};
template<typename _Ptr>
struct pointer_traits : __ptrtr_pointer_to<_Ptr>
{
typedef _Ptr pointer;
typedef typename __ptrtr_elt_type<_Ptr>::__type element_type;
typedef typename __ptrtr_diff_type<_Ptr>::__type difference_type;
template<typename _Up>
using rebind = typename __ptrtr_rebind<_Ptr, _Up>::__type;
};
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(typename __ptrtr_not_void<element_type>::__type& __r) noexcept
{ return std::addressof(__r); }
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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;
reverse_iterator() ;
explicit
reverse_iterator(iterator_type __x) ;
reverse_iterator(const reverse_iterator& __x) ;
template<typename _Iter>
reverse_iterator(const reverse_iterator<_Iter>& __x) ;
iterator_type
base() const
;
reference
operator*() const
;
pointer
operator->() const
;
reverse_iterator&
operator++()
;
reverse_iterator
operator++(int)
;
reverse_iterator&
operator--()
;
reverse_iterator
operator--(int)
;
reverse_iterator
operator+(difference_type __n) const
;
reverse_iterator&
operator+=(difference_type __n)
;
reverse_iterator
operator-(difference_type __n) const
;
reverse_iterator&
operator-=(difference_type __n)
;
reference
operator[](difference_type __n) const
;
};
template<typename _Iterator>
bool
operator==(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
bool
operator<(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
bool
operator!=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
bool
operator>(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
bool
operator<=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
bool
operator>=(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
typename reverse_iterator<_Iterator>::difference_type
operator-(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
;
template<typename _Iterator>
reverse_iterator<_Iterator>
operator+(typename reverse_iterator<_Iterator>::difference_type __n,
const reverse_iterator<_Iterator>& __x)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator==(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator<(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator!=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator>(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator<=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator>=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
;
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 _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) ;
back_insert_iterator&
operator=(const typename _Container::value_type& __value)
;
back_insert_iterator&
operator=(typename _Container::value_type&& __value)
;
back_insert_iterator&
operator*()
;
back_insert_iterator&
operator++()
;
back_insert_iterator
operator++(int)
;
};
template<typename _Container>
back_insert_iterator<_Container>
back_inserter(_Container& __x)
;
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) ;
front_insert_iterator&
operator=(const typename _Container::value_type& __value)
;
front_insert_iterator&
operator=(typename _Container::value_type&& __value)
;
front_insert_iterator&
operator*()
;
front_insert_iterator&
operator++()
;
front_insert_iterator
operator++(int)
;
};
template<typename _Container>
front_insert_iterator<_Container>
front_inserter(_Container& __x)
;
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) ;
insert_iterator&
operator=(const typename _Container::value_type& __value)
;
insert_iterator&
operator=(typename _Container::value_type&& __value)
;
insert_iterator&
operator*()
;
insert_iterator&
operator++()
;
insert_iterator&
operator++(int)
;
};
template<typename _Container, typename _Iterator>
insert_iterator<_Container>
inserter(_Container& __x, _Iterator __i)
;
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
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; }
};
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>
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() ;
explicit
move_iterator(iterator_type __i) ;
template<typename _Iter>
move_iterator(const move_iterator<_Iter>& __i) ;
iterator_type
base() const
;
reference
operator*() const
;
pointer
operator->() const
;
move_iterator&
operator++()
;
move_iterator
operator++(int)
;
move_iterator&
operator--()
;
move_iterator
operator--(int)
;
move_iterator
operator+(difference_type __n) const
;
move_iterator&
operator+=(difference_type __n)
;
move_iterator
operator-(difference_type __n) const
;
move_iterator&
operator-=(difference_type __n)
;
reference
operator[](difference_type __n) const
;
};
template<typename _IteratorL, typename _IteratorR>
bool
operator==(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
;
template<typename _Iterator>
bool
operator==(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator!=(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
;
template<typename _Iterator>
bool
operator!=(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator<(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
;
template<typename _Iterator>
bool
operator<(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator<=(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
;
template<typename _Iterator>
bool
operator<=(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator>(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
;
template<typename _Iterator>
bool
operator>(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
;
template<typename _IteratorL, typename _IteratorR>
bool
operator>=(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
;
template<typename _Iterator>
bool
operator>=(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __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 auto
operator-(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
-> decltype(__x.base() - __y.base())
{ return __x.base() - __y.base(); }
template<typename _Iterator>
move_iterator<_Iterator>
operator+(typename move_iterator<_Iterator>::difference_type __n,
const move_iterator<_Iterator>& __x)
;
template<typename _Iterator>
move_iterator<_Iterator>
make_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); }
}
#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)
#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
;
};
_Iter_less_iter
__iter_less_iter()
;
struct _Iter_less_val
{
template<typename _Iterator, typename _Value>
bool
operator()(_Iterator __it, _Value& __val) const
;
};
_Iter_less_val
__iter_less_val()
;
_Iter_less_val
__iter_comp_val(_Iter_less_iter)
;
struct _Val_less_iter
{
template<typename _Value, typename _Iterator>
bool
operator()(_Value& __val, _Iterator __it) const
;
};
_Val_less_iter
__val_less_iter()
;
_Val_less_iter
__val_comp_iter(_Iter_less_iter)
;
struct _Iter_equal_to_iter
{
template<typename _Iterator1, typename _Iterator2>
bool
operator()(_Iterator1 __it1, _Iterator2 __it2) const
;
};
_Iter_equal_to_iter
__iter_equal_to_iter()
;
struct _Iter_equal_to_val
{
template<typename _Iterator, typename _Value>
bool
operator()(_Iterator __it, _Value& __val) const
;
};
_Iter_equal_to_val
__iter_equal_to_val()
;
_Iter_equal_to_val
__iter_comp_val(_Iter_equal_to_iter)
;
template<typename _Compare>
struct _Iter_comp_iter
{
_Compare _M_comp;
_Iter_comp_iter(_Compare __comp)
;
template<typename _Iterator1, typename _Iterator2>
bool
operator()(_Iterator1 __it1, _Iterator2 __it2)
;
};
template<typename _Compare>
_Iter_comp_iter<_Compare>
__iter_comp_iter(_Compare __comp)
;
template<typename _Compare>
struct _Iter_comp_val
{
_Compare _M_comp;
_Iter_comp_val(_Compare __comp)
;
template<typename _Iterator, typename _Value>
bool
operator()(_Iterator __it, _Value& __val)
;
};
template<typename _Compare>
_Iter_comp_val<_Compare>
__iter_comp_val(_Compare __comp)
;
template<typename _Compare>
_Iter_comp_val<_Compare>
__iter_comp_val(_Iter_comp_iter<_Compare> __comp)
;
template<typename _Compare>
struct _Val_comp_iter
{
_Compare _M_comp;
_Val_comp_iter(_Compare __comp)
;
template<typename _Value, typename _Iterator>
bool
operator()(_Value& __val, _Iterator __it)
;
};
template<typename _Compare>
_Val_comp_iter<_Compare>
__val_comp_iter(_Compare __comp)
;
template<typename _Compare>
_Val_comp_iter<_Compare>
__val_comp_iter(_Iter_comp_iter<_Compare> __comp)
;
template<typename _Value>
struct _Iter_equals_val
{
_Value& _M_value;
_Iter_equals_val(_Value& __value)
;
template<typename _Iterator>
bool
operator()(_Iterator __it)
;
};
template<typename _Value>
_Iter_equals_val<_Value>
__iter_equals_val(_Value& __val)
;
template<typename _Iterator1>
struct _Iter_equals_iter
{
typename std::iterator_traits<_Iterator1>::reference _M_ref;
_Iter_equals_iter(_Iterator1 __it1)
;
template<typename _Iterator2>
bool
operator()(_Iterator2 __it2)
;
};
template<typename _Iterator>
_Iter_equals_iter<_Iterator>
__iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
;
template<typename _Predicate>
struct _Iter_pred
{
_Predicate _M_pred;
_Iter_pred(_Predicate __pred)
;
template<typename _Iterator>
bool
operator()(_Iterator __it)
;
};
template<typename _Predicate>
_Iter_pred<_Predicate>
__pred_iter(_Predicate __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)
;
template<typename _Iterator>
bool
operator()(_Iterator __it)
;
};
template<typename _Compare, typename _Value>
_Iter_comp_to_val<_Compare, _Value>
__iter_comp_val(_Compare __comp, _Value &__val)
;
template<typename _Compare, typename _Iterator1>
struct _Iter_comp_to_iter
{
_Compare _M_comp;
typename std::iterator_traits<_Iterator1>::reference _M_ref;
_Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
;
template<typename _Iterator2>
bool
operator()(_Iterator2 __it2)
;
};
template<typename _Compare, typename _Iterator>
_Iter_comp_to_iter<_Compare, _Iterator>
__iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
;
template<typename _Predicate>
struct _Iter_negate
{
_Predicate _M_pred;
_Iter_negate(_Predicate __pred)
;
template<typename _Iterator>
bool
operator()(_Iterator __it)
;
};
template<typename _Predicate>
_Iter_negate<_Predicate>
__negate(_Iter_pred<_Predicate> __pred)
;
}
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _ForwardIterator1, typename _ForwardIterator2>
void
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
;
template<typename _ForwardIterator1, typename _ForwardIterator2>
_ForwardIterator2
swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2)
;
template<typename _Tp>
const _Tp&
min(const _Tp& __a, const _Tp& __b)
;
template<typename _Tp>
const _Tp&
max(const _Tp& __a, const _Tp& __b)
;
template<typename _Tp, typename _Compare>
const _Tp&
min(const _Tp& __a, const _Tp& __b, _Compare __comp)
;
template<typename _Tp, typename _Compare>
const _Tp&
max(const _Tp& __a, const _Tp& __b, _Compare __comp)
;
template<typename _Iterator>
struct _Niter_base
: _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value>
{ };
template<typename _Iterator>
typename _Niter_base<_Iterator>::iterator_type
__niter_base(_Iterator __it)
;
template<typename _Iterator>
struct _Miter_base
: _Iter_base<_Iterator, __is_move_iterator<_Iterator>::__value>
{ };
template<typename _Iterator>
typename _Miter_base<_Iterator>::iterator_type
__miter_base(_Iterator __it)
;
template<bool, bool, typename>
struct __copy_move
{
template<typename _II, typename _OI>
static _OI
__copy_m(_II __first, _II __last, _OI __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)
;
};
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)
;
};
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)
;
};
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)
;
};
template<bool _IsMove, typename _II, typename _OI>
_OI
__copy_move_a(_II __first, _II __last, _OI __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>
_OI
__copy_move_a2(_II __first, _II __last, _OI __result)
;
template<typename _II, typename _OI>
_OI
copy(_II __first, _II __last, _OI __result)
;
template<typename _II, typename _OI>
_OI
move(_II __first, _II __last, _OI __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)
;
};
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)
;
};
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)
;
};
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)
;
};
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)
;
};
template<bool _IsMove, typename _BI1, typename _BI2>
_BI2
__copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
;
template<bool _IsMove, typename _BI1, typename _BI2>
_BI2
__copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
;
template<typename _BI1, typename _BI2>
_BI2
copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
;
template<typename _BI1, typename _BI2>
_BI2
move_backward(_BI1 __first, _BI1 __last, _BI2 __result)
;
#define _GLIBCXX_MOVE_BACKWARD3(_Tp,_Up,_Vp) std::move_backward(_Tp, _Up, _Vp)
template<typename _ForwardIterator, typename _Tp>
typename
__gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
__fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __value)
;
template<typename _ForwardIterator, typename _Tp>
typename
__gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
__fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __value)
;
template<typename _Tp>
typename
__gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
__fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)
;
template<typename _ForwardIterator, typename _Tp>
void
fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
;
template<typename _OutputIterator, typename _Size, typename _Tp>
typename
__gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
;
template<typename _OutputIterator, typename _Size, typename _Tp>
typename
__gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
;
template<typename _Size, typename _Tp>
typename
__gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
__fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
;
template<typename _OI, typename _Size, typename _Tp>
_OI
fill_n(_OI __first, _Size __n, const _Tp& __value)
;
template<bool _BoolType>
struct __equal
{
template<typename _II1, typename _II2>
static bool
equal(_II1 __first1, _II1 __last1, _II2 __first2)
;
};
template<>
struct __equal<true>
{
template<typename _Tp>
static bool
equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
;
};
template<typename _II1, typename _II2>
bool
__equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
;
template<typename, typename>
struct __lc_rai
{
template<typename _II1, typename _II2>
static _II1
__newlast1(_II1, _II1 __last1, _II2, _II2)
;
template<typename _II>
static bool
__cnd2(_II __first, _II __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)
;
template<typename _RAI>
static bool
__cnd2(_RAI, _RAI)
;
};
template<typename _II1, typename _II2, typename _Compare>
bool
__lexicographical_compare_impl(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2,
_Compare __comp)
;
template<bool _BoolType>
struct __lexicographical_compare
{
template<typename _II1, typename _II2>
static bool __lc(_II1, _II1, _II2, _II2);
};
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)
;
};
template<typename _II1, typename _II2>
bool
__lexicographical_compare_aux(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
_ForwardIterator
__lower_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
;
template<typename _ForwardIterator, typename _Tp>
_ForwardIterator
lower_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __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); }
template<typename _II1, typename _II2>
bool
equal(_II1 __first1, _II1 __last1, _II2 __first2)
;
template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
bool
equal(_IIter1 __first1, _IIter1 __last1,
_IIter2 __first2, _BinaryPredicate __binary_pred)
;
template<typename _II1, typename _II2>
bool
lexicographical_compare(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2)
;
template<typename _II1, typename _II2, typename _Compare>
bool
lexicographical_compare(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2, _Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _BinaryPredicate>
pair<_InputIterator1, _InputIterator2>
__mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _BinaryPredicate __binary_pred)
;
template<typename _InputIterator1, typename _InputIterator2>
pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _BinaryPredicate>
pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _BinaryPredicate __binary_pred)
;
}
#define _GLIBCXX_POSTYPES_H 1
#define _WCHAR_H 1
#define __need___FILE
#define __need_FILE
struct _IO_FILE;
typedef struct _IO_FILE FILE;
#define __FILE_defined 1
#undef __need_FILE
typedef struct _IO_FILE __FILE;
#define ____FILE_defined 1
#undef __need___FILE
#define __need___va_list
#undef __need___va_list
#define __GNUC_VA_LIST
typedef __builtin_va_list __gnuc_va_list;
#define _BITS_WCHAR_H 1
#define __WCHAR_MAX __WCHAR_MAX__
#define __WCHAR_MIN __WCHAR_MIN__
#define __need_size_t
#define __need_wchar_t
#define __need_NULL
#undef __need_wint_t
#define __need_wint_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#define _WINT_T
typedef unsigned int wint_t;
#undef __need_wint_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define __CORRECT_ISO_CPP_WCHAR_H_PROTO
#define ____mbstate_t_defined 1
typedef struct
{
int __count;
union
{
unsigned int __wch;
char __wchb[4];
} __value;
} __mbstate_t;
#undef __need_mbstate_t
typedef __mbstate_t mbstate_t;
#define __mbstate_t_defined 1
#define WCHAR_MIN __WCHAR_MIN
#define WCHAR_MAX __WCHAR_MAX
#define WEOF (0xffffffffu)
extern "C" {
struct tm;
extern wchar_t *wcscpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src) throw ();
extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw ();
extern wchar_t *wcscat (wchar_t *__restrict __dest,
const wchar_t *__restrict __src) throw ();
extern wchar_t *wcsncat (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw ();
extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
throw () __attribute__ ((__pure__));
extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw () __attribute__ ((__pure__));
extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw ();
extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2,
size_t __n) throw ();
extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
__locale_t __loc) throw ();
extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
size_t __n, __locale_t __loc) throw ();
extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw ();
extern size_t wcsxfrm (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n) throw ();
extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2,
__locale_t __loc) throw ();
extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2,
size_t __n, __locale_t __loc) throw ();
extern wchar_t *wcsdup (const wchar_t *__s) throw () __attribute__ ((__malloc__));
extern "C++" wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcschr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcschr") __attribute__ ((__pure__));
extern "C++" wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcsrchr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
throw () __asm ("wcsrchr") __attribute__ ((__pure__));
extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc)
throw () __attribute__ ((__pure__));
extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject)
throw () __attribute__ ((__pure__));
extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept)
throw () __attribute__ ((__pure__));
extern "C++" wchar_t *wcspbrk (wchar_t *__wcs, const wchar_t *__accept)
throw () __asm ("wcspbrk") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcspbrk (const wchar_t *__wcs,
const wchar_t *__accept)
throw () __asm ("wcspbrk") __attribute__ ((__pure__));
extern "C++" wchar_t *wcsstr (wchar_t *__haystack, const wchar_t *__needle)
throw () __asm ("wcsstr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcsstr (const wchar_t *__haystack,
const wchar_t *__needle)
throw () __asm ("wcsstr") __attribute__ ((__pure__));
extern wchar_t *wcstok (wchar_t *__restrict __s,
const wchar_t *__restrict __delim,
wchar_t **__restrict __ptr) throw ();
extern size_t wcslen (const wchar_t *__s) throw () __attribute__ ((__pure__));
extern "C++" wchar_t *wcswcs (wchar_t *__haystack, const wchar_t *__needle)
throw () __asm ("wcswcs") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcswcs (const wchar_t *__haystack,
const wchar_t *__needle)
throw () __asm ("wcswcs") __attribute__ ((__pure__));
extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
throw () __attribute__ ((__pure__));
extern "C++" wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n)
throw () __asm ("wmemchr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wmemchr (const wchar_t *__s, wchar_t __c,
size_t __n)
throw () __asm ("wmemchr") __attribute__ ((__pure__));
extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw () __attribute__ ((__pure__));
extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n) throw ();
extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw ();
extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();
extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n)
throw ();
extern wint_t btowc (int __c) throw ();
extern int wctob (wint_t __c) throw ();
extern int mbsinit (const mbstate_t *__ps) throw () __attribute__ ((__pure__));
extern size_t mbrtowc (wchar_t *__restrict __pwc,
const char *__restrict __s, size_t __n,
mbstate_t *__restrict __p) throw ();
extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
mbstate_t *__restrict __ps) throw ();
extern size_t __mbrlen (const char *__restrict __s, size_t __n,
mbstate_t *__restrict __ps) throw ();
extern size_t mbrlen (const char *__restrict __s, size_t __n,
mbstate_t *__restrict __ps) throw ();
extern size_t mbsrtowcs (wchar_t *__restrict __dst,
const char **__restrict __src, size_t __len,
mbstate_t *__restrict __ps) throw ();
extern size_t wcsrtombs (char *__restrict __dst,
const wchar_t **__restrict __src, size_t __len,
mbstate_t *__restrict __ps) throw ();
extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
const char **__restrict __src, size_t __nmc,
size_t __len, mbstate_t *__restrict __ps) throw ();
extern size_t wcsnrtombs (char *__restrict __dst,
const wchar_t **__restrict __src,
size_t __nwc, size_t __len,
mbstate_t *__restrict __ps) throw ();
extern int wcwidth (wchar_t __c) throw ();
extern int wcswidth (const wchar_t *__s, size_t __n) throw ();
extern double wcstod (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern float wcstof (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern long double wcstold (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern long int wcstol (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base) throw ();
extern unsigned long int wcstoul (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
__extension__
extern long long int wcstoll (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
__extension__
extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base) throw ();
__extension__
extern long long int wcstoq (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
__extension__
extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base) throw ();
extern long int wcstol_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base,
__locale_t __loc) throw ();
extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, __locale_t __loc) throw ();
__extension__
extern long long int wcstoll_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, __locale_t __loc) throw ();
__extension__
extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, __locale_t __loc)
throw ();
extern double wcstod_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, __locale_t __loc)
throw ();
extern float wcstof_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, __locale_t __loc)
throw ();
extern long double wcstold_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
__locale_t __loc) throw ();
extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src) throw ();
extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw ();
extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();
extern int fwide (__FILE *__fp, int __mode) throw ();
extern int fwprintf (__FILE *__restrict __stream,
const wchar_t *__restrict __format, ...)
;
extern int wprintf (const wchar_t *__restrict __format, ...)
;
extern int swprintf (wchar_t *__restrict __s, size_t __n,
const wchar_t *__restrict __format, ...)
throw () ;
extern int vfwprintf (__FILE *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vwprintf (const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vswprintf (wchar_t *__restrict __s, size_t __n,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
throw () ;
extern int fwscanf (__FILE *__restrict __stream,
const wchar_t *__restrict __format, ...)
;
extern int wscanf (const wchar_t *__restrict __format, ...)
;
extern int swscanf (const wchar_t *__restrict __s,
const wchar_t *__restrict __format, ...)
throw () ;
extern int vfwscanf (__FILE *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vwscanf (const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vswscanf (const wchar_t *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
throw () ;
extern wint_t fgetwc (__FILE *__stream);
extern wint_t getwc (__FILE *__stream);
extern wint_t getwchar (void);
extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
extern wint_t putwc (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar (wchar_t __wc);
extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
__FILE *__restrict __stream);
extern int fputws (const wchar_t *__restrict __ws,
__FILE *__restrict __stream);
extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
extern wint_t getwc_unlocked (__FILE *__stream);
extern wint_t getwchar_unlocked (void);
extern wint_t fgetwc_unlocked (__FILE *__stream);
extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar_unlocked (wchar_t __wc);
extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
__FILE *__restrict __stream);
extern int fputws_unlocked (const wchar_t *__restrict __ws,
__FILE *__restrict __stream);
extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
const wchar_t *__restrict __format,
const struct tm *__restrict __tp) throw ();
extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
const wchar_t *__restrict __format,
const struct tm *__restrict __tp,
__locale_t __loc) throw ();
}
#undef __need_mbstate_t
#undef __need_wint_t
#define _GLIBCXX_CWCHAR 1
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;
}
#undef wcstold
#undef wcstoll
#undef wcstoull
namespace __gnu_cxx
{
using ::wcstold;
using ::wcstoll;
using ::wcstoull;
}
namespace std
{
using ::__gnu_cxx::wcstold;
using ::__gnu_cxx::wcstoll;
using ::__gnu_cxx::wcstoull;
}
namespace std
{
using std::wcstof;
using std::vfwscanf;
using std::vswscanf;
using std::vwscanf;
using std::wcstold;
using std::wcstoll;
using std::wcstoull;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
typedef long streamoff;
typedef ptrdiff_t streamsize;
template<typename _StateT>
class fpos
{
private:
streamoff _M_off;
_StateT _M_state;
public:
fpos() ;
fpos(streamoff __off) ;
operator streamoff() const ;
void
state(_StateT __st)
;
_StateT
state() const
;
fpos&
operator+=(streamoff __off)
;
fpos&
operator-=(streamoff __off)
;
fpos
operator+(streamoff __off) const
;
fpos
operator-(streamoff __off) const
;
streamoff
operator-(const fpos& __other) const
;
};
template<typename _StateT>
bool
operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
;
template<typename _StateT>
bool
operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
;
typedef fpos<mbstate_t> streampos;
typedef fpos<mbstate_t> wstreampos;
typedef fpos<mbstate_t> u16streampos;
typedef fpos<mbstate_t> u32streampos;
}
#undef __need_mbstate_t
#undef __need_wint_t
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
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;
};
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)
;
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()); }
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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)
{ 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)
{ 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)
{ return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n)); }
static char_type*
copy(char_type* __s1, const char_type* __s2, size_t __n)
{ return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n)); }
static char_type*
assign(char_type* __s, size_t __n, char_type __a)
{ return static_cast<char_type*>(__builtin_memset(__s, __a, __n)); }
static constexpr char_type
to_char_type(const int_type& __c) noexcept
{ return static_cast<char_type>(__c); }
static constexpr int_type
to_int_type(const char_type& __c) noexcept
{ return static_cast<int_type>(static_cast<unsigned char>(__c)); }
static constexpr bool
eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
{ return __c1 == __c2; }
static constexpr int_type
eof() noexcept
{ return static_cast<int_type>(-1); }
static constexpr int_type
not_eof(const int_type& __c) noexcept
{ return (__c == eof()) ? 0 : __c; }
};
template<>
struct char_traits<wchar_t>
{
typedef wchar_t char_type;
typedef wint_t int_type;
typedef streamoff off_type;
typedef wstreampos pos_type;
typedef mbstate_t state_type;
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)
{ 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)
{ return wmemchr(__s, __a, __n); }
static char_type*
move(char_type* __s1, const char_type* __s2, size_t __n)
{ return wmemmove(__s1, __s2, __n); }
static char_type*
copy(char_type* __s1, const char_type* __s2, size_t __n)
{ return wmemcpy(__s1, __s2, __n); }
static char_type*
assign(char_type* __s, size_t __n, char_type __a)
{ return wmemset(__s, __a, __n); }
static constexpr char_type
to_char_type(const int_type& __c) noexcept
{ return char_type(__c); }
static constexpr int_type
to_int_type(const char_type& __c) noexcept
{ return int_type(__c); }
static constexpr bool
eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
{ return __c1 == __c2; }
static constexpr int_type
eof() noexcept
{ return static_cast<int_type>((0xffffffffu)); }
static constexpr int_type
not_eof(const int_type& __c) noexcept
{ return eq_int_type(__c, eof()) ? 0 : __c; }
};
}
#define _GLIBCXX_CSTDINT 1
#undef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS
#undef __STDC_CONSTANT_MACROS
#define __STDC_CONSTANT_MACROS
#define _STDINT_H 1
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
typedef unsigned char uint8_t;
typedef unsigned short int uint16_t;
typedef unsigned int uint32_t;
#define __uint32_t_defined
typedef unsigned long int uint64_t;
typedef signed char int_least8_t;
typedef short int int_least16_t;
typedef int int_least32_t;
typedef long int int_least64_t;
typedef unsigned char uint_least8_t;
typedef unsigned short int uint_least16_t;
typedef unsigned int uint_least32_t;
typedef unsigned long int uint_least64_t;
typedef signed char int_fast8_t;
typedef long int int_fast16_t;
typedef long int int_fast32_t;
typedef long int int_fast64_t;
typedef unsigned char uint_fast8_t;
typedef unsigned long int uint_fast16_t;
typedef unsigned long int uint_fast32_t;
typedef unsigned long int uint_fast64_t;
typedef unsigned long int uintptr_t;
typedef long int intmax_t;
typedef unsigned long int uintmax_t;
#define __INT64_C(c) c ## L
#define __UINT64_C(c) c ## UL
#define INT8_MIN (-128)
#define INT16_MIN (-32767-1)
#define INT32_MIN (-2147483647-1)
#define INT64_MIN (-__INT64_C(9223372036854775807)-1)
#define INT8_MAX (127)
#define INT16_MAX (32767)
#define INT32_MAX (2147483647)
#define INT64_MAX (__INT64_C(9223372036854775807))
#define UINT8_MAX (255)
#define UINT16_MAX (65535)
#define UINT32_MAX (4294967295U)
#define UINT64_MAX (__UINT64_C(18446744073709551615))
#define INT_LEAST8_MIN (-128)
#define INT_LEAST16_MIN (-32767-1)
#define INT_LEAST32_MIN (-2147483647-1)
#define INT_LEAST64_MIN (-__INT64_C(9223372036854775807)-1)
#define INT_LEAST8_MAX (127)
#define INT_LEAST16_MAX (32767)
#define INT_LEAST32_MAX (2147483647)
#define INT_LEAST64_MAX (__INT64_C(9223372036854775807))
#define UINT_LEAST8_MAX (255)
#define UINT_LEAST16_MAX (65535)
#define UINT_LEAST32_MAX (4294967295U)
#define UINT_LEAST64_MAX (__UINT64_C(18446744073709551615))
#define INT_FAST8_MIN (-128)
#define INT_FAST16_MIN (-9223372036854775807L-1)
#define INT_FAST32_MIN (-9223372036854775807L-1)
#define INT_FAST64_MIN (-__INT64_C(9223372036854775807)-1)
#define INT_FAST8_MAX (127)
#define INT_FAST16_MAX (9223372036854775807L)
#define INT_FAST32_MAX (9223372036854775807L)
#define INT_FAST64_MAX (__INT64_C(9223372036854775807))
#define UINT_FAST8_MAX (255)
#define UINT_FAST16_MAX (18446744073709551615UL)
#define UINT_FAST32_MAX (18446744073709551615UL)
#define UINT_FAST64_MAX (__UINT64_C(18446744073709551615))
#define INTPTR_MIN (-9223372036854775807L-1)
#define INTPTR_MAX (9223372036854775807L)
#define UINTPTR_MAX (18446744073709551615UL)
#define INTMAX_MIN (-__INT64_C(9223372036854775807)-1)
#define INTMAX_MAX (__INT64_C(9223372036854775807))
#define UINTMAX_MAX (__UINT64_C(18446744073709551615))
#define PTRDIFF_MIN (-9223372036854775807L-1)
#define PTRDIFF_MAX (9223372036854775807L)
#define SIG_ATOMIC_MIN (-2147483647-1)
#define SIG_ATOMIC_MAX (2147483647)
#define SIZE_MAX (18446744073709551615UL)
#define WINT_MIN (0u)
#define WINT_MAX (4294967295u)
#define INT8_C(c) c
#define INT16_C(c) c
#define INT32_C(c) c
#define INT64_C(c) c ## L
#define UINT8_C(c) c
#define UINT16_C(c) c
#define UINT32_C(c) c ## U
#define UINT64_C(c) c ## UL
#define INTMAX_C(c) c ## L
#define UINTMAX_C(c) c ## UL
#define _GCC_WRAP_STDINT_H
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;
}
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)
{
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)
{
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)
{
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)
{
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; }
};
}
#define _ALLOCATOR_H 1
#define _GLIBCXX_CXX_ALLOCATOR_H 1
#define _MT_ALLOCATOR_H 1
#define _NEW
#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 { };
extern const nothrow_t nothrow;
typedef void (*new_handler)();
new_handler set_new_handler(new_handler) throw();
new_handler get_new_handler() noexcept;
}
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__));
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 { }
}
#pragma GCC visibility pop
#define _GLIBCXX_ATOMICITY_H 1
#define _GLIBCXX_GCC_GTHR_H
#pragma GCC visibility push(default)
#define _GLIBCXX_GTHREAD_USE_WEAK 1
#define _GLIBCXX_GCC_GTHR_POSIX_H
#define __GTHREADS 1
#define __GTHREADS_CXX0X 1
#define _PTHREAD_H 1
#define _SCHED_H 1
#define __need_size_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define __need_time_t
#define __need_timespec
#undef __need_clock_t
#undef __need_time_t
#undef __clockid_time_t
#undef __need_timer_t
#undef __need_timespec
#define SCHED_OTHER 0
#define SCHED_FIFO 1
#define SCHED_RR 2
#define SCHED_BATCH 3
#define SCHED_IDLE 5
#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_NEWUTS 0x04000000
#define CLONE_NEWIPC 0x08000000
#define CLONE_NEWUSER 0x10000000
#define CLONE_NEWPID 0x20000000
#define CLONE_NEWNET 0x40000000
#define CLONE_IO 0x80000000
struct sched_param
{
int __sched_priority;
};
extern "C" {
extern int clone (int (*__fn) (void *__arg), void *__child_stack,
int __flags, void *__arg, ...) throw ();
extern int unshare (int __flags) throw ();
extern int sched_getcpu (void) throw ();
extern int setns (int __fd, int __nstype) throw ();
}
#define __defined_schedparam 1
struct __sched_param
{
int __sched_priority;
};
#undef __need_schedparam
#define __cpu_set_t_defined
#define __CPU_SETSIZE 1024
#define __NCPUBITS (8 * sizeof (__cpu_mask))
typedef unsigned long int __cpu_mask;
#define __CPUELT(cpu) ((cpu) / __NCPUBITS)
#define __CPUMASK(cpu) ((__cpu_mask) 1 << ((cpu) % __NCPUBITS))
typedef struct
{
__cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
} cpu_set_t;
#define __CPU_ZERO_S(setsize,cpusetp) do __builtin_memset (cpusetp, '\0', setsize); while (0)
#define __CPU_SET_S(cpu,setsize,cpusetp) (__extension__ ({ size_t __cpu = (cpu); __cpu / 8 < (setsize) ? (((__cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] |= __CPUMASK (__cpu)) : 0; }))
#define __CPU_CLR_S(cpu,setsize,cpusetp) (__extension__ ({ size_t __cpu = (cpu); __cpu / 8 < (setsize) ? (((__cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] &= ~__CPUMASK (__cpu)) : 0; }))
#define __CPU_ISSET_S(cpu,setsize,cpusetp) (__extension__ ({ size_t __cpu = (cpu); __cpu / 8 < (setsize) ? ((((const __cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] & __CPUMASK (__cpu))) != 0 : 0; }))
#define __CPU_COUNT_S(setsize,cpusetp) __sched_cpucount (setsize, cpusetp)
#define __CPU_EQUAL_S(setsize,cpusetp1,cpusetp2) (__builtin_memcmp (cpusetp1, cpusetp2, setsize) == 0)
#define __CPU_OP_S(setsize,destset,srcset1,srcset2,op) (__extension__ ({ cpu_set_t *__dest = (destset); const __cpu_mask *__arr1 = (srcset1)->__bits; const __cpu_mask *__arr2 = (srcset2)->__bits; size_t __imax = (setsize) / sizeof (__cpu_mask); size_t __i; for (__i = 0; __i < __imax; ++__i) ((__cpu_mask *) __dest->__bits)[__i] = __arr1[__i] op __arr2[__i]; __dest; }))
#define __CPU_ALLOC_SIZE(count) ((((count) + __NCPUBITS - 1) / __NCPUBITS) * sizeof (__cpu_mask))
#define __CPU_ALLOC(count) __sched_cpualloc (count)
#define __CPU_FREE(cpuset) __sched_cpufree (cpuset)
extern "C" {
extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
throw ();
extern cpu_set_t *__sched_cpualloc (size_t __count) throw () ;
extern void __sched_cpufree (cpu_set_t *__set) throw ();
}
#define sched_priority __sched_priority
extern "C" {
extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
throw ();
extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();
extern int sched_setscheduler (__pid_t __pid, int __policy,
const struct sched_param *__param) throw ();
extern int sched_getscheduler (__pid_t __pid) throw ();
extern int sched_yield (void) throw ();
extern int sched_get_priority_max (int __algorithm) throw ();
extern int sched_get_priority_min (int __algorithm) throw ();
extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();
#define CPU_SETSIZE __CPU_SETSIZE
#define CPU_SET(cpu,cpusetp) __CPU_SET_S (cpu, sizeof (cpu_set_t), cpusetp)
#define CPU_CLR(cpu,cpusetp) __CPU_CLR_S (cpu, sizeof (cpu_set_t), cpusetp)
#define CPU_ISSET(cpu,cpusetp) __CPU_ISSET_S (cpu, sizeof (cpu_set_t), cpusetp)
#define CPU_ZERO(cpusetp) __CPU_ZERO_S (sizeof (cpu_set_t), cpusetp)
#define CPU_COUNT(cpusetp) __CPU_COUNT_S (sizeof (cpu_set_t), cpusetp)
#define CPU_SET_S(cpu,setsize,cpusetp) __CPU_SET_S (cpu, setsize, cpusetp)
#define CPU_CLR_S(cpu,setsize,cpusetp) __CPU_CLR_S (cpu, setsize, cpusetp)
#define CPU_ISSET_S(cpu,setsize,cpusetp) __CPU_ISSET_S (cpu, setsize, cpusetp)
#define CPU_ZERO_S(setsize,cpusetp) __CPU_ZERO_S (setsize, cpusetp)
#define CPU_COUNT_S(setsize,cpusetp) __CPU_COUNT_S (setsize, cpusetp)
#define CPU_EQUAL(cpusetp1,cpusetp2) __CPU_EQUAL_S (sizeof (cpu_set_t), cpusetp1, cpusetp2)
#define CPU_EQUAL_S(setsize,cpusetp1,cpusetp2) __CPU_EQUAL_S (setsize, cpusetp1, cpusetp2)
#define CPU_AND(destset,srcset1,srcset2) __CPU_OP_S (sizeof (cpu_set_t), destset, srcset1, srcset2, &)
#define CPU_OR(destset,srcset1,srcset2) __CPU_OP_S (sizeof (cpu_set_t), destset, srcset1, srcset2, |)
#define CPU_XOR(destset,srcset1,srcset2) __CPU_OP_S (sizeof (cpu_set_t), destset, srcset1, srcset2, ^)
#define CPU_AND_S(setsize,destset,srcset1,srcset2) __CPU_OP_S (setsize, destset, srcset1, srcset2, &)
#define CPU_OR_S(setsize,destset,srcset1,srcset2) __CPU_OP_S (setsize, destset, srcset1, srcset2, |)
#define CPU_XOR_S(setsize,destset,srcset1,srcset2) __CPU_OP_S (setsize, destset, srcset1, srcset2, ^)
#define CPU_ALLOC_SIZE(count) __CPU_ALLOC_SIZE (count)
#define CPU_ALLOC(count) __CPU_ALLOC (count)
#define CPU_FREE(cpuset) __CPU_FREE (cpuset)
extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
const cpu_set_t *__cpuset) throw ();
extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
cpu_set_t *__cpuset) throw ();
}
#define _TIME_H 1
extern "C" {
#define __need_size_t
#define __need_NULL
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define _BITS_TIME_H 1
#define CLOCKS_PER_SEC 1000000l
#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 TIMER_ABSTIME 1
#define _BITS_TIMEX_H 1
struct timex
{
unsigned int modes;
__syscall_slong_t offset;
__syscall_slong_t freq;
__syscall_slong_t maxerror;
__syscall_slong_t esterror;
int status;
__syscall_slong_t constant;
__syscall_slong_t precision;
__syscall_slong_t tolerance;
struct timeval time;
__syscall_slong_t tick;
__syscall_slong_t ppsfreq;
__syscall_slong_t jitter;
int shift;
__syscall_slong_t stabil;
__syscall_slong_t jitcnt;
__syscall_slong_t calcnt;
__syscall_slong_t errcnt;
__syscall_slong_t stbcnt;
int tai;
int :32; int :32; int :32; int :32;
int :32; int :32; int :32; int :32;
int :32; int :32; int :32;
};
#define ADJ_OFFSET 0x0001
#define ADJ_FREQUENCY 0x0002
#define ADJ_MAXERROR 0x0004
#define ADJ_ESTERROR 0x0008
#define ADJ_STATUS 0x0010
#define ADJ_TIMECONST 0x0020
#define ADJ_TAI 0x0080
#define ADJ_MICRO 0x1000
#define ADJ_NANO 0x2000
#define ADJ_TICK 0x4000
#define ADJ_OFFSET_SINGLESHOT 0x8001
#define ADJ_OFFSET_SS_READ 0xa001
#define MOD_OFFSET ADJ_OFFSET
#define MOD_FREQUENCY ADJ_FREQUENCY
#define MOD_MAXERROR ADJ_MAXERROR
#define MOD_ESTERROR ADJ_ESTERROR
#define MOD_STATUS ADJ_STATUS
#define MOD_TIMECONST ADJ_TIMECONST
#define MOD_CLKB ADJ_TICK
#define MOD_CLKA ADJ_OFFSET_SINGLESHOT
#define MOD_TAI ADJ_TAI
#define MOD_MICRO ADJ_MICRO
#define MOD_NANO ADJ_NANO
#define STA_PLL 0x0001
#define STA_PPSFREQ 0x0002
#define STA_PPSTIME 0x0004
#define STA_FLL 0x0008
#define STA_INS 0x0010
#define STA_DEL 0x0020
#define STA_UNSYNC 0x0040
#define STA_FREQHOLD 0x0080
#define STA_PPSSIGNAL 0x0100
#define STA_PPSJITTER 0x0200
#define STA_PPSWANDER 0x0400
#define STA_PPSERROR 0x0800
#define STA_CLOCKERR 0x1000
#define STA_NANO 0x2000
#define STA_MODE 0x4000
#define STA_CLK 0x8000
#define STA_RONLY (STA_PPSSIGNAL | STA_PPSJITTER | STA_PPSWANDER | STA_PPSERROR | STA_CLOCKERR | STA_NANO | STA_MODE | STA_CLK)
extern "C" {
extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw ();
}
#undef __need_timeval
#undef __need_clock_t
#undef __need_time_t
#undef __clockid_time_t
#undef __need_timer_t
#undef __need_timespec
struct tm
{
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
long int tm_gmtoff;
const char *tm_zone;
};
struct itimerspec
{
struct timespec it_interval;
struct timespec it_value;
};
struct sigevent;
#define TIME_UTC 1
extern clock_t clock (void) throw ();
extern time_t time (time_t *__timer) throw ();
extern double difftime (time_t __time1, time_t __time0)
throw () __attribute__ ((__const__));
extern time_t mktime (struct tm *__tp) throw ();
extern size_t strftime (char *__restrict __s, size_t __maxsize,
const char *__restrict __format,
const struct tm *__restrict __tp) throw ();
extern char *strptime (const char *__restrict __s,
const char *__restrict __fmt, struct tm *__tp)
throw ();
extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
const char *__restrict __format,
const struct tm *__restrict __tp,
__locale_t __loc) throw ();
extern char *strptime_l (const char *__restrict __s,
const char *__restrict __fmt, struct tm *__tp,
__locale_t __loc) throw ();
extern struct tm *gmtime (const time_t *__timer) throw ();
extern struct tm *localtime (const time_t *__timer) throw ();
extern struct tm *gmtime_r (const time_t *__restrict __timer,
struct tm *__restrict __tp) throw ();
extern struct tm *localtime_r (const time_t *__restrict __timer,
struct tm *__restrict __tp) throw ();
extern char *asctime (const struct tm *__tp) throw ();
extern char *ctime (const time_t *__timer) throw ();
extern char *asctime_r (const struct tm *__restrict __tp,
char *__restrict __buf) throw ();
extern char *ctime_r (const time_t *__restrict __timer,
char *__restrict __buf) throw ();
extern char *__tzname[2];
extern int __daylight;
extern long int __timezone;
extern char *tzname[2];
extern void tzset (void) throw ();
extern int daylight;
extern long int timezone;
extern int stime (const time_t *__when) throw ();
#define __isleap(year) ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
extern time_t timegm (struct tm *__tp) throw ();
extern time_t timelocal (struct tm *__tp) throw ();
extern int dysize (int __year) throw () __attribute__ ((__const__));
extern int nanosleep (const struct timespec *__requested_time,
struct timespec *__remaining);
extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();
extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();
extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
throw ();
extern int clock_nanosleep (clockid_t __clock_id, int __flags,
const struct timespec *__req,
struct timespec *__rem);
extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();
extern int timer_create (clockid_t __clock_id,
struct sigevent *__restrict __evp,
timer_t *__restrict __timerid) throw ();
extern int timer_delete (timer_t __timerid) throw ();
extern int timer_settime (timer_t __timerid, int __flags,
const struct itimerspec *__restrict __value,
struct itimerspec *__restrict __ovalue) throw ();
extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
throw ();
extern int timer_getoverrun (timer_t __timerid) throw ();
extern int timespec_get (struct timespec *__ts, int __base)
throw () __attribute__ ((__nonnull__ (1)));
extern int getdate_err;
extern struct tm *getdate (const char *__string);
extern int getdate_r (const char *__restrict __string,
struct tm *__restrict __resbufp);
}
#define _BITS_SETJMP_H 1
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
typedef long int __jmp_buf[8];
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
enum
{
PTHREAD_CREATE_JOINABLE,
#define PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_JOINABLE
PTHREAD_CREATE_DETACHED
#define PTHREAD_CREATE_DETACHED PTHREAD_CREATE_DETACHED
};
enum
{
PTHREAD_MUTEX_TIMED_NP,
PTHREAD_MUTEX_RECURSIVE_NP,
PTHREAD_MUTEX_ERRORCHECK_NP,
PTHREAD_MUTEX_ADAPTIVE_NP
,
PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
, PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP
};
enum
{
PTHREAD_MUTEX_STALLED,
PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED,
PTHREAD_MUTEX_ROBUST,
PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST
};
enum
{
PTHREAD_PRIO_NONE,
PTHREAD_PRIO_INHERIT,
PTHREAD_PRIO_PROTECT
};
#define __PTHREAD_SPINS 0, 0
#define PTHREAD_MUTEX_INITIALIZER { { 0, 0, 0, 0, 0, __PTHREAD_SPINS, { 0, 0 } } }
#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP { { 0, 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, __PTHREAD_SPINS, { 0, 0 } } }
#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP { { 0, 0, 0, 0, PTHREAD_MUTEX_ERRORCHECK_NP, __PTHREAD_SPINS, { 0, 0 } } }
#define PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP { { 0, 0, 0, 0, PTHREAD_MUTEX_ADAPTIVE_NP, __PTHREAD_SPINS, { 0, 0 } } }
#define PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP { { 0, 0, 0, 0, PTHREAD_MUTEX_ADAPTIVE_NP, __PTHREAD_SPINS, { 0, 0 } } }
enum
{
PTHREAD_RWLOCK_PREFER_READER_NP,
PTHREAD_RWLOCK_PREFER_WRITER_NP,
PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP
};
#define PTHREAD_RWLOCK_INITIALIZER { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }
#define PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP } }
enum
{
PTHREAD_INHERIT_SCHED,
#define PTHREAD_INHERIT_SCHED PTHREAD_INHERIT_SCHED
PTHREAD_EXPLICIT_SCHED
#define PTHREAD_EXPLICIT_SCHED PTHREAD_EXPLICIT_SCHED
};
enum
{
PTHREAD_SCOPE_SYSTEM,
#define PTHREAD_SCOPE_SYSTEM PTHREAD_SCOPE_SYSTEM
PTHREAD_SCOPE_PROCESS
#define PTHREAD_SCOPE_PROCESS PTHREAD_SCOPE_PROCESS
};
enum
{
PTHREAD_PROCESS_PRIVATE,
#define PTHREAD_PROCESS_PRIVATE PTHREAD_PROCESS_PRIVATE
PTHREAD_PROCESS_SHARED
#define PTHREAD_PROCESS_SHARED PTHREAD_PROCESS_SHARED
};
#define PTHREAD_COND_INITIALIZER { { 0, 0, 0, 0, 0, (void *) 0, 0, 0 } }
struct _pthread_cleanup_buffer
{
void (*__routine) (void *);
void *__arg;
int __canceltype;
struct _pthread_cleanup_buffer *__prev;
};
enum
{
PTHREAD_CANCEL_ENABLE,
#define PTHREAD_CANCEL_ENABLE PTHREAD_CANCEL_ENABLE
PTHREAD_CANCEL_DISABLE
#define PTHREAD_CANCEL_DISABLE PTHREAD_CANCEL_DISABLE
};
enum
{
PTHREAD_CANCEL_DEFERRED,
#define PTHREAD_CANCEL_DEFERRED PTHREAD_CANCEL_DEFERRED
PTHREAD_CANCEL_ASYNCHRONOUS
#define PTHREAD_CANCEL_ASYNCHRONOUS PTHREAD_CANCEL_ASYNCHRONOUS
};
#define PTHREAD_CANCELED ((void *) -1)
#define PTHREAD_ONCE_INIT 0
#define PTHREAD_BARRIER_SERIAL_THREAD -1
extern "C" {
extern int pthread_create (pthread_t *__restrict __newthread,
const pthread_attr_t *__restrict __attr,
void *(*__start_routine) (void *),
void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3)));
extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));
extern int pthread_join (pthread_t __th, void **__thread_return);
extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();
extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
const struct timespec *__abstime);
extern int pthread_detach (pthread_t __th) throw ();
extern pthread_t pthread_self (void) throw () __attribute__ ((__const__));
extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
throw () __attribute__ ((__const__));
extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_destroy (pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
int *__detachstate)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
int __detachstate)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
size_t *__guardsize)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
size_t __guardsize)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
struct sched_param *__restrict __param)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
const struct sched_param *__restrict
__param) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
__attr, int *__restrict __policy)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
__attr, int *__restrict __inherit)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
int __inherit)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
int *__restrict __scope)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
__attr, void **__restrict __stackaddr)
throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));
extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
void *__stackaddr)
throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));
extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
__attr, size_t *__restrict __stacksize)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
size_t __stacksize)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
void **__restrict __stackaddr,
size_t *__restrict __stacksize)
throw () __attribute__ ((__nonnull__ (1, 2, 3)));
extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
size_t __stacksize) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
size_t __cpusetsize,
const cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
size_t __cpusetsize,
cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern int pthread_getattr_default_np (pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_setattr_default_np (const pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
throw () __attribute__ ((__nonnull__ (2)));
extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
const struct sched_param *__param)
throw () __attribute__ ((__nonnull__ (3)));
extern int pthread_getschedparam (pthread_t __target_thread,
int *__restrict __policy,
struct sched_param *__restrict __param)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
throw ();
extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
size_t __buflen)
throw () __attribute__ ((__nonnull__ (2)));
extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
throw () __attribute__ ((__nonnull__ (2)));
extern int pthread_getconcurrency (void) throw ();
extern int pthread_setconcurrency (int __level) throw ();
extern int pthread_yield (void) throw ();
extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
const cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (3)));
extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
cpu_set_t *__cpuset)
throw () __attribute__ ((__nonnull__ (3)));
extern int pthread_once (pthread_once_t *__once_control,
void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_setcancelstate (int __state, int *__oldstate);
extern int pthread_setcanceltype (int __type, int *__oldtype);
extern int pthread_cancel (pthread_t __th);
extern void pthread_testcancel (void);
typedef struct
{
struct
{
__jmp_buf __cancel_jmp_buf;
int __mask_was_saved;
} __cancel_jmp_buf[1];
void *__pad[4];
} __pthread_unwind_buf_t __attribute__ ((__aligned__));
#define __cleanup_fct_attribute
struct __pthread_cleanup_frame
{
void (*__cancel_routine) (void *);
void *__cancel_arg;
int __do_it;
int __cancel_type;
};
class __pthread_cleanup_class
{
void (*__cancel_routine) (void *);
void *__cancel_arg;
int __do_it;
int __cancel_type;
public:
__pthread_cleanup_class (void (*__fct) (void *), void *__arg) ;
~__pthread_cleanup_class () ;
void __setdoit (int __newval) ;
void __defer () ;
void __restore () const ;
};
#define pthread_cleanup_push(routine,arg) do { __pthread_cleanup_class __clframe (routine, arg)
#define pthread_cleanup_pop(execute) __clframe.__setdoit (execute); } while (0)
#define pthread_cleanup_push_defer_np(routine,arg) do { __pthread_cleanup_class __clframe (routine, arg); __clframe.__defer ()
#define pthread_cleanup_pop_restore_np(execute) __clframe.__restore (); __clframe.__setdoit (execute); } while (0)
struct __jmp_buf_tag;
extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();
extern int pthread_mutex_init (pthread_mutex_t *__mutex,
const pthread_mutexattr_t *__mutexattr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
const struct timespec *__restrict
__abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
__restrict __mutex,
int *__restrict __prioceiling)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
int __prioceiling,
int *__restrict __old_ceiling)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
__attr, int *__restrict __kind)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
__restrict __attr,
int *__restrict __protocol)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
int __protocol)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
__restrict __attr,
int *__restrict __prioceiling)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
int __prioceiling)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
int *__robustness)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
int *__robustness)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
int __robustness)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
int __robustness)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
const pthread_rwlockattr_t *__restrict
__attr) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
const struct timespec *__restrict
__abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
const struct timespec *__restrict
__abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
__restrict __attr,
int *__restrict __pref)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
int __pref) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
const pthread_condattr_t *__restrict __cond_attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_destroy (pthread_cond_t *__cond)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_signal (pthread_cond_t *__cond)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_broadcast (pthread_cond_t *__cond)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
pthread_mutex_t *__restrict __mutex)
__attribute__ ((__nonnull__ (1, 2)));
extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
pthread_mutex_t *__restrict __mutex,
const struct timespec *__restrict __abstime)
__attribute__ ((__nonnull__ (1, 2, 3)));
extern int pthread_condattr_init (pthread_condattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_condattr_getpshared (const pthread_condattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
int __pshared) throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_condattr_getclock (const pthread_condattr_t *
__restrict __attr,
__clockid_t *__restrict __clock_id)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
__clockid_t __clock_id)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_lock (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
const pthread_barrierattr_t *__restrict
__attr, unsigned int __count)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
__restrict __attr,
int *__restrict __pshared)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
int __pshared)
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_key_create (pthread_key_t *__key,
void (*__destr_function) (void *))
throw () __attribute__ ((__nonnull__ (1)));
extern int pthread_key_delete (pthread_key_t __key) throw ();
extern void *pthread_getspecific (pthread_key_t __key) throw ();
extern int pthread_setspecific (pthread_key_t __key,
const void *__pointer) throw () ;
extern int pthread_getcpuclockid (pthread_t __thread_id,
__clockid_t *__clock_id)
throw () __attribute__ ((__nonnull__ (2)));
extern int pthread_atfork (void (*__prepare) (void),
void (*__parent) (void),
void (*__child) (void)) throw ();
}
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 PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
#define __GTHREAD_COND_INIT PTHREAD_COND_INITIALIZER
#define __GTHREAD_TIME_INIT {0,0}
#define __gthrw_pragma(pragma)
#define __gthrw2(name,name2,type) static __typeof(type) name __attribute__ ((__weakref__(#name2))); __gthrw_pragma(weak type)
#define __gthrw_(name) __gthrw_ ## name
#define __gthrw(name) __gthrw2(__gthrw_ ## name,name,name)
static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once")));
static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific")));
static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific")));
static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create")));
static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join")));
static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal")));
static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self")));
static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach")));
static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel")));
static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield")));
static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock")));
static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock")));
static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock")));
static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock")));
static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init")));
static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy")));
static __typeof(pthread_cond_init) __gthrw_pthread_cond_init __attribute__ ((__weakref__("pthread_cond_init")));
static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast")));
static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal")));
static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait")));
static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait")));
static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy")));
static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create")));
static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete")));
static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init")));
static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype")));
static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy")));
static __typeof(pthread_key_create) __gthrw___pthread_key_create __attribute__ ((__weakref__("__pthread_key_create")));
#define GTHR_ACTIVE_PROXY __gthrw_(__pthread_key_create)
static int
__gthread_active_p (void)
;
static int
__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
void *__args)
;
static int
__gthread_join (__gthread_t __threadid, void **__value_ptr)
;
static int
__gthread_detach (__gthread_t __threadid)
;
static int
__gthread_equal (__gthread_t __t1, __gthread_t __t2)
;
static __gthread_t
__gthread_self (void)
;
static int
__gthread_yield (void)
;
static int
__gthread_once (__gthread_once_t *__once, void (*__func) (void))
;
static int
__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
;
static int
__gthread_key_delete (__gthread_key_t __key)
;
static void *
__gthread_getspecific (__gthread_key_t __key)
;
static int
__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
;
static void
__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
;
static int
__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
;
static int
__gthread_mutex_lock (__gthread_mutex_t *__mutex)
;
static int
__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
;
static int
__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
const __gthread_time_t *__abs_timeout)
;
static int
__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
;
static int
__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
;
static int
__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
;
static int
__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
const __gthread_time_t *__abs_timeout)
;
static int
__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
;
static int
__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
;
static int
__gthread_cond_broadcast (__gthread_cond_t *__cond)
;
static int
__gthread_cond_signal (__gthread_cond_t *__cond)
;
static int
__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
;
static int
__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
const __gthread_time_t *__abs_timeout)
;
static int
__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
__gthread_recursive_mutex_t *__mutex)
;
static int
__gthread_cond_destroy (__gthread_cond_t* __cond)
;
#pragma GCC visibility pop
#define _GLIBCXX_ATOMIC_WORD_H 1
typedef int _Atomic_word;
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
static _Atomic_word
__exchange_and_add(volatile _Atomic_word* __mem, int __val)
;
static void
__atomic_add(volatile _Atomic_word* __mem, int __val)
;
static _Atomic_word
__exchange_and_add_single(_Atomic_word* __mem, int __val)
;
static void
__atomic_add_single(_Atomic_word* __mem, int __val)
;
static _Atomic_word
__attribute__ ((__unused__))
__exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
;
static void
__attribute__ ((__unused__))
__atomic_add_dispatch(_Atomic_word* __mem, int __val)
;
}
#define _GLIBCXX_READ_MEM_BARRIER __asm __volatile ("":::"memory")
#define _GLIBCXX_WRITE_MEM_BARRIER __asm __volatile ("":::"memory")
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
using std::size_t;
using std::ptrdiff_t;
typedef void (*__destroy_handler)(void*);
struct __pool_base
{
typedef unsigned short int _Binmap_type;
struct _Tune
{
enum { _S_align = 8 };
enum { _S_max_bytes = 128 };
enum { _S_min_bin = 8 };
enum { _S_chunk_size = 4096 - 4 * sizeof(void*) };
enum { _S_max_threads = 4096 };
enum { _S_freelist_headroom = 10 };
size_t _M_align;
size_t _M_max_bytes;
size_t _M_min_bin;
size_t _M_chunk_size;
size_t _M_max_threads;
size_t _M_freelist_headroom;
bool _M_force_new;
explicit
_Tune()
;
explicit
_Tune(size_t __align, size_t __maxb, size_t __minbin, size_t __chunk,
size_t __maxthreads, size_t __headroom, bool __force)
;
};
struct _Block_address
{
void* _M_initial;
_Block_address* _M_next;
};
const _Tune&
_M_get_options() const
;
void
_M_set_options(_Tune __t)
;
bool
_M_check_threshold(size_t __bytes)
;
size_t
_M_get_binmap(size_t __bytes)
;
size_t
_M_get_align()
;
explicit
__pool_base() ;
explicit
__pool_base(const _Tune& __options) ;
private:
explicit
__pool_base(const __pool_base&);
__pool_base&
operator=(const __pool_base&);
protected:
_Tune _M_options;
_Binmap_type* _M_binmap;
bool _M_init;
};
template<bool _Thread>
class __pool;
template<>
class __pool<false> : public __pool_base
{
public:
union _Block_record
{
_Block_record* _M_next;
};
struct _Bin_record
{
_Block_record** _M_first;
_Block_address* _M_address;
};
void
_M_initialize_once()
;
void
_M_destroy() throw();
char*
_M_reserve_block(size_t __bytes, const size_t __thread_id);
void
_M_reclaim_block(char* __p, size_t __bytes) throw ();
size_t
_M_get_thread_id() ;
const _Bin_record&
_M_get_bin(size_t __which)
;
void
_M_adjust_freelist(const _Bin_record&, _Block_record*, size_t)
;
explicit __pool() ;
explicit __pool(const __pool_base::_Tune& __tune) ;
private:
_Bin_record* _M_bin;
size_t _M_bin_size;
void
_M_initialize();
};
template<>
class __pool<true> : public __pool_base
{
public:
struct _Thread_record
{
_Thread_record* _M_next;
size_t _M_id;
};
union _Block_record
{
_Block_record* _M_next;
size_t _M_thread_id;
};
struct _Bin_record
{
_Block_record** _M_first;
_Block_address* _M_address;
size_t* _M_free;
size_t* _M_used;
__gthread_mutex_t* _M_mutex;
};
void
_M_initialize(__destroy_handler);
void
_M_initialize_once()
;
void
_M_destroy() throw();
char*
_M_reserve_block(size_t __bytes, const size_t __thread_id);
void
_M_reclaim_block(char* __p, size_t __bytes) throw ();
const _Bin_record&
_M_get_bin(size_t __which)
;
void
_M_adjust_freelist(const _Bin_record& __bin, _Block_record* __block,
size_t __thread_id)
;
__attribute__ ((__const__)) void
_M_destroy_thread_key(void*) throw ();
size_t
_M_get_thread_id();
explicit __pool()
;
explicit __pool(const __pool_base::_Tune& __tune)
;
private:
_Bin_record* _M_bin;
size_t _M_bin_size;
_Thread_record* _M_thread_freelist;
void* _M_thread_freelist_initial;
void
_M_initialize();
};
template<template <bool> class _PoolTp, bool _Thread>
struct __common_pool
{
typedef _PoolTp<_Thread> pool_type;
static pool_type&
_S_get_pool()
;
};
template<template <bool> class _PoolTp, bool _Thread>
struct __common_pool_base;
template<template <bool> class _PoolTp>
struct __common_pool_base<_PoolTp, false>
: public __common_pool<_PoolTp, false>
{
using __common_pool<_PoolTp, false>::_S_get_pool;
static void
_S_initialize_once()
;
};
template<template <bool> class _PoolTp>
struct __common_pool_base<_PoolTp, true>
: public __common_pool<_PoolTp, true>
{
using __common_pool<_PoolTp, true>::_S_get_pool;
static void
_S_initialize()
;
static void
_S_initialize_once()
;
};
template<template <bool> class _PoolTp, bool _Thread>
struct __common_pool_policy : public __common_pool_base<_PoolTp, _Thread>
{
template<typename _Tp1, template <bool> class _PoolTp1 = _PoolTp,
bool _Thread1 = _Thread>
struct _M_rebind
{ typedef __common_pool_policy<_PoolTp1, _Thread1> other; };
using __common_pool_base<_PoolTp, _Thread>::_S_get_pool;
using __common_pool_base<_PoolTp, _Thread>::_S_initialize_once;
};
template<typename _Tp, template <bool> class _PoolTp, bool _Thread>
struct __per_type_pool
{
typedef _Tp value_type;
typedef _PoolTp<_Thread> pool_type;
static pool_type&
_S_get_pool()
;
};
template<typename _Tp, template <bool> class _PoolTp, bool _Thread>
struct __per_type_pool_base;
template<typename _Tp, template <bool> class _PoolTp>
struct __per_type_pool_base<_Tp, _PoolTp, false>
: public __per_type_pool<_Tp, _PoolTp, false>
{
using __per_type_pool<_Tp, _PoolTp, false>::_S_get_pool;
static void
_S_initialize_once()
;
};
template<typename _Tp, template <bool> class _PoolTp>
struct __per_type_pool_base<_Tp, _PoolTp, true>
: public __per_type_pool<_Tp, _PoolTp, true>
{
using __per_type_pool<_Tp, _PoolTp, true>::_S_get_pool;
static void
_S_initialize()
;
static void
_S_initialize_once()
;
};
template<typename _Tp, template <bool> class _PoolTp, bool _Thread>
struct __per_type_pool_policy
: public __per_type_pool_base<_Tp, _PoolTp, _Thread>
{
template<typename _Tp1, template <bool> class _PoolTp1 = _PoolTp,
bool _Thread1 = _Thread>
struct _M_rebind
{ typedef __per_type_pool_policy<_Tp1, _PoolTp1, _Thread1> other; };
using __per_type_pool_base<_Tp, _PoolTp, _Thread>::_S_get_pool;
using __per_type_pool_base<_Tp, _PoolTp, _Thread>::_S_initialize_once;
};
template<typename _Tp>
class __mt_alloc_base
{
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;
typedef std::true_type propagate_on_container_move_assignment;
pointer
address(reference __x) const noexcept
{ return std::__addressof(__x); }
const_pointer
address(const_reference __x) const noexcept
{ return std::__addressof(__x); }
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(); }
};
#define __thread_default true
template<typename _Tp,
typename _Poolp = __common_pool_policy<__pool, true> >
class __mt_alloc : public __mt_alloc_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;
typedef _Poolp __policy_type;
typedef typename _Poolp::pool_type __pool_type;
template<typename _Tp1, typename _Poolp1 = _Poolp>
struct rebind
{
typedef typename _Poolp1::template _M_rebind<_Tp1>::other pol_type;
typedef __mt_alloc<_Tp1, pol_type> other;
};
__mt_alloc() noexcept { }
__mt_alloc(const __mt_alloc&) noexcept { }
template<typename _Tp1, typename _Poolp1>
__mt_alloc(const __mt_alloc<_Tp1, _Poolp1>&) noexcept { }
~__mt_alloc() noexcept { }
pointer
allocate(size_type __n, const void* = 0);
void
deallocate(pointer __p, size_type __n);
const __pool_base::_Tune
_M_get_options()
;
void
_M_set_options(__pool_base::_Tune __t)
;
};
template<typename _Tp, typename _Poolp>
bool
operator==(const __mt_alloc<_Tp, _Poolp>&, const __mt_alloc<_Tp, _Poolp>&)
;
template<typename _Tp, typename _Poolp>
bool
operator!=(const __mt_alloc<_Tp, _Poolp>&, const __mt_alloc<_Tp, _Poolp>&)
;
#undef __thread_default
}
namespace std
{
template<typename _Tp>
using __allocator_base = __gnu_cxx::__mt_alloc<_Tp>;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<>
class allocator<void>
{
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef void* pointer;
typedef const void* const_pointer;
typedef void value_type;
template<typename _Tp1>
struct rebind
{ typedef allocator<_Tp1> other; };
typedef true_type propagate_on_container_move_assignment;
};
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;
allocator() throw() ;
allocator(const allocator& __a) throw() ;
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&)
;
};
template<typename _Alloc>
struct __alloc_neq<_Alloc, false>
{
static bool
_S_do_it(const _Alloc& __one, const _Alloc& __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; }
}
};
}
#define _LOCALE_FWD_H 1
#define _GLIBCXX_CXX_LOCALE_H 1
#define _LOCALE_H 1
#define __need_NULL
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define _BITS_LOCALE_H 1
#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
#define __LC_PAPER 7
#define __LC_NAME 8
#define __LC_ADDRESS 9
#define __LC_TELEPHONE 10
#define __LC_MEASUREMENT 11
#define __LC_IDENTIFICATION 12
extern "C" {
#define LC_CTYPE __LC_CTYPE
#define LC_NUMERIC __LC_NUMERIC
#define LC_TIME __LC_TIME
#define LC_COLLATE __LC_COLLATE
#define LC_MONETARY __LC_MONETARY
#define LC_MESSAGES __LC_MESSAGES
#define LC_ALL __LC_ALL
#define LC_PAPER __LC_PAPER
#define LC_NAME __LC_NAME
#define LC_ADDRESS __LC_ADDRESS
#define LC_TELEPHONE __LC_TELEPHONE
#define LC_MEASUREMENT __LC_MEASUREMENT
#define LC_IDENTIFICATION __LC_IDENTIFICATION
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;
};
extern char *setlocale (int __category, const char *__locale) throw ();
extern struct lconv *localeconv (void) throw ();
extern __locale_t newlocale (int __category_mask, const char *__locale,
__locale_t __base) throw ();
#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_PAPER_MASK (1 << __LC_PAPER)
#define LC_NAME_MASK (1 << __LC_NAME)
#define LC_ADDRESS_MASK (1 << __LC_ADDRESS)
#define LC_TELEPHONE_MASK (1 << __LC_TELEPHONE)
#define LC_MEASUREMENT_MASK (1 << __LC_MEASUREMENT)
#define LC_IDENTIFICATION_MASK (1 << __LC_IDENTIFICATION)
#define LC_ALL_MASK (LC_CTYPE_MASK | LC_NUMERIC_MASK | LC_TIME_MASK | LC_COLLATE_MASK | LC_MONETARY_MASK | LC_MESSAGES_MASK | LC_PAPER_MASK | LC_NAME_MASK | LC_ADDRESS_MASK | LC_TELEPHONE_MASK | LC_MEASUREMENT_MASK | LC_IDENTIFICATION_MASK )
extern __locale_t duplocale (__locale_t __dataset) throw ();
extern void freelocale (__locale_t __dataset) throw ();
extern __locale_t uselocale (__locale_t __dataset) throw ();
#define LC_GLOBAL_LOCALE ((__locale_t) -1L)
}
#define _GLIBCXX_CLOCALE 1
#undef setlocale
#undef localeconv
namespace std
{
using ::lconv;
using ::setlocale;
using ::localeconv;
}
#define _GLIBCXX_C_LOCALE_GNU 1
#define _GLIBCXX_NUM_CATEGORIES 6
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
extern "C" __typeof(uselocale) __uselocale;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
typedef __locale_t __c_locale;
int
__convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
char* __out,
const int __size __attribute__ ((__unused__)),
const char* __fmt, ...)
;
}
#define _GLIBCXX_IOSFWD 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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;
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;
}
#define _CTYPE_H 1
extern "C" {
#define _ISbit(bit) ((bit) < 8 ? ((1 << (bit)) << 8) : ((1 << (bit)) >> 8))
enum
{
_ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
_ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
_ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
_ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
_ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
_ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
_ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
_ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
_ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
_IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
_ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
_ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
};
extern const unsigned short int **__ctype_b_loc (void)
throw () __attribute__ ((__const__));
extern const __int32_t **__ctype_tolower_loc (void)
throw () __attribute__ ((__const__));
extern const __int32_t **__ctype_toupper_loc (void)
throw () __attribute__ ((__const__));
#define __isascii(c) (((c) & ~0x7f) == 0)
#define __toascii(c) ((c) & 0x7f)
#define __exctype(name) extern int name (int) __THROW
extern int isalnum (int) throw ();
extern int isalpha (int) throw ();
extern int iscntrl (int) throw ();
extern int isdigit (int) throw ();
extern int islower (int) throw ();
extern int isgraph (int) throw ();
extern int isprint (int) throw ();
extern int ispunct (int) throw ();
extern int isspace (int) throw ();
extern int isupper (int) throw ();
extern int isxdigit (int) throw ();
extern int tolower (int __c) throw ();
extern int toupper (int __c) throw ();
extern int isblank (int) throw ();
extern int isctype (int __c, int __mask) throw ();
extern int isascii (int __c) throw ();
extern int toascii (int __c) throw ();
extern int _toupper (int) throw ();
extern int _tolower (int) throw ();
#define __tobody(c,f,a,args) (__extension__ ({ int __res; if (sizeof (c) > 1) { if (__builtin_constant_p (c)) { int __c = (c); __res = __c < -128 || __c > 255 ? __c : (a)[__c]; } else __res = f args; } else __res = (a)[(int) (c)]; __res; }))
#define __isctype_l(c,type,locale) ((locale)->__ctype_b[(int) (c)] & (unsigned short int) type)
#define __exctype_l(name) extern int name (int, __locale_t) __THROW
extern int isalnum_l (int, __locale_t) throw ();
extern int isalpha_l (int, __locale_t) throw ();
extern int iscntrl_l (int, __locale_t) throw ();
extern int isdigit_l (int, __locale_t) throw ();
extern int islower_l (int, __locale_t) throw ();
extern int isgraph_l (int, __locale_t) throw ();
extern int isprint_l (int, __locale_t) throw ();
extern int ispunct_l (int, __locale_t) throw ();
extern int isspace_l (int, __locale_t) throw ();
extern int isupper_l (int, __locale_t) throw ();
extern int isxdigit_l (int, __locale_t) throw ();
extern int isblank_l (int, __locale_t) throw ();
extern int __tolower_l (int __c, __locale_t __l) throw ();
extern int tolower_l (int __c, __locale_t __l) throw ();
extern int __toupper_l (int __c, __locale_t __l) throw ();
extern int toupper_l (int __c, __locale_t __l) throw ();
}
#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;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
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>
_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;
template<typename _CharT> class numpunct;
template<typename _CharT> class numpunct_byname;
template<typename _CharT>
class collate;
template<typename _CharT> class
collate_byname;
class time_base;
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;
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class money_get;
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class money_put;
template<typename _CharT, bool _Intl = false>
class moneypunct;
template<typename _CharT, bool _Intl = false>
class moneypunct_byname;
class messages_base;
template<typename _CharT>
class messages;
template<typename _CharT>
class messages_byname;
}
#define _OSTREAM_INSERT_H 1
#define _CXXABI_FORCED_H 1
#pragma GCC visibility push(default)
namespace __cxxabiv1
{
class __forced_unwind
{
virtual ~__forced_unwind() throw();
virtual void __pure_dummy() = 0;
};
}
#pragma GCC visibility pop
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
void
__ostream_write(basic_ostream<_CharT, _Traits>& __out,
const _CharT* __s, streamsize __n)
;
template<typename _CharT, typename _Traits>
void
__ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
__ostream_insert(basic_ostream<_CharT, _Traits>& __out,
const _CharT* __s, streamsize __n)
;
extern template ostream& __ostream_insert(ostream&, const char*, streamsize);
extern template wostream& __ostream_insert(wostream&, const wchar_t*,
streamsize);
}
#define _STL_FUNCTION_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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;
};
template<typename _Tp>
struct plus : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct minus : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct multiplies : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct divides : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct modulus : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct negate : public unary_function<_Tp, _Tp>
{
_Tp
operator()(const _Tp& __x) const
;
};
template<typename _Tp>
struct equal_to : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct not_equal_to : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct greater : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct less : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct greater_equal : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct less_equal : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct logical_and : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct logical_or : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct logical_not : public unary_function<_Tp, bool>
{
bool
operator()(const _Tp& __x) const
;
};
template<typename _Tp>
struct bit_and : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct bit_or : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
{
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
;
};
template<typename _Tp>
struct bit_not : public unary_function<_Tp, _Tp>
{
_Tp
operator()(const _Tp& __x) const
;
};
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) ;
bool
operator()(const typename _Predicate::argument_type& __x) const
;
};
template<typename _Predicate>
unary_negate<_Predicate>
not1(const _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) ;
bool
operator()(const typename _Predicate::first_argument_type& __x,
const typename _Predicate::second_argument_type& __y) const
;
};
template<typename _Predicate>
binary_negate<_Predicate>
not2(const _Predicate& __pred)
;
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)) ;
_Result
operator()(_Arg __x) const
;
};
template<typename _Arg, typename _Result>
pointer_to_unary_function<_Arg, _Result>
ptr_fun(_Result (*__x)(_Arg))
;
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)) ;
_Result
operator()(_Arg1 __x, _Arg2 __y) const
;
};
template<typename _Arg1, typename _Arg2, typename _Result>
pointer_to_binary_function<_Arg1, _Arg2, _Result>
ptr_fun(_Result (*__x)(_Arg1, _Arg2))
;
template<typename _Tp>
struct _Identity
: public unary_function<_Tp,_Tp>
{
_Tp&
operator()(_Tp& __x) const
;
const _Tp&
operator()(const _Tp& __x) const
;
};
template<typename _Pair>
struct _Select1st
: public unary_function<_Pair, typename _Pair::first_type>
{
typename _Pair::first_type&
operator()(_Pair& __x) const
;
const typename _Pair::first_type&
operator()(const _Pair& __x) const
;
template<typename _Pair2>
typename _Pair2::first_type&
operator()(_Pair2& __x) const
;
template<typename _Pair2>
const typename _Pair2::first_type&
operator()(const _Pair2& __x) const
;
};
template<typename _Pair>
struct _Select2nd
: public unary_function<_Pair, typename _Pair::second_type>
{
typename _Pair::second_type&
operator()(_Pair& __x) const
;
const typename _Pair::second_type&
operator()(const _Pair& __x) const
;
};
template<typename _Ret, typename _Tp>
class mem_fun_t : public unary_function<_Tp*, _Ret>
{
public:
explicit
mem_fun_t(_Ret (_Tp::*__pf)()) ;
_Ret
operator()(_Tp* __p) const
;
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) ;
_Ret
operator()(const _Tp* __p) const
;
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)()) ;
_Ret
operator()(_Tp& __r) const
;
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) ;
_Ret
operator()(const _Tp& __r) const
;
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)) ;
_Ret
operator()(_Tp* __p, _Arg __x) const
;
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) ;
_Ret
operator()(const _Tp* __p, _Arg __x) const
;
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)) ;
_Ret
operator()(_Tp& __r, _Arg __x) const
;
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) ;
_Ret
operator()(const _Tp& __r, _Arg __x) const
;
private:
_Ret (_Tp::*_M_f)(_Arg) const;
};
template<typename _Ret, typename _Tp>
mem_fun_t<_Ret, _Tp>
mem_fun(_Ret (_Tp::*__f)())
;
template<typename _Ret, typename _Tp>
const_mem_fun_t<_Ret, _Tp>
mem_fun(_Ret (_Tp::*__f)() const)
;
template<typename _Ret, typename _Tp>
mem_fun_ref_t<_Ret, _Tp>
mem_fun_ref(_Ret (_Tp::*__f)())
;
template<typename _Ret, typename _Tp>
const_mem_fun_ref_t<_Ret, _Tp>
mem_fun_ref(_Ret (_Tp::*__f)() const)
;
template<typename _Ret, typename _Tp, typename _Arg>
mem_fun1_t<_Ret, _Tp, _Arg>
mem_fun(_Ret (_Tp::*__f)(_Arg))
;
template<typename _Ret, typename _Tp, typename _Arg>
const_mem_fun1_t<_Ret, _Tp, _Arg>
mem_fun(_Ret (_Tp::*__f)(_Arg) const)
;
template<typename _Ret, typename _Tp, typename _Arg>
mem_fun1_ref_t<_Ret, _Tp, _Arg>
mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
;
template<typename _Ret, typename _Tp, typename _Arg>
const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
;
}
#define _BACKWARD_BINDERS_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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) ;
typename _Operation::result_type
operator()(const typename _Operation::second_argument_type& __x) const
;
typename _Operation::result_type
operator()(typename _Operation::second_argument_type& __x) const
;
} __attribute__ ((__deprecated__));
template<typename _Operation, typename _Tp>
binder1st<_Operation>
bind1st(const _Operation& __fn, const _Tp& __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) ;
typename _Operation::result_type
operator()(const typename _Operation::first_argument_type& __x) const
;
typename _Operation::result_type
operator()(typename _Operation::first_argument_type& __x) const
;
} __attribute__ ((__deprecated__));
template<typename _Operation, typename _Tp>
binder2nd<_Operation>
bind2nd(const _Operation& __fn, const _Tp& __x)
;
}
#define _GLIBCXX_RANGE_ACCESS_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<class _Container>
inline auto
begin(_Container& __cont) -> decltype(__cont.begin())
{ return __cont.begin(); }
template<class _Container>
inline auto
begin(const _Container& __cont) -> decltype(__cont.begin())
{ return __cont.begin(); }
template<class _Container>
inline auto
end(_Container& __cont) -> decltype(__cont.end())
{ return __cont.end(); }
template<class _Container>
inline auto
end(const _Container& __cont) -> decltype(__cont.end())
{ return __cont.end(); }
template<class _Tp, size_t _Nm>
_Tp*
begin(_Tp (&__arr)[_Nm])
;
template<class _Tp, size_t _Nm>
_Tp*
end(_Tp (&__arr)[_Nm])
;
}
#define _BASIC_STRING_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits, typename _Alloc>
class basic_string
{
typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;
public:
typedef _Traits traits_type;
typedef typename _Traits::char_type value_type;
typedef _Alloc allocator_type;
typedef typename _CharT_alloc_type::size_type size_type;
typedef typename _CharT_alloc_type::difference_type difference_type;
typedef typename _CharT_alloc_type::reference reference;
typedef typename _CharT_alloc_type::const_reference const_reference;
typedef typename _CharT_alloc_type::pointer pointer;
typedef typename _CharT_alloc_type::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;
private:
struct _Rep_base
{
size_type _M_length;
size_type _M_capacity;
_Atomic_word _M_refcount;
};
struct _Rep : _Rep_base
{
typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
static const size_type _S_max_size;
static const _CharT _S_terminal;
static size_type _S_empty_rep_storage[];
static _Rep&
_S_empty_rep() noexcept
{
void* __p = reinterpret_cast<void*>(&_S_empty_rep_storage);
return *reinterpret_cast<_Rep*>(__p);
}
bool
_M_is_leaked() const noexcept
{ return this->_M_refcount < 0; }
bool
_M_is_shared() const noexcept
{ return this->_M_refcount > 0; }
void
_M_set_leaked() noexcept
{ this->_M_refcount = -1; }
void
_M_set_sharable() noexcept
{ this->_M_refcount = 0; }
void
_M_set_length_and_sharable(size_type __n) noexcept
{
if (__builtin_expect(this != &_S_empty_rep(), false))
{
this->_M_set_sharable();
this->_M_length = __n;
traits_type::assign(this->_M_refdata()[__n], _S_terminal);
}
}
_CharT*
_M_refdata() throw()
{ return reinterpret_cast<_CharT*>(this + 1); }
_CharT*
_M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2)
{
return (!_M_is_leaked() && __alloc1 == __alloc2)
? _M_refcopy() : _M_clone(__alloc1);
}
static _Rep*
_S_create(size_type, size_type, const _Alloc&);
void
_M_dispose(const _Alloc& __a) noexcept
{
if (__builtin_expect(this != &_S_empty_rep(), false))
{
;
if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount,
-1) <= 0)
{
;
_M_destroy(__a);
}
}
}
void
_M_destroy(const _Alloc&) throw();
_CharT*
_M_refcopy() throw()
;
_CharT*
_M_clone(const _Alloc&, size_type __res = 0);
};
struct _Alloc_hider : _Alloc
{
_Alloc_hider(_CharT* __dat, const _Alloc& __a) noexcept
: _Alloc(__a), _M_p(__dat) { }
_CharT* _M_p;
};
public:
static const size_type npos = static_cast<size_type>(-1);
private:
mutable _Alloc_hider _M_dataplus;
_CharT*
_M_data() const noexcept
{ return _M_dataplus._M_p; }
_CharT*
_M_data(_CharT* __p) noexcept
{ return (_M_dataplus._M_p = __p); }
_Rep*
_M_rep() const noexcept
{ return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }
iterator
_M_ibegin() const noexcept
{ return iterator(_M_data()); }
iterator
_M_iend() const noexcept
{ return iterator(_M_data() + this->size()); }
void
_M_leak()
{
if (!_M_rep()->_M_is_leaked())
_M_leak_hard();
}
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
_M_copy(_CharT* __d, const _CharT* __s, size_type __n) noexcept
{
if (__n == 1)
traits_type::assign(*__d, *__s);
else
traits_type::copy(__d, __s, __n);
}
static void
_M_move(_CharT* __d, const _CharT* __s, size_type __n) noexcept
{
if (__n == 1)
traits_type::assign(*__d, *__s);
else
traits_type::move(__d, __s, __n);
}
static void
_M_assign(_CharT* __d, size_type __n, _CharT __c) noexcept
{
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)
noexcept
{
for (; __k1 != __k2; ++__k1, ++__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
{ _M_copy(__p, __k1, __k2 - __k1); }
static void
_S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
noexcept
{ _M_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_mutate(size_type __pos, size_type __len1, size_type __len2);
void
_M_leak_hard();
static _Rep&
_S_empty_rep() noexcept
{ return _Rep::_S_empty_rep(); }
public:
basic_string()
: _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { }
explicit
basic_string(const _Alloc& __a);
basic_string(const basic_string& __str);
basic_string(const basic_string& __str, size_type __pos,
size_type __n = npos);
basic_string(const basic_string& __str, size_type __pos,
size_type __n, const _Alloc& __a);
basic_string(const _CharT* __s, size_type __n,
const _Alloc& __a = _Alloc());
basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc());
basic_string(basic_string&& __str)
noexcept
: _M_dataplus(__str._M_dataplus)
{
__str._M_data(_S_empty_rep()._M_refdata());
}
basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc());
template<class _InputIterator>
basic_string(_InputIterator __beg, _InputIterator __end,
const _Alloc& __a = _Alloc());
~basic_string() noexcept
{ _M_rep()->_M_dispose(this->get_allocator()); }
basic_string&
operator=(const basic_string& __str)
{ return this->assign(__str); }
basic_string&
operator=(const _CharT* __s)
{ return this->assign(__s); }
basic_string&
operator=(_CharT __c)
{
this->assign(1, __c);
return *this;
}
basic_string&
operator=(basic_string&& __str)
{
this->swap(__str);
return *this;
}
basic_string&
operator=(initializer_list<_CharT> __l)
{
this->assign(__l.begin(), __l.size());
return *this;
}
iterator
begin()
{
_M_leak();
return iterator(_M_data());
}
const_iterator
begin() const noexcept
{ return const_iterator(_M_data()); }
iterator
end()
{
_M_leak();
return iterator(_M_data() + this->size());
}
const_iterator
end() const noexcept
{ return const_iterator(_M_data() + this->size()); }
reverse_iterator
rbegin()
{ return reverse_iterator(this->end()); }
const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(this->end()); }
reverse_iterator
rend()
{ 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_rep()->_M_length; }
size_type
length() const noexcept
{ return _M_rep()->_M_length; }
size_type
max_size() const noexcept
{ return _Rep::_S_max_size; }
void
resize(size_type __n, _CharT __c);
void
resize(size_type __n)
;
void
shrink_to_fit() noexcept
{
if (capacity() > size())
{
try
{ reserve(0); }
catch(...)
{ }
}
}
size_type
capacity() const noexcept
{ return _M_rep()->_M_capacity; }
void
reserve(size_type __res_arg = 0);
void
clear()
;
bool
empty() const noexcept
{ return this->size() == 0; }
const_reference
operator[] (size_type __pos) const noexcept
{
;
return _M_data()[__pos];
}
reference
operator[](size_type __pos)
{
;
;
_M_leak();
return _M_data()[__pos];
}
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];
}
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());
_M_leak();
return _M_data()[__n];
}
reference
front()
{ return operator[](0); }
const_reference
front() const noexcept
{ return operator[](0); }
reference
back()
{ return operator[](this->size() - 1); }
const_reference
back() const noexcept
{ return operator[](this->size() - 1); }
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()); }
basic_string&
append(const basic_string& __str);
basic_string&
append(const basic_string& __str, size_type __pos, size_type __n);
basic_string&
append(const _CharT* __s, size_type __n);
basic_string&
append(const _CharT* __s)
;
basic_string&
append(size_type __n, _CharT __c);
basic_string&
append(initializer_list<_CharT> __l)
;
template<class _InputIterator>
basic_string&
append(_InputIterator __first, _InputIterator __last)
;
void
push_back(_CharT __c)
;
basic_string&
assign(const basic_string& __str);
basic_string&
assign(basic_string&& __str)
;
basic_string&
assign(const basic_string& __str, size_type __pos, size_type __n)
;
basic_string&
assign(const _CharT* __s, size_type __n);
basic_string&
assign(const _CharT* __s)
;
basic_string&
assign(size_type __n, _CharT __c)
;
template<class _InputIterator>
basic_string&
assign(_InputIterator __first, _InputIterator __last)
;
basic_string&
assign(initializer_list<_CharT> __l)
;
void
insert(iterator __p, size_type __n, _CharT __c)
;
template<class _InputIterator>
void
insert(iterator __p, _InputIterator __beg, _InputIterator __end)
;
void
insert(iterator __p, initializer_list<_CharT> __l)
;
basic_string&
insert(size_type __pos1, const basic_string& __str)
;
basic_string&
insert(size_type __pos1, const basic_string& __str,
size_type __pos2, size_type __n)
;
basic_string&
insert(size_type __pos, const _CharT* __s, size_type __n);
basic_string&
insert(size_type __pos, const _CharT* __s)
;
basic_string&
insert(size_type __pos, size_type __n, _CharT __c)
;
iterator
insert(iterator __p, _CharT __c)
;
basic_string&
erase(size_type __pos = 0, size_type __n = npos)
;
iterator
erase(iterator __position)
;
iterator
erase(iterator __first, iterator __last);
void
pop_back()
;
basic_string&
replace(size_type __pos, size_type __n, const basic_string& __str)
;
basic_string&
replace(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2)
;
basic_string&
replace(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2);
basic_string&
replace(size_type __pos, size_type __n1, const _CharT* __s)
;
basic_string&
replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
;
basic_string&
replace(iterator __i1, iterator __i2, const basic_string& __str)
;
basic_string&
replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
;
basic_string&
replace(iterator __i1, iterator __i2, const _CharT* __s)
;
basic_string&
replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
;
template<class _InputIterator>
basic_string&
replace(iterator __i1, iterator __i2,
_InputIterator __k1, _InputIterator __k2)
;
basic_string&
replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
;
basic_string&
replace(iterator __i1, iterator __i2,
const _CharT* __k1, const _CharT* __k2)
;
basic_string&
replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
;
basic_string&
replace(iterator __i1, iterator __i2,
const_iterator __k1, const_iterator __k2)
;
basic_string& replace(iterator __i1, iterator __i2,
initializer_list<_CharT> __l)
;
private:
template<class _Integer>
basic_string&
_M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n,
_Integer __val, __true_type)
;
template<class _InputIterator>
basic_string&
_M_replace_dispatch(iterator __i1, 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_safe(size_type __pos1, size_type __n1, const _CharT* __s,
size_type __n2);
template<class _InIterator>
static _CharT*
_S_construct_aux(_InIterator __beg, _InIterator __end,
const _Alloc& __a, __false_type)
;
template<class _Integer>
static _CharT*
_S_construct_aux(_Integer __beg, _Integer __end,
const _Alloc& __a, __true_type)
;
static _CharT*
_S_construct_aux_2(size_type __req, _CharT __c, const _Alloc& __a)
;
template<class _InIterator>
static _CharT*
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a)
;
template<class _InIterator>
static _CharT*
_S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
input_iterator_tag);
template<class _FwdIterator>
static _CharT*
_S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a,
forward_iterator_tag);
static _CharT*
_S_construct(size_type __req, _CharT __c, const _Alloc& __a);
public:
size_type
copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
void
swap(basic_string& __s);
const _CharT*
c_str() const noexcept
{ return _M_data(); }
const _CharT*
data() const noexcept
{ return _M_data(); }
allocator_type
get_allocator() const noexcept
{ return _M_dataplus; }
size_type
find(const _CharT* __s, size_type __pos, size_type __n) const;
size_type
find(const basic_string& __str, size_type __pos = 0) const
noexcept
{ return this->find(__str.data(), __pos, __str.size()); }
size_type
find(const _CharT* __s, size_type __pos = 0) const
{
;
return this->find(__s, __pos, traits_type::length(__s));
}
size_type
find(_CharT __c, size_type __pos = 0) const noexcept;
size_type
rfind(const basic_string& __str, size_type __pos = npos) const
noexcept
{ return this->rfind(__str.data(), __pos, __str.size()); }
size_type
rfind(const _CharT* __s, size_type __pos, size_type __n) const;
size_type
rfind(const _CharT* __s, size_type __pos = npos) const
;
size_type
rfind(_CharT __c, size_type __pos = npos) const noexcept;
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()); }
size_type
find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
size_type
find_first_of(const _CharT* __s, size_type __pos = 0) const
;
size_type
find_first_of(_CharT __c, size_type __pos = 0) const noexcept
{ return this->find(__c, __pos); }
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()); }
size_type
find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
size_type
find_last_of(const _CharT* __s, size_type __pos = npos) const
;
size_type
find_last_of(_CharT __c, size_type __pos = npos) const noexcept
{ return this->rfind(__c, __pos); }
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()); }
size_type
find_first_not_of(const _CharT* __s, size_type __pos,
size_type __n) const;
size_type
find_first_not_of(const _CharT* __s, size_type __pos = 0) const
;
size_type
find_first_not_of(_CharT __c, size_type __pos = 0) const
noexcept;
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()); }
size_type
find_last_not_of(const _CharT* __s, size_type __pos,
size_type __n) const;
size_type
find_last_not_of(const _CharT* __s, size_type __pos = npos) const
;
size_type
find_last_not_of(_CharT __c, size_type __pos = npos) const
noexcept;
basic_string
substr(size_type __pos = 0, size_type __n = npos) const
;
int
compare(const basic_string& __str) const
;
int
compare(size_type __pos, size_type __n, const basic_string& __str) const;
int
compare(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2) const;
int
compare(const _CharT* __s) const;
int
compare(size_type __pos, size_type __n1, const _CharT* __s) const;
int
compare(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2) const;
};
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)
;
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>
basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
basic_string<_CharT, _Traits, _Alloc>&& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
basic_string<_CharT, _Traits, _Alloc>&& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const _CharT* __lhs,
basic_string<_CharT, _Traits, _Alloc>&& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(_CharT __lhs,
basic_string<_CharT, _Traits, _Alloc>&& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
_CharT __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
operator==(const basic_string<_CharT>& __lhs,
const basic_string<_CharT>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator==(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator!=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator<=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
bool
operator>=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
template<typename _CharT, typename _Traits, typename _Alloc>
void
swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
basic_string<_CharT, _Traits, _Alloc>& __rhs)
;
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);
template<typename _CharT, typename _Traits, typename _Alloc>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os,
const basic_string<_CharT, _Traits, _Alloc>& __str)
;
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);
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Alloc>& __str)
;
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)
;
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>&& __is,
basic_string<_CharT, _Traits, _Alloc>& __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);
}
#define _STRING_CONVERSIONS_H 1
#undef __need_mbstate_t
#undef __need_wint_t
#define _STDIO_H 1
extern "C" {
#define __need_size_t
#define __need_NULL
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define __need_FILE
#define __need___FILE
#undef __need_FILE
#undef __need___FILE
#define _STDIO_USES_IOSTREAM
#define _IO_STDIO_H
#define _G_config_h 1
#define __need_size_t
#define __need_NULL
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define __need_mbstate_t
#undef __need_mbstate_t
#undef __need_wint_t
typedef struct
{
__off_t __pos;
__mbstate_t __state;
} _G_fpos_t;
typedef struct
{
__off64_t __pos;
__mbstate_t __state;
} _G_fpos64_t;
#define _G_va_list __gnuc_va_list
#define _G_HAVE_MMAP 1
#define _G_HAVE_MREMAP 1
#define _G_IO_IO_FILE_VERSION 0x20001
#define _G_HAVE_ST_BLKSIZE defined (_STATBUF_ST_BLKSIZE)
#define _G_BUFSIZ 8192
#define _IO_fpos_t _G_fpos_t
#define _IO_fpos64_t _G_fpos64_t
#define _IO_size_t size_t
#define _IO_ssize_t __ssize_t
#define _IO_off_t __off_t
#define _IO_off64_t __off64_t
#define _IO_pid_t __pid_t
#define _IO_uid_t __uid_t
#define _IO_iconv_t _G_iconv_t
#define _IO_HAVE_ST_BLKSIZE _G_HAVE_ST_BLKSIZE
#define _IO_BUFSIZ _G_BUFSIZ
#define _IO_va_list _G_va_list
#define _IO_wint_t wint_t
#define __need___va_list
#undef __need___va_list
#undef _IO_va_list
#define _IO_va_list __gnuc_va_list
#define _IO_UNIFIED_JUMPTABLES 1
#define EOF (-1)
#define _IOS_INPUT 1
#define _IOS_OUTPUT 2
#define _IOS_ATEND 4
#define _IOS_APPEND 8
#define _IOS_TRUNC 16
#define _IOS_NOCREATE 32
#define _IOS_NOREPLACE 64
#define _IOS_BIN 128
#define _IO_MAGIC 0xFBAD0000
#define _OLD_STDIO_MAGIC 0xFABC0000
#define _IO_MAGIC_MASK 0xFFFF0000
#define _IO_USER_BUF 1
#define _IO_UNBUFFERED 2
#define _IO_NO_READS 4
#define _IO_NO_WRITES 8
#define _IO_EOF_SEEN 0x10
#define _IO_ERR_SEEN 0x20
#define _IO_DELETE_DONT_CLOSE 0x40
#define _IO_LINKED 0x80
#define _IO_IN_BACKUP 0x100
#define _IO_LINE_BUF 0x200
#define _IO_TIED_PUT_GET 0x400
#define _IO_CURRENTLY_PUTTING 0x800
#define _IO_IS_APPENDING 0x1000
#define _IO_IS_FILEBUF 0x2000
#define _IO_BAD_SEEN 0x4000
#define _IO_USER_LOCK 0x8000
#define _IO_FLAGS2_MMAP 1
#define _IO_FLAGS2_NOTCANCEL 2
#define _IO_FLAGS2_USER_WBUF 8
#define _IO_SKIPWS 01
#define _IO_LEFT 02
#define _IO_RIGHT 04
#define _IO_INTERNAL 010
#define _IO_DEC 020
#define _IO_OCT 040
#define _IO_HEX 0100
#define _IO_SHOWBASE 0200
#define _IO_SHOWPOINT 0400
#define _IO_UPPERCASE 01000
#define _IO_SHOWPOS 02000
#define _IO_SCIENTIFIC 04000
#define _IO_FIXED 010000
#define _IO_UNITBUF 020000
#define _IO_STDIO 040000
#define _IO_DONT_CLOSE 0100000
#define _IO_BOOLALPHA 0200000
struct _IO_jump_t; struct _IO_FILE;
typedef void _IO_lock_t;
struct _IO_marker {
struct _IO_marker *_next;
struct _IO_FILE *_sbuf;
int _pos;
};
enum __codecvt_result
{
__codecvt_ok,
__codecvt_partial,
__codecvt_error,
__codecvt_noconv
};
struct _IO_FILE {
int _flags;
#define _IO_file_flags _flags
char* _IO_read_ptr;
char* _IO_read_end;
char* _IO_read_base;
char* _IO_write_base;
char* _IO_write_ptr;
char* _IO_write_end;
char* _IO_buf_base;
char* _IO_buf_end;
char *_IO_save_base;
char *_IO_backup_base;
char *_IO_save_end;
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
int _flags2;
__off_t _old_offset;
#define __HAVE_COLUMN
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
_IO_lock_t *_lock;
__off64_t _offset;
void *__pad1;
void *__pad2;
void *__pad3;
void *__pad4;
size_t __pad5;
int _mode;
char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
};
struct _IO_FILE_plus;
extern struct _IO_FILE_plus _IO_2_1_stdin_;
extern struct _IO_FILE_plus _IO_2_1_stdout_;
extern struct _IO_FILE_plus _IO_2_1_stderr_;
#define _IO_stdin ((_IO_FILE*)(&_IO_2_1_stdin_))
#define _IO_stdout ((_IO_FILE*)(&_IO_2_1_stdout_))
#define _IO_stderr ((_IO_FILE*)(&_IO_2_1_stderr_))
typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
typedef __ssize_t __io_write_fn (void *__cookie, const char *__buf,
size_t __n);
typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
typedef int __io_close_fn (void *__cookie);
typedef __io_read_fn cookie_read_function_t;
typedef __io_write_fn cookie_write_function_t;
typedef __io_seek_fn cookie_seek_function_t;
typedef __io_close_fn cookie_close_function_t;
typedef struct
{
__io_read_fn *read;
__io_write_fn *write;
__io_seek_fn *seek;
__io_close_fn *close;
} _IO_cookie_io_functions_t;
typedef _IO_cookie_io_functions_t cookie_io_functions_t;
struct _IO_cookie_file;
extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
void *__cookie, _IO_cookie_io_functions_t __fns);
extern "C" {
extern int __underflow (_IO_FILE *);
extern int __uflow (_IO_FILE *);
extern int __overflow (_IO_FILE *, int);
#define _IO_BE(expr,res) __builtin_expect ((expr), res)
#define _IO_getc_unlocked(_fp) (_IO_BE ((_fp)->_IO_read_ptr >= (_fp)->_IO_read_end, 0) ? __uflow (_fp) : *(unsigned char *) (_fp)->_IO_read_ptr++)
#define _IO_peekc_unlocked(_fp) (_IO_BE ((_fp)->_IO_read_ptr >= (_fp)->_IO_read_end, 0) && __underflow (_fp) == EOF ? EOF : *(unsigned char *) (_fp)->_IO_read_ptr)
#define _IO_putc_unlocked(_ch,_fp) (_IO_BE ((_fp)->_IO_write_ptr >= (_fp)->_IO_write_end, 0) ? __overflow (_fp, (unsigned char) (_ch)) : (unsigned char) (*(_fp)->_IO_write_ptr++ = (_ch)))
#define _IO_feof_unlocked(__fp) (((__fp)->_flags & _IO_EOF_SEEN) != 0)
#define _IO_ferror_unlocked(__fp) (((__fp)->_flags & _IO_ERR_SEEN) != 0)
extern int _IO_getc (_IO_FILE *__fp);
extern int _IO_putc (int __c, _IO_FILE *__fp);
extern int _IO_feof (_IO_FILE *__fp) throw ();
extern int _IO_ferror (_IO_FILE *__fp) throw ();
extern int _IO_peekc_locked (_IO_FILE *__fp);
#define _IO_PENDING_OUTPUT_COUNT(_fp) ((_fp)->_IO_write_ptr - (_fp)->_IO_write_base)
extern void _IO_flockfile (_IO_FILE *) throw ();
extern void _IO_funlockfile (_IO_FILE *) throw ();
extern int _IO_ftrylockfile (_IO_FILE *) throw ();
#define _IO_peekc(_fp) _IO_peekc_unlocked (_fp)
#define _IO_flockfile(_fp)
#define _IO_funlockfile(_fp)
#define _IO_ftrylockfile(_fp)
#define _IO_cleanup_region_start(_fct,_fp)
#define _IO_cleanup_region_end(_Doit)
extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
__gnuc_va_list, int *__restrict);
extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
__gnuc_va_list);
extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);
extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);
extern void _IO_free_backup_area (_IO_FILE *) throw ();
}
typedef __gnuc_va_list va_list;
#define _VA_LIST_DEFINED
typedef _G_fpos_t fpos_t;
typedef _G_fpos64_t fpos64_t;
#define _IOFBF 0
#define _IOLBF 1
#define _IONBF 2
#define BUFSIZ _IO_BUFSIZ
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2
#define SEEK_DATA 3
#define SEEK_HOLE 4
#define P_tmpdir "/tmp"
#define L_tmpnam 20
#define TMP_MAX 238328
#define FILENAME_MAX 4096
#define L_ctermid 9
#define L_cuserid 9
#undef FOPEN_MAX
#define FOPEN_MAX 16
extern struct _IO_FILE *stdin;
extern struct _IO_FILE *stdout;
extern struct _IO_FILE *stderr;
#define stdin stdin
#define stdout stdout
#define stderr stderr
extern int remove (const char *__filename) throw ();
extern int rename (const char *__old, const char *__new) throw ();
extern int renameat (int __oldfd, const char *__old, int __newfd,
const char *__new) throw ();
extern FILE *tmpfile (void) ;
extern FILE *tmpfile64 (void) ;
extern char *tmpnam (char *__s) throw () ;
extern char *tmpnam_r (char *__s) throw () ;
extern char *tempnam (const char *__dir, const char *__pfx)
throw () __attribute__ ((__malloc__)) ;
extern int fclose (FILE *__stream);
extern int fflush (FILE *__stream);
extern int fflush_unlocked (FILE *__stream);
extern int fcloseall (void);
extern FILE *fopen (const char *__restrict __filename,
const char *__restrict __modes) ;
extern FILE *freopen (const char *__restrict __filename,
const char *__restrict __modes,
FILE *__restrict __stream) ;
extern FILE *fopen64 (const char *__restrict __filename,
const char *__restrict __modes) ;
extern FILE *freopen64 (const char *__restrict __filename,
const char *__restrict __modes,
FILE *__restrict __stream) ;
extern FILE *fdopen (int __fd, const char *__modes) throw () ;
extern FILE *fopencookie (void *__restrict __magic_cookie,
const char *__restrict __modes,
_IO_cookie_io_functions_t __io_funcs) throw () ;
extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
throw () ;
extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ;
extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();
extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
int __modes, size_t __n) throw ();
extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
size_t __size) throw ();
extern void setlinebuf (FILE *__stream) throw ();
extern int fprintf (FILE *__restrict __stream,
const char *__restrict __format, ...);
extern int printf (const char *__restrict __format, ...);
extern int sprintf (char *__restrict __s,
const char *__restrict __format, ...) throw ();
extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg);
extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
extern int vsprintf (char *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg) throw ();
extern int snprintf (char *__restrict __s, size_t __maxlen,
const char *__restrict __format, ...)
throw () __attribute__ ((__format__ (__printf__, 3, 4)));
extern int vsnprintf (char *__restrict __s, size_t __maxlen,
const char *__restrict __format, __gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__printf__, 3, 0)));
extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
__gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__printf__, 2, 0))) ;
extern int __asprintf (char **__restrict __ptr,
const char *__restrict __fmt, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
extern int asprintf (char **__restrict __ptr,
const char *__restrict __fmt, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
extern int vdprintf (int __fd, const char *__restrict __fmt,
__gnuc_va_list __arg)
__attribute__ ((__format__ (__printf__, 2, 0)));
extern int dprintf (int __fd, const char *__restrict __fmt, ...)
__attribute__ ((__format__ (__printf__, 2, 3)));
extern int fscanf (FILE *__restrict __stream,
const char *__restrict __format, ...) ;
extern int scanf (const char *__restrict __format, ...) ;
extern int sscanf (const char *__restrict __s,
const char *__restrict __format, ...) throw ();
extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg)
__attribute__ ((__format__ (__scanf__, 2, 0))) ;
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
__attribute__ ((__format__ (__scanf__, 1, 0))) ;
extern int vsscanf (const char *__restrict __s,
const char *__restrict __format, __gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
extern int fgetc (FILE *__stream);
extern int getc (FILE *__stream);
extern int getchar (void);
#define getc(_fp) _IO_getc (_fp)
extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
extern int fgetc_unlocked (FILE *__stream);
extern int fputc (int __c, FILE *__stream);
extern int putc (int __c, FILE *__stream);
extern int putchar (int __c);
#define putc(_ch,_fp) _IO_putc (_ch, _fp)
extern int fputc_unlocked (int __c, FILE *__stream);
extern int putc_unlocked (int __c, FILE *__stream);
extern int putchar_unlocked (int __c);
extern int getw (FILE *__stream);
extern int putw (int __w, FILE *__stream);
extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
;
extern char *gets (char *__s) __attribute__ ((__deprecated__));
extern char *fgets_unlocked (char *__restrict __s, int __n,
FILE *__restrict __stream) ;
extern __ssize_t __getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) ;
extern __ssize_t getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) ;
extern __ssize_t getline (char **__restrict __lineptr,
size_t *__restrict __n,
FILE *__restrict __stream) ;
extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
extern int puts (const char *__s);
extern int ungetc (int __c, FILE *__stream);
extern size_t fread (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite (const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __s);
extern int fputs_unlocked (const char *__restrict __s,
FILE *__restrict __stream);
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream);
extern int fseek (FILE *__stream, long int __off, int __whence);
extern long int ftell (FILE *__stream) ;
extern void rewind (FILE *__stream);
extern int fseeko (FILE *__stream, __off_t __off, int __whence);
extern __off_t ftello (FILE *__stream) ;
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
extern int fsetpos (FILE *__stream, const fpos_t *__pos);
extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
extern __off64_t ftello64 (FILE *__stream) ;
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos);
extern void clearerr (FILE *__stream) throw ();
extern int feof (FILE *__stream) throw () ;
extern int ferror (FILE *__stream) throw () ;
extern void clearerr_unlocked (FILE *__stream) throw ();
extern int feof_unlocked (FILE *__stream) throw () ;
extern int ferror_unlocked (FILE *__stream) throw () ;
extern void perror (const char *__s);
extern int sys_nerr;
extern const char *const sys_errlist[];
extern int _sys_nerr;
extern const char *const _sys_errlist[];
extern int fileno (FILE *__stream) throw () ;
extern int fileno_unlocked (FILE *__stream) throw () ;
extern FILE *popen (const char *__command, const char *__modes) ;
extern int pclose (FILE *__stream);
extern char *ctermid (char *__s) throw ();
extern char *cuserid (char *__s);
struct obstack;
extern int obstack_printf (struct obstack *__restrict __obstack,
const char *__restrict __format, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3)));
extern int obstack_vprintf (struct obstack *__restrict __obstack,
const char *__restrict __format,
__gnuc_va_list __args)
throw () __attribute__ ((__format__ (__printf__, 2, 0)));
extern void flockfile (FILE *__stream) throw ();
extern int ftrylockfile (FILE *__stream) throw () ;
extern void funlockfile (FILE *__stream) throw ();
}
#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
{
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;
}
#define _ERRNO_H 1
extern "C" {
#undef EDOM
#undef EILSEQ
#undef ERANGE
#define _ASM_GENERIC_ERRNO_H
#define _ASM_GENERIC_ERRNO_BASE_H
#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 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
#define ENOTSUP EOPNOTSUPP
extern int *__errno_location (void) throw () __attribute__ ((__const__));
#define errno (*__errno_location ())
#undef __need_Emath
extern char *program_invocation_name, *program_invocation_short_name;
}
typedef int error_t;
#define __error_t_defined 1
#undef __need_error_t
#define _GLIBCXX_CERRNO 1
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)
;
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, ...)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
int
stoi(const string& __str, size_t* __idx = 0, int __base = 10)
;
long
stol(const string& __str, size_t* __idx = 0, int __base = 10)
;
unsigned long
stoul(const string& __str, size_t* __idx = 0, int __base = 10)
;
long long
stoll(const string& __str, size_t* __idx = 0, int __base = 10)
;
unsigned long long
stoull(const string& __str, size_t* __idx = 0, int __base = 10)
;
float
stof(const string& __str, size_t* __idx = 0)
;
double
stod(const string& __str, size_t* __idx = 0)
;
long double
stold(const string& __str, size_t* __idx = 0)
;
string
to_string(int __val)
;
string
to_string(unsigned __val)
;
string
to_string(long __val)
;
string
to_string(unsigned long __val)
;
string
to_string(long long __val)
;
string
to_string(unsigned long long __val)
;
string
to_string(float __val)
;
string
to_string(double __val)
;
string
to_string(long double __val)
;
int
stoi(const wstring& __str, size_t* __idx = 0, int __base = 10)
;
long
stol(const wstring& __str, size_t* __idx = 0, int __base = 10)
;
unsigned long
stoul(const wstring& __str, size_t* __idx = 0, int __base = 10)
;
long long
stoll(const wstring& __str, size_t* __idx = 0, int __base = 10)
;
unsigned long long
stoull(const wstring& __str, size_t* __idx = 0, int __base = 10)
;
float
stof(const wstring& __str, size_t* __idx = 0)
;
double
stod(const wstring& __str, size_t* __idx = 0)
;
long double
stold(const wstring& __str, size_t* __idx = 0)
;
wstring
to_wstring(int __val)
;
wstring
to_wstring(unsigned __val)
;
wstring
to_wstring(long __val)
;
wstring
to_wstring(unsigned long __val)
;
wstring
to_wstring(long long __val)
;
wstring
to_wstring(unsigned long long __val)
;
wstring
to_wstring(float __val)
;
wstring
to_wstring(double __val)
;
wstring
to_wstring(long double __val)
;
}
#define _FUNCTIONAL_HASH_H 1
#define _HASH_BYTES_H 1
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);
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Result, typename _Arg>
struct __hash_base
{
typedef _Result result_type;
typedef _Arg argument_type;
};
template<typename _Tp>
struct hash;
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); } };
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); } };
#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))
;
template<typename _Tp>
static size_t
hash(const _Tp& __val)
;
template<typename _Tp>
static size_t
__hash_combine(const _Tp& __val, size_t __hash)
;
};
struct _Fnv_hash_impl
{
static size_t
hash(const void* __ptr, size_t __clength,
size_t __seed = static_cast<size_t>(2166136261UL))
;
template<typename _Tp>
static size_t
hash(const _Tp& __val)
;
template<typename _Tp>
static size_t
__hash_combine(const _Tp& __val, size_t __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
{ };
}
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
{ };
}
#define _BASIC_STRING_TCC 1
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>::
_Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4;
template<typename _CharT, typename _Traits, typename _Alloc>
const _CharT
basic_string<_CharT, _Traits, _Alloc>::
_Rep::_S_terminal = _CharT();
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>
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[
(sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) /
sizeof(size_type)];
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>
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
{
;
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
{
;
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
{
;
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
{
;
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
{
;
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
{
;
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&);
}
namespace std __attribute__ ((__visibility__ ("default")))
{
class logic_error : public exception
{
string _M_msg;
public:
explicit
logic_error(const string& __arg);
virtual ~logic_error() noexcept;
virtual const char*
what() const noexcept;
};
class domain_error : public logic_error
{
public:
explicit domain_error(const string& __arg);
virtual ~domain_error() noexcept;
};
class invalid_argument : public logic_error
{
public:
explicit invalid_argument(const string& __arg);
virtual ~invalid_argument() noexcept;
};
class length_error : public logic_error
{
public:
explicit length_error(const string& __arg);
virtual ~length_error() noexcept;
};
class out_of_range : public logic_error
{
public:
explicit out_of_range(const string& __arg);
virtual ~out_of_range() noexcept;
};
class runtime_error : public exception
{
string _M_msg;
public:
explicit
runtime_error(const string& __arg);
virtual ~runtime_error() noexcept;
virtual const char*
what() const noexcept;
};
class range_error : public runtime_error
{
public:
explicit range_error(const string& __arg);
virtual ~range_error() noexcept;
};
class overflow_error : public runtime_error
{
public:
explicit overflow_error(const string& __arg);
virtual ~overflow_error() noexcept;
};
class underflow_error : public runtime_error
{
public:
explicit underflow_error(const string& __arg);
virtual ~underflow_error() noexcept;
};
}
#define _TYPEINFO
#pragma GCC visibility push(default)
extern "C++" {
namespace __cxxabiv1
{
class __class_type_info;
}
#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; }
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));
}
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) ;
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
#define BOOST_ASIO_DETAIL_NONCOPYABLE_HPP
namespace boost {
namespace asio {
namespace detail {
class noncopyable
{
protected:
noncopyable() ;
~noncopyable() ;
private:
noncopyable(const noncopyable&);
const noncopyable& operator=(const noncopyable&);
};
}
using boost::asio::detail::noncopyable;
}
}
#define BOOST_ASIO_DETAIL_WRAPPED_HANDLER_HPP
#define BOOST_ASIO_DETAIL_BIND_HANDLER_HPP
#define BOOST_ASIO_DETAIL_HANDLER_ALLOC_HELPERS_HPP
#define BOOST_ASIO_DETAIL_ADDRESSOF_HPP
#define _GLIBCXX_MEMORY 1
#define _STL_CONSTRUCT_H 1
#define _EXT_ALLOC_TRAITS_H 1
#define _ALLOC_TRAITS_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc, typename _Tp>
class __alloctr_rebind_helper
{
template<typename _Alloc2, typename _Tp2>
static constexpr true_type
_S_chk(typename _Alloc2::template rebind<_Tp2>::other*);
template<typename, typename>
static constexpr false_type
_S_chk(...);
public:
using __type = decltype(_S_chk<_Alloc, _Tp>(nullptr));
};
template<typename _Alloc, typename _Tp,
bool = __alloctr_rebind_helper<_Alloc, _Tp>::__type::value>
struct __alloctr_rebind;
template<typename _Alloc, typename _Tp>
struct __alloctr_rebind<_Alloc, _Tp, true>
{
typedef typename _Alloc::template rebind<_Tp>::other __type;
};
template<template<typename, typename...> class _Alloc, typename _Tp,
typename _Up, typename... _Args>
struct __alloctr_rebind<_Alloc<_Up, _Args...>, _Tp, false>
{
typedef _Alloc<_Tp, _Args...> __type;
};
template<typename _Ptr, typename _Tp>
using __alloc_rebind = typename __alloctr_rebind<_Ptr, _Tp>::__type;
template<typename _Alloc>
struct allocator_traits
{
typedef _Alloc allocator_type;
typedef typename _Alloc::value_type value_type;
#define _GLIBCXX_ALLOC_TR_NESTED_TYPE(_NTYPE,_ALT) private: template<typename _Tp> static typename _Tp::_NTYPE _S_ ##_NTYPE ##_helper(_Tp*); static _ALT _S_ ##_NTYPE ##_helper(...); typedef decltype(_S_ ##_NTYPE ##_helper((_Alloc*)0)) __ ##_NTYPE; public:
private: template<typename _Tp> static typename _Tp::pointer _S_pointer_helper(_Tp*); static value_type* _S_pointer_helper(...); typedef decltype(_S_pointer_helper((_Alloc*)0)) __pointer; public:
typedef __pointer pointer;
private: template<typename _Tp> static typename _Tp::const_pointer _S_const_pointer_helper(_Tp*); static typename pointer_traits<pointer>::template rebind<const value_type> _S_const_pointer_helper(...); typedef decltype(_S_const_pointer_helper((_Alloc*)0)) __const_pointer; public:
typedef __const_pointer const_pointer;
private: template<typename _Tp> static typename _Tp::void_pointer _S_void_pointer_helper(_Tp*); static typename pointer_traits<pointer>::template rebind<void> _S_void_pointer_helper(...); typedef decltype(_S_void_pointer_helper((_Alloc*)0)) __void_pointer; public:
typedef __void_pointer void_pointer;
private: template<typename _Tp> static typename _Tp::const_void_pointer _S_const_void_pointer_helper(_Tp*); static typename pointer_traits<pointer>::template rebind<const void> _S_const_void_pointer_helper(...); typedef decltype(_S_const_void_pointer_helper((_Alloc*)0)) __const_void_pointer; public:
typedef __const_void_pointer const_void_pointer;
private: template<typename _Tp> static typename _Tp::difference_type _S_difference_type_helper(_Tp*); static typename pointer_traits<pointer>::difference_type _S_difference_type_helper(...); typedef decltype(_S_difference_type_helper((_Alloc*)0)) __difference_type; public:
typedef __difference_type difference_type;
private: template<typename _Tp> static typename _Tp::size_type _S_size_type_helper(_Tp*); static typename make_unsigned<difference_type>::type _S_size_type_helper(...); typedef decltype(_S_size_type_helper((_Alloc*)0)) __size_type; public:
typedef __size_type size_type;
private: template<typename _Tp> static typename _Tp::propagate_on_container_copy_assignment _S_propagate_on_container_copy_assignment_helper(_Tp*); static false_type _S_propagate_on_container_copy_assignment_helper(...); typedef decltype(_S_propagate_on_container_copy_assignment_helper((_Alloc*)0)) __propagate_on_container_copy_assignment; public:
typedef __propagate_on_container_copy_assignment
propagate_on_container_copy_assignment;
private: template<typename _Tp> static typename _Tp::propagate_on_container_move_assignment _S_propagate_on_container_move_assignment_helper(_Tp*); static false_type _S_propagate_on_container_move_assignment_helper(...); typedef decltype(_S_propagate_on_container_move_assignment_helper((_Alloc*)0)) __propagate_on_container_move_assignment; public:
typedef __propagate_on_container_move_assignment
propagate_on_container_move_assignment;
private: template<typename _Tp> static typename _Tp::propagate_on_container_swap _S_propagate_on_container_swap_helper(_Tp*); static false_type _S_propagate_on_container_swap_helper(...); typedef decltype(_S_propagate_on_container_swap_helper((_Alloc*)0)) __propagate_on_container_swap; public:
typedef __propagate_on_container_swap propagate_on_container_swap;
#undef _GLIBCXX_ALLOC_TR_NESTED_TYPE
template<typename _Tp>
using rebind_alloc = typename __alloctr_rebind<_Alloc, _Tp>::__type;
template<typename _Tp>
using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;
private:
template<typename _Alloc2>
struct __allocate_helper
{
template<typename _Alloc3,
typename = decltype(std::declval<_Alloc3*>()->allocate(
std::declval<size_type>(),
std::declval<const_void_pointer>()))>
static true_type __test(int);
template<typename>
static false_type __test(...);
using type = decltype(__test<_Alloc>(0));
};
template<typename _Alloc2>
using __has_allocate = typename __allocate_helper<_Alloc2>::type;
template<typename _Alloc2,
typename = _Require<__has_allocate<_Alloc2>>>
static pointer
_S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint)
;
template<typename _Alloc2, typename _UnusedHint,
typename = _Require<__not_<__has_allocate<_Alloc2>>>>
static pointer
_S_allocate(_Alloc2& __a, size_type __n, _UnusedHint)
;
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)
;
template<typename _Tp, typename... _Args>
static
_Require<__and_<__not_<__has_construct<_Tp, _Args...>>,
is_constructible<_Tp, _Args...>>>
_S_construct(_Alloc&, _Tp* __p, _Args&&... __args)
;
template<typename _Tp>
struct __destroy_helper
{
template<typename _Alloc2,
typename = decltype(std::declval<_Alloc2*>()->destroy(
std::declval<_Tp*>()))>
static true_type __test(int);
template<typename>
static false_type __test(...);
using type = decltype(__test<_Alloc>(0));
};
template<typename _Tp>
using __has_destroy = typename __destroy_helper<_Tp>::type;
template<typename _Tp>
static _Require<__has_destroy<_Tp>>
_S_destroy(_Alloc& __a, _Tp* __p)
;
template<typename _Tp>
static _Require<__not_<__has_destroy<_Tp>>>
_S_destroy(_Alloc&, _Tp* __p)
;
template<typename _Alloc2>
struct __maxsize_helper
{
template<typename _Alloc3,
typename = decltype(std::declval<_Alloc3*>()->max_size())>
static true_type __test(int);
template<typename>
static false_type __test(...);
using type = decltype(__test<_Alloc2>(0));
};
template<typename _Alloc2>
using __has_max_size = typename __maxsize_helper<_Alloc2>::type;
template<typename _Alloc2,
typename = _Require<__has_max_size<_Alloc2>>>
static size_type
_S_max_size(_Alloc2& __a, int)
;
template<typename _Alloc2,
typename = _Require<__not_<__has_max_size<_Alloc2>>>>
static size_type
_S_max_size(_Alloc2&, ...)
;
template<typename _Alloc2>
struct __select_helper
{
template<typename _Alloc3, typename
= decltype(std::declval<_Alloc3*>()
->select_on_container_copy_construction())>
static true_type __test(int);
template<typename>
static false_type __test(...);
using type = decltype(__test<_Alloc2>(0));
};
template<typename _Alloc2>
using __has_soccc = typename __select_helper<_Alloc2>::type;
template<typename _Alloc2,
typename = _Require<__has_soccc<_Alloc2>>>
static _Alloc2
_S_select(_Alloc2& __a, int)
;
template<typename _Alloc2,
typename = _Require<__not_<__has_soccc<_Alloc2>>>>
static _Alloc2
_S_select(_Alloc2& __a, ...)
;
public:
static pointer
allocate(_Alloc& __a, size_type __n)
;
static pointer
allocate(_Alloc& __a, size_type __n, const_void_pointer __hint)
;
static void deallocate(_Alloc& __a, pointer __p, size_type __n)
;
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)...); }
template <class _Tp>
static void destroy(_Alloc& __a, _Tp* __p)
{ _S_destroy(__a, __p); }
static size_type max_size(const _Alloc& __a) noexcept
{ return _S_max_size(__a, 0); }
static _Alloc
select_on_container_copy_construction(const _Alloc& __rhs)
{ return _S_select(__rhs, 0); }
};
template<typename _Alloc>
void
__do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type)
;
template<typename _Alloc>
void
__do_alloc_on_copy(_Alloc&, const _Alloc&, false_type)
;
template<typename _Alloc>
void __alloc_on_copy(_Alloc& __one, const _Alloc& __two)
;
template<typename _Alloc>
_Alloc __alloc_on_copy(const _Alloc& __a)
;
template<typename _Alloc>
void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type)
;
template<typename _Alloc>
void __do_alloc_on_move(_Alloc&, _Alloc&, false_type)
;
template<typename _Alloc>
void __alloc_on_move(_Alloc& __one, _Alloc& __two)
;
template<typename _Alloc>
void __do_alloc_on_swap(_Alloc& __one, _Alloc& __two, true_type)
;
template<typename _Alloc>
void __do_alloc_on_swap(_Alloc&, _Alloc&, false_type)
;
template<typename _Alloc>
void __alloc_on_swap(_Alloc& __one, _Alloc& __two)
;
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>
{ };
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc>
struct __allocator_always_compares_equal : std::false_type { };
template<typename _Tp>
struct __allocator_always_compares_equal<std::allocator<_Tp>>
: std::true_type { };
template<typename, typename> struct array_allocator;
template<typename _Tp, typename _Array>
struct __allocator_always_compares_equal<array_allocator<_Tp, _Array>>
: std::true_type { };
template<typename> struct bitmap_allocator;
template<typename _Tp>
struct __allocator_always_compares_equal<bitmap_allocator<_Tp>>
: std::true_type { };
template<typename> struct malloc_allocator;
template<typename _Tp>
struct __allocator_always_compares_equal<malloc_allocator<_Tp>>
: std::true_type { };
template<typename> struct mt_allocator;
template<typename _Tp>
struct __allocator_always_compares_equal<mt_allocator<_Tp>>
: std::true_type { };
template<typename> struct new_allocator;
template<typename _Tp>
struct __allocator_always_compares_equal<new_allocator<_Tp>>
: std::true_type { };
template<typename> struct pool_allocator;
template<typename _Tp>
struct __allocator_always_compares_equal<pool_allocator<_Tp>>
: std::true_type { };
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)
;
template<typename _Ptr>
static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
destroy(_Alloc& __a, _Ptr __p)
;
static _Alloc _S_select_on_copy(const _Alloc& __a)
;
static void _S_on_swap(_Alloc& __a, _Alloc& __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 __allocator_always_compares_equal<_Alloc>::value; }
static constexpr bool _S_nothrow_move()
{ return _S_propagate_on_move_assign() || _S_always_equal(); }
static constexpr bool _S_nothrow_swap()
{
using std::swap;
return !_S_propagate_on_swap()
|| noexcept(swap(std::declval<_Alloc&>(), std::declval<_Alloc&>()));
}
template<typename _Tp>
struct rebind
{ typedef typename _Base_type::template rebind_alloc<_Tp> other; };
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _T1, typename... _Args>
void
_Construct(_T1* __p, _Args&&... __args)
;
template<typename _Tp>
void
_Destroy(_Tp* __pointer)
;
template<bool>
struct _Destroy_aux
{
template<typename _ForwardIterator>
static void
__destroy(_ForwardIterator __first, _ForwardIterator __last)
;
};
template<>
struct _Destroy_aux<true>
{
template<typename _ForwardIterator>
static void
__destroy(_ForwardIterator, _ForwardIterator) ;
};
template<typename _ForwardIterator>
void
_Destroy(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Allocator>
void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
_Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Tp>
void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
allocator<_Tp>&)
;
}
#define _STL_UNINITIALIZED_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<bool _TrivialValueTypes>
struct __uninitialized_copy
{
template<typename _InputIterator, typename _ForwardIterator>
static _ForwardIterator
__uninit_copy(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result)
;
};
template<>
struct __uninitialized_copy<true>
{
template<typename _InputIterator, typename _ForwardIterator>
static _ForwardIterator
__uninit_copy(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result)
;
};
template<typename _InputIterator, typename _ForwardIterator>
_ForwardIterator
uninitialized_copy(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result)
;
template<bool _TrivialValueType>
struct __uninitialized_fill
{
template<typename _ForwardIterator, typename _Tp>
static void
__uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x)
;
};
template<>
struct __uninitialized_fill<true>
{
template<typename _ForwardIterator, typename _Tp>
static void
__uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x)
;
};
template<typename _ForwardIterator, typename _Tp>
void
uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x)
;
template<bool _TrivialValueType>
struct __uninitialized_fill_n
{
template<typename _ForwardIterator, typename _Size, typename _Tp>
static _ForwardIterator
__uninit_fill_n(_ForwardIterator __first, _Size __n,
const _Tp& __x)
;
};
template<>
struct __uninitialized_fill_n<true>
{
template<typename _ForwardIterator, typename _Size, typename _Tp>
static _ForwardIterator
__uninit_fill_n(_ForwardIterator __first, _Size __n,
const _Tp& __x)
;
};
template<typename _ForwardIterator, typename _Size, typename _Tp>
_ForwardIterator
uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
;
template<typename _InputIterator, typename _ForwardIterator,
typename _Allocator>
_ForwardIterator
__uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
;
template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
_ForwardIterator
__uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, allocator<_Tp>&)
;
template<typename _InputIterator, typename _ForwardIterator,
typename _Allocator>
_ForwardIterator
__uninitialized_move_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
;
template<typename _InputIterator, typename _ForwardIterator,
typename _Allocator>
_ForwardIterator
__uninitialized_move_if_noexcept_a(_InputIterator __first,
_InputIterator __last,
_ForwardIterator __result,
_Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Tp, typename _Allocator>
void
__uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x, _Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Tp, typename _Tp2>
void
__uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __x, allocator<_Tp2>&)
;
template<typename _ForwardIterator, typename _Size, typename _Tp,
typename _Allocator>
_ForwardIterator
__uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
const _Tp& __x, _Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Size, typename _Tp,
typename _Tp2>
_ForwardIterator
__uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
const _Tp& __x, allocator<_Tp2>&)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _ForwardIterator, typename _Allocator>
_ForwardIterator
__uninitialized_copy_move(_InputIterator1 __first1,
_InputIterator1 __last1,
_InputIterator2 __first2,
_InputIterator2 __last2,
_ForwardIterator __result,
_Allocator& __alloc)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _ForwardIterator, typename _Allocator>
_ForwardIterator
__uninitialized_move_copy(_InputIterator1 __first1,
_InputIterator1 __last1,
_InputIterator2 __first2,
_InputIterator2 __last2,
_ForwardIterator __result,
_Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
typename _Allocator>
_ForwardIterator
__uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
const _Tp& __x, _InputIterator __first,
_InputIterator __last, _Allocator& __alloc)
;
template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
typename _Allocator>
void
__uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
_ForwardIterator __first2,
_ForwardIterator __last2, const _Tp& __x,
_Allocator& __alloc)
;
template<bool _TrivialValueType>
struct __uninitialized_default_1
{
template<typename _ForwardIterator>
static void
__uninit_default(_ForwardIterator __first, _ForwardIterator __last)
;
};
template<>
struct __uninitialized_default_1<true>
{
template<typename _ForwardIterator>
static void
__uninit_default(_ForwardIterator __first, _ForwardIterator __last)
;
};
template<bool _TrivialValueType>
struct __uninitialized_default_n_1
{
template<typename _ForwardIterator, typename _Size>
static _ForwardIterator
__uninit_default_n(_ForwardIterator __first, _Size __n)
;
};
template<>
struct __uninitialized_default_n_1<true>
{
template<typename _ForwardIterator, typename _Size>
static _ForwardIterator
__uninit_default_n(_ForwardIterator __first, _Size __n)
;
};
template<typename _ForwardIterator>
void
__uninitialized_default(_ForwardIterator __first,
_ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Size>
_ForwardIterator
__uninitialized_default_n(_ForwardIterator __first, _Size __n)
;
template<typename _ForwardIterator, typename _Allocator>
void
__uninitialized_default_a(_ForwardIterator __first,
_ForwardIterator __last,
_Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Tp>
void
__uninitialized_default_a(_ForwardIterator __first,
_ForwardIterator __last,
allocator<_Tp>&)
;
template<typename _ForwardIterator, typename _Size, typename _Allocator>
_ForwardIterator
__uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
_Allocator& __alloc)
;
template<typename _ForwardIterator, typename _Size, typename _Tp>
_ForwardIterator
__uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
allocator<_Tp>&)
;
template<typename _InputIterator, typename _Size,
typename _ForwardIterator>
_ForwardIterator
__uninitialized_copy_n(_InputIterator __first, _Size __n,
_ForwardIterator __result, input_iterator_tag)
;
template<typename _RandomAccessIterator, typename _Size,
typename _ForwardIterator>
_ForwardIterator
__uninitialized_copy_n(_RandomAccessIterator __first, _Size __n,
_ForwardIterator __result,
random_access_iterator_tag)
;
template<typename _InputIterator, typename _Size, typename _ForwardIterator>
_ForwardIterator
uninitialized_copy_n(_InputIterator __first, _Size __n,
_ForwardIterator __result)
;
}
#define _STL_TEMPBUF_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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);
}
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)
;
};
template<>
struct __uninitialized_construct_buf_dispatch<true>
{
template<typename _Pointer, typename _ForwardIterator>
static void
__ucr(_Pointer, _Pointer, _ForwardIterator) ;
};
template<typename _Pointer, typename _ForwardIterator>
void
__uninitialized_construct_buf(_Pointer __first, _Pointer __last,
_ForwardIterator __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;
}
}
}
#define _STL_RAW_STORAGE_ITERATOR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template <class _OutputIterator, class _Tp>
class raw_storage_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
protected:
_OutputIterator _M_iter;
public:
explicit
raw_storage_iterator(_OutputIterator __x) ;
raw_storage_iterator&
operator*() ;
raw_storage_iterator&
operator=(const _Tp& __element)
;
raw_storage_iterator<_OutputIterator, _Tp>&
operator++()
;
raw_storage_iterator<_OutputIterator, _Tp>
operator++(int)
;
};
}
#define _CONCURRENCE_H 1
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
enum _Lock_policy { _S_single, _S_mutex, _S_atomic };
static const _Lock_policy __default_lock_policy =
_S_atomic;
class __concurrence_lock_error : public std::exception
{
public:
virtual char const*
what() const throw()
;
};
class __concurrence_unlock_error : public std::exception
{
public:
virtual char const*
what() const throw()
;
};
class __concurrence_broadcast_error : public std::exception
{
public:
virtual char const*
what() const throw()
;
};
class __concurrence_wait_error : public std::exception
{
public:
virtual char const*
what() const throw()
;
};
void
__throw_concurrence_lock_error()
;
void
__throw_concurrence_unlock_error()
;
void
__throw_concurrence_broadcast_error()
;
void
__throw_concurrence_wait_error()
;
class __mutex
{
private:
__gthread_mutex_t _M_mutex = { { 0, 0, 0, 0, 0, 0, 0, { 0, 0 } } };
__mutex(const __mutex&);
__mutex& operator=(const __mutex&);
public:
__mutex()
;
void lock()
;
void unlock()
;
__gthread_mutex_t* gthread_mutex(void)
;
};
class __recursive_mutex
{
private:
__gthread_recursive_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, 0, 0, { 0, 0 } } };
__recursive_mutex(const __recursive_mutex&);
__recursive_mutex& operator=(const __recursive_mutex&);
public:
__recursive_mutex()
;
void lock()
;
void unlock()
;
__gthread_recursive_mutex_t* gthread_recursive_mutex(void)
;
};
class __scoped_lock
{
public:
typedef __mutex __mutex_type;
private:
__mutex_type& _M_device;
__scoped_lock(const __scoped_lock&);
__scoped_lock& operator=(const __scoped_lock&);
public:
explicit __scoped_lock(__mutex_type& __name)
;
~__scoped_lock() throw()
;
};
class __cond
{
private:
__gthread_cond_t _M_cond = { { 0, 0, 0, 0, 0, (void *) 0, 0, 0 } };
__cond(const __cond&);
__cond& operator=(const __cond&);
public:
__cond()
;
void broadcast()
;
void wait(__mutex *mutex)
;
void wait_recursive(__recursive_mutex *mutex)
;
};
}
#define _USES_ALLOCATOR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
struct allocator_arg_t { };
constexpr allocator_arg_t allocator_arg = allocator_arg_t();
template<typename _Tp> class __has_allocator_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::allocator_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_allocator_type : public __has_allocator_type_helper <typename remove_cv<_Tp>::type>::type { };
template<typename _Tp, typename _Alloc,
bool = __has_allocator_type<_Tp>::value>
struct __uses_allocator_helper
: false_type { };
template<typename _Tp, typename _Alloc>
struct __uses_allocator_helper<_Tp, _Alloc, true>
: is_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
{ };
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>
__uses_alloc_t<_Tp, _Alloc, _Args...>
__use_alloc(const _Alloc& __a)
;
}
#define _GLIBCXX_FUNCTIONAL 1
#define _GLIBCXX_TUPLE 1
#define _GLIBCXX_ARRAY 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp, std::size_t _Nm>
struct __array_traits
{
typedef _Tp _Type[_Nm];
static constexpr _Tp&
_S_ref(const _Type& __t, std::size_t __n) noexcept
{ return const_cast<_Tp&>(__t[__n]); }
};
template<typename _Tp>
struct __array_traits<_Tp, 0>
{
struct _Type { };
static constexpr _Tp&
_S_ref(const _Type&, std::size_t) noexcept
{ return *static_cast<_Tp*>(nullptr); }
};
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)
;
void
swap(array& __other)
noexcept(noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())))
{ 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 std::__addressof(_AT_Type::_S_ref(_M_elems, 0)); }
const_pointer
data() const noexcept
{ return std::__addressof(_AT_Type::_S_ref(_M_elems, 0)); }
};
template<typename _Tp, std::size_t _Nm>
bool
operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
;
template<typename _Tp, std::size_t _Nm>
bool
operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
;
template<typename _Tp, std::size_t _Nm>
bool
operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
;
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 void
swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
noexcept(noexcept(__one.swap(__two)))
{ __one.swap(__two); }
template<std::size_t _Int, typename _Tp, std::size_t _Nm>
constexpr _Tp&
get(array<_Tp, _Nm>& __arr) noexcept
{
static_assert(_Int < _Nm, "index is out of 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, "index is out of 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, "index is out of 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;
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<std::size_t _Idx, typename _Head, bool _IsEmptyNotFinal>
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;
};
template<std::size_t _Idx, typename... _Elements>
struct _Tuple_impl;
template<std::size_t _Idx>
struct _Tuple_impl<_Idx>
{
template<std::size_t, typename...> friend class _Tuple_impl;
_Tuple_impl() = default;
template<typename _Alloc>
_Tuple_impl(allocator_arg_t, const _Alloc&) { }
template<typename _Alloc>
_Tuple_impl(allocator_arg_t, const _Alloc&, const _Tuple_impl&) { }
template<typename _Alloc>
_Tuple_impl(allocator_arg_t, const _Alloc&, _Tuple_impl&&) { }
protected:
void _M_swap(_Tuple_impl&) noexcept { }
};
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, typename... _Tail>
struct _Tuple_impl<_Idx, _Head, _Tail...>
: public _Tuple_impl<_Idx + 1, _Tail...>,
private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value>
{
template<std::size_t, typename...> friend class _Tuple_impl;
typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _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(noexcept(swap(std::declval<_Head&>(),
std::declval<_Head&>()))
&& 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<typename... _Elements>
class tuple : public _Tuple_impl<0, _Elements...>
{
typedef _Tuple_impl<0, _Elements...> _Inherited;
public:
constexpr tuple()
: _Inherited() { }
explicit
constexpr tuple(const _Elements&... __elements)
: _Inherited(__elements...) { }
template<typename... _UElements, typename = typename
enable_if<__and_<is_convertible<_UElements,
_Elements>...>::value>::type>
explicit
constexpr tuple(_UElements&&... __elements)
: _Inherited(std::forward<_UElements>(__elements)...) { }
constexpr tuple(const tuple&) = default;
constexpr tuple(tuple&&) = default;
template<typename... _UElements, typename = typename
enable_if<__and_<is_convertible<const _UElements&,
_Elements>...>::value>::type>
constexpr tuple(const tuple<_UElements...>& __in)
: _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
{ }
template<typename... _UElements, typename = typename
enable_if<__and_<is_convertible<_UElements,
_Elements>...>::value>::type>
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>
tuple(allocator_arg_t __tag, const _Alloc& __a,
const _Elements&... __elements)
: _Inherited(__tag, __a, __elements...) { }
template<typename _Alloc, typename... _UElements, typename = typename
enable_if<sizeof...(_UElements)
== sizeof...(_Elements)>::type>
tuple(allocator_arg_t __tag, const _Alloc& __a,
_UElements&&... __elements)
: _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
{ }
template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
: _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
template<typename _Alloc>
tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
: _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
template<typename _Alloc, typename... _UElements, typename = typename
enable_if<sizeof...(_UElements)
== sizeof...(_Elements)>::type>
tuple(allocator_arg_t __tag, const _Alloc& __a,
const tuple<_UElements...>& __in)
: _Inherited(__tag, __a,
static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
{ }
template<typename _Alloc, typename... _UElements, typename = typename
enable_if<sizeof...(_UElements)
== sizeof...(_Elements)>::type>
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 = typename
enable_if<sizeof...(_UElements)
== sizeof...(_Elements)>::type>
tuple&
operator=(const tuple<_UElements...>& __in)
{
static_cast<_Inherited&>(*this) = __in;
return *this;
}
template<typename... _UElements, typename = typename
enable_if<sizeof...(_UElements)
== sizeof...(_Elements)>::type>
tuple&
operator=(tuple<_UElements...>&& __in)
{
static_cast<_Inherited&>(*this) = std::move(__in);
return *this;
}
void
swap(tuple& __in)
noexcept(noexcept(__in._M_swap(__in)))
{ _Inherited::_M_swap(__in); }
};
template<>
class tuple<>
{
public:
void swap(tuple&) noexcept { }
};
template<typename _T1, typename _T2>
class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
{
typedef _Tuple_impl<0, _T1, _T2> _Inherited;
public:
constexpr tuple()
: _Inherited() { }
explicit
constexpr tuple(const _T1& __a1, const _T2& __a2)
: _Inherited(__a1, __a2) { }
template<typename _U1, typename _U2, typename = typename
enable_if<__and_<is_convertible<_U1, _T1>,
is_convertible<_U2, _T2>>::value>::type>
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 = typename
enable_if<__and_<is_convertible<const _U1&, _T1>,
is_convertible<const _U2&, _T2>>::value>::type>
constexpr tuple(const tuple<_U1, _U2>& __in)
: _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
template<typename _U1, typename _U2, typename = typename
enable_if<__and_<is_convertible<_U1, _T1>,
is_convertible<_U2, _T2>>::value>::type>
constexpr tuple(tuple<_U1, _U2>&& __in)
: _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
template<typename _U1, typename _U2, typename = typename
enable_if<__and_<is_convertible<const _U1&, _T1>,
is_convertible<const _U2&, _T2>>::value>::type>
constexpr tuple(const pair<_U1, _U2>& __in)
: _Inherited(__in.first, __in.second) { }
template<typename _U1, typename _U2, typename = typename
enable_if<__and_<is_convertible<_U1, _T1>,
is_convertible<_U2, _T2>>::value>::type>
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>
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>
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>
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>
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>
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>
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)
;
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<std::size_t __i, typename _Tp>
struct tuple_element;
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<std::size_t __i, typename _Tp>
using __tuple_element_t = typename tuple_element<__i, _Tp>::type;
template<std::size_t __i, typename _Tp>
struct tuple_element<__i, const _Tp>
{
typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type;
};
template<std::size_t __i, typename _Tp>
struct tuple_element<__i, volatile _Tp>
{
typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type;
};
template<std::size_t __i, typename _Tp>
struct tuple_element<__i, const volatile _Tp>
{
typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type;
};
template<typename _Tp>
struct tuple_size;
template<typename _Tp>
struct tuple_size<const _Tp>
: integral_constant<size_t, tuple_size<_Tp>::value> { };
template<typename _Tp>
struct tuple_size<volatile _Tp>
: integral_constant<size_t, tuple_size<_Tp>::value> { };
template<typename _Tp>
struct tuple_size<const volatile _Tp>
: integral_constant<size_t, tuple_size<_Tp>::value> { };
template<typename... _Elements>
struct tuple_size<tuple<_Elements...>>
: public integral_constant<std::size_t, sizeof...(_Elements)> { };
template<std::size_t __i, typename _Head, typename... _Tail>
constexpr _Head&
__get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
{ return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
template<std::size_t __i, typename _Head, typename... _Tail>
constexpr const _Head&
__get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
{ return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
template<std::size_t __i, typename... _Elements>
constexpr __tuple_element_t<__i, tuple<_Elements...>>&
get(tuple<_Elements...>& __t) noexcept
{ return std::__get_helper<__i>(__t); }
template<std::size_t __i, typename... _Elements>
constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
get(const tuple<_Elements...>& __t) noexcept
{ return std::__get_helper<__i>(__t); }
template<std::size_t __i, typename... _Elements>
constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
get(tuple<_Elements...>&& __t) noexcept
{
typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
return std::forward<__element_type&&>(std::get<__i>(__t));
}
template<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>
tuple<_Elements&&...>
forward_as_tuple(_Elements&&... __args) noexcept
{ return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
template<typename>
struct __is_tuple_like_impl : false_type
{ };
template<typename... _Tps>
struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
{ };
template<typename _T1, typename _T2>
struct __is_tuple_like_impl<pair<_T1, _T2>> : true_type
{ };
template<typename _Tp, std::size_t _Nm>
struct __is_tuple_like_impl<array<_Tp, _Nm>> : true_type
{ };
template<typename _Tp>
struct __is_tuple_like
: public __is_tuple_like_impl<typename std::remove_cv
<typename std::remove_reference<_Tp>::type>::type>::type
{ };
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>
inline tuple<_Elements&...>
tie(_Elements&... __args) noexcept
{ return tuple<_Elements&...>(__args...); }
template<typename... _Elements>
inline void
swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
struct _Swallow_assign
{
template<class _Tp>
const _Swallow_assign&
operator=(const _Tp&) const
{ return *this; }
};
const _Swallow_assign ignore{};
template<typename... _Types, typename _Alloc>
struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _MemberPointer>
class _Mem_fn;
template<typename _Tp, typename _Class>
_Mem_fn<_Tp _Class::*>
mem_fn(_Tp _Class::*) noexcept;
template<typename _Tp> class __has_result_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::result_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_result_type : public __has_result_type_helper <typename remove_cv<_Tp>::type>::type { };
template<bool _Has_result_type, typename _Functor>
struct _Maybe_get_result_type
{ };
template<typename _Functor>
struct _Maybe_get_result_type<true, _Functor>
{ typedef typename _Functor::result_type result_type; };
template<typename _Functor>
struct _Weak_result_type_impl
: _Maybe_get_result_type<__has_result_type<_Functor>::value, _Functor>
{ };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...)>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......)>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...) const>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......) const>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
{ typedef _Res result_type; };
template<typename _Res, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)
const volatile>
{ typedef _Res result_type; };
template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)
const volatile>
{ typedef _Res result_type; };
template<typename _Functor>
struct _Weak_result_type
: _Weak_result_type_impl<typename remove_cv<_Functor>::type>
{ };
template<typename _Functor, typename... _Args>
typename enable_if<
(!is_member_pointer<_Functor>::value
&& !is_function<_Functor>::value
&& !is_function<typename remove_pointer<_Functor>::type>::value),
typename result_of<_Functor&(_Args&&...)>::type
>::type
__invoke(_Functor& __f, _Args&&... __args)
;
template<typename _Functor, typename... _Args>
typename enable_if<
(is_member_pointer<_Functor>::value
&& !is_function<_Functor>::value
&& !is_function<typename remove_pointer<_Functor>::type>::value),
typename result_of<_Functor(_Args&&...)>::type
>::type
__invoke(_Functor& __f, _Args&&... __args)
;
template<typename _Functor, typename... _Args>
typename enable_if<
(is_pointer<_Functor>::value
&& is_function<typename remove_pointer<_Functor>::type>::value),
typename result_of<_Functor(_Args&&...)>::type
>::type
__invoke(_Functor __f, _Args&&... __args)
;
template<bool _Unary, bool _Binary, typename _Tp>
struct _Reference_wrapper_base_impl;
template<typename _Tp>
struct _Reference_wrapper_base_impl<false, false, _Tp>
: _Weak_result_type<_Tp>
{ };
template<typename _Tp>
struct _Reference_wrapper_base_impl<true, false, _Tp>
: _Weak_result_type<_Tp>
{
typedef typename _Tp::argument_type argument_type;
};
template<typename _Tp>
struct _Reference_wrapper_base_impl<false, true, _Tp>
: _Weak_result_type<_Tp>
{
typedef typename _Tp::first_argument_type first_argument_type;
typedef typename _Tp::second_argument_type second_argument_type;
};
template<typename _Tp>
struct _Reference_wrapper_base_impl<true, true, _Tp>
: _Weak_result_type<_Tp>
{
typedef typename _Tp::argument_type argument_type;
typedef typename _Tp::first_argument_type first_argument_type;
typedef typename _Tp::second_argument_type second_argument_type;
};
template<typename _Tp> class __has_argument_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::argument_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_argument_type : public __has_argument_type_helper <typename remove_cv<_Tp>::type>::type { };
template<typename _Tp> class __has_first_argument_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::first_argument_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_first_argument_type : public __has_first_argument_type_helper <typename remove_cv<_Tp>::type>::type { };
template<typename _Tp> class __has_second_argument_type_helper { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static true_type __test(_Wrap_type<typename _Up::second_argument_type>*); template<typename _Up> static false_type __test(...); public: typedef decltype(__test<_Tp>(0)) type; }; template<typename _Tp> struct __has_second_argument_type : public __has_second_argument_type_helper <typename remove_cv<_Tp>::type>::type { };
template<typename _Tp>
struct _Reference_wrapper_base
: _Reference_wrapper_base_impl<
__has_argument_type<_Tp>::value,
__has_first_argument_type<_Tp>::value
&& __has_second_argument_type<_Tp>::value,
_Tp>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1)>
: unary_function<_T1, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1) const>
: unary_function<_T1, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1) volatile>
: unary_function<_T1, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1) const volatile>
: unary_function<_T1, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2)>
: binary_function<_T1, _T2, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2) const>
: binary_function<_T1, _T2, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
: binary_function<_T1, _T2, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
: binary_function<_T1, _T2, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(*)(_T1)>
: unary_function<_T1, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
: binary_function<_T1, _T2, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)()>
: unary_function<_T1*, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
: binary_function<_T1*, _T2, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)() const>
: unary_function<const _T1*, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
: binary_function<const _T1*, _T2, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
: unary_function<volatile _T1*, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
: binary_function<volatile _T1*, _T2, _Res>
{ };
template<typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
: unary_function<const volatile _T1*, _Res>
{ };
template<typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
: binary_function<const volatile _T1*, _T2, _Res>
{ };
template<typename _Tp>
class reference_wrapper
: public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
{
_Tp* _M_data;
public:
typedef _Tp type;
reference_wrapper(_Tp& __indata) noexcept
: _M_data(std::__addressof(__indata))
{ }
reference_wrapper(_Tp&&) = delete;
reference_wrapper(const reference_wrapper<_Tp>& __inref) noexcept
: _M_data(__inref._M_data)
{ }
reference_wrapper&
operator=(const reference_wrapper<_Tp>& __inref) noexcept
{
_M_data = __inref._M_data;
return *this;
}
operator _Tp&() const noexcept
{ return this->get(); }
_Tp&
get() const noexcept
{ return *_M_data; }
template<typename... _Args>
typename result_of<_Tp&(_Args&&...)>::type
operator()(_Args&&... __args) const
{
return __invoke(get(), std::forward<_Args>(__args)...);
}
};
template<typename _Tp>
inline reference_wrapper<_Tp>
ref(_Tp& __t) noexcept
{ return reference_wrapper<_Tp>(__t); }
template<typename _Tp>
inline reference_wrapper<const _Tp>
cref(const _Tp& __t) noexcept
{ return reference_wrapper<const _Tp>(__t); }
template<typename _Tp>
void ref(const _Tp&&) = delete;
template<typename _Tp>
void cref(const _Tp&&) = delete;
template<typename _Tp>
inline reference_wrapper<_Tp>
ref(reference_wrapper<_Tp> __t) noexcept
{ return ref(__t.get()); }
template<typename _Tp>
inline reference_wrapper<const _Tp>
cref(reference_wrapper<_Tp> __t) noexcept
{ return cref(__t.get()); }
template<typename... _Types>
struct _Pack : integral_constant<size_t, sizeof...(_Types)>
{ };
template<typename _From, typename _To, bool = _From::value == _To::value>
struct _AllConvertible : false_type
{ };
template<typename... _From, typename... _To>
struct _AllConvertible<_Pack<_From...>, _Pack<_To...>, true>
: __and_<is_convertible<_From, _To>...>
{ };
template<typename _Tp1, typename _Tp2>
using _NotSame = __not_<is_same<typename std::decay<_Tp1>::type,
typename std::decay<_Tp2>::type>>;
template<typename _Res, typename... _ArgTypes>
struct _Maybe_unary_or_binary_function { };
template<typename _Res, typename _T1>
struct _Maybe_unary_or_binary_function<_Res, _T1>
: std::unary_function<_T1, _Res> { };
template<typename _Res, typename _T1, typename _T2>
struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
: std::binary_function<_T1, _T2, _Res> { };
template<typename _Res, typename _Class, typename... _ArgTypes>
class _Mem_fn<_Res (_Class::*)(_ArgTypes...)>
: public _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>
{
typedef _Res (_Class::*_Functor)(_ArgTypes...);
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __object, const volatile _Class *,
_Args&&... __args) const
;
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
;
template<typename... _Args>
using _RequireValidArgs
= _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs2
= _Require<_NotSame<_Class, _Tp>, _NotSame<_Class*, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs3
= _Require<is_base_of<_Class, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
public:
typedef _Res result_type;
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(_Class& __object, _Args&&... __args) const
{ return (__object.*__pmf)(std::forward<_Args>(__args)...); }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(_Class&& __object, _Args&&... __args) const
{
return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
}
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(_Class* __object, _Args&&... __args) const
{ return (__object->*__pmf)(std::forward<_Args>(__args)...); }
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs2<_Tp, _Args...>>
_Res
operator()(_Tp&& __object, _Args&&... __args) const
{
return _M_call(std::forward<_Tp>(__object), &__object,
std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs3<_Tp, _Args...>>
_Res
operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
{ return operator()(__ref.get(), std::forward<_Args>(__args)...); }
private:
_Functor __pmf;
};
template<typename _Res, typename _Class, typename... _ArgTypes>
class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const>
: public _Maybe_unary_or_binary_function<_Res, const _Class*,
_ArgTypes...>
{
typedef _Res (_Class::*_Functor)(_ArgTypes...) const;
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __object, const volatile _Class *,
_Args&&... __args) const
{
return (std::forward<_Tp>(__object).*__pmf)
(std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
{ return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }
template<typename... _Args>
using _RequireValidArgs
= _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs2
= _Require<_NotSame<_Class, _Tp>, _NotSame<const _Class*, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs3
= _Require<is_base_of<_Class, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
public:
typedef _Res result_type;
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(const _Class& __object, _Args&&... __args) const
{ return (__object.*__pmf)(std::forward<_Args>(__args)...); }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(const _Class&& __object, _Args&&... __args) const
{
return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
}
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(const _Class* __object, _Args&&... __args) const
{ return (__object->*__pmf)(std::forward<_Args>(__args)...); }
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs2<_Tp, _Args...>>
_Res operator()(_Tp&& __object, _Args&&... __args) const
{
return _M_call(std::forward<_Tp>(__object), &__object,
std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs3<_Tp, _Args...>>
_Res
operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
{ return operator()(__ref.get(), std::forward<_Args>(__args)...); }
private:
_Functor __pmf;
};
template<typename _Res, typename _Class, typename... _ArgTypes>
class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile>
: public _Maybe_unary_or_binary_function<_Res, volatile _Class*,
_ArgTypes...>
{
typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile;
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __object, const volatile _Class *,
_Args&&... __args) const
{
return (std::forward<_Tp>(__object).*__pmf)
(std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
{ return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }
template<typename... _Args>
using _RequireValidArgs
= _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs2
= _Require<_NotSame<_Class, _Tp>, _NotSame<volatile _Class*, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs3
= _Require<is_base_of<_Class, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
public:
typedef _Res result_type;
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(volatile _Class& __object, _Args&&... __args) const
{ return (__object.*__pmf)(std::forward<_Args>(__args)...); }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(volatile _Class&& __object, _Args&&... __args) const
{
return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
}
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(volatile _Class* __object, _Args&&... __args) const
{ return (__object->*__pmf)(std::forward<_Args>(__args)...); }
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs2<_Tp, _Args...>>
_Res
operator()(_Tp&& __object, _Args&&... __args) const
{
return _M_call(std::forward<_Tp>(__object), &__object,
std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs3<_Tp, _Args...>>
_Res
operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
{ return operator()(__ref.get(), std::forward<_Args>(__args)...); }
private:
_Functor __pmf;
};
template<typename _Res, typename _Class, typename... _ArgTypes>
class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile>
: public _Maybe_unary_or_binary_function<_Res, const volatile _Class*,
_ArgTypes...>
{
typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile;
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __object, const volatile _Class *,
_Args&&... __args) const
{
return (std::forward<_Tp>(__object).*__pmf)
(std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args>
_Res
_M_call(_Tp&& __ptr, const volatile void *, _Args&&... __args) const
{ return ((*__ptr).*__pmf)(std::forward<_Args>(__args)...); }
template<typename... _Args>
using _RequireValidArgs
= _Require<_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs2
= _Require<_NotSame<_Class, _Tp>,
_NotSame<const volatile _Class*, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
template<typename _Tp, typename... _Args>
using _RequireValidArgs3
= _Require<is_base_of<_Class, _Tp>,
_AllConvertible<_Pack<_Args...>, _Pack<_ArgTypes...>>>;
public:
typedef _Res result_type;
explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(const volatile _Class& __object, _Args&&... __args) const
{ return (__object.*__pmf)(std::forward<_Args>(__args)...); }
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(const volatile _Class&& __object, _Args&&... __args) const
{
return (std::move(__object).*__pmf)(std::forward<_Args>(__args)...);
}
template<typename... _Args, typename _Req = _RequireValidArgs<_Args...>>
_Res
operator()(const volatile _Class* __object, _Args&&... __args) const
{ return (__object->*__pmf)(std::forward<_Args>(__args)...); }
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs2<_Tp, _Args...>>
_Res operator()(_Tp&& __object, _Args&&... __args) const
{
return _M_call(std::forward<_Tp>(__object), &__object,
std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args,
typename _Req = _RequireValidArgs3<_Tp, _Args...>>
_Res
operator()(reference_wrapper<_Tp> __ref, _Args&&... __args) const
{ return operator()(__ref.get(), std::forward<_Args>(__args)...); }
private:
_Functor __pmf;
};
template<typename _Tp, bool>
struct _Mem_fn_const_or_non
{
typedef const _Tp& type;
};
template<typename _Tp>
struct _Mem_fn_const_or_non<_Tp, false>
{
typedef _Tp& type;
};
template<typename _Res, typename _Class>
class _Mem_fn<_Res _Class::*>
{
using __pm_type = _Res _Class::*;
template<typename _Tp>
auto
_M_call(_Tp&& __object, const _Class *) const noexcept
-> decltype(std::forward<_Tp>(__object).*std::declval<__pm_type&>())
{ return std::forward<_Tp>(__object).*__pm; }
template<typename _Tp, typename _Up>
auto
_M_call(_Tp&& __object, _Up * const *) const noexcept
-> decltype((*std::forward<_Tp>(__object)).*std::declval<__pm_type&>())
{ return (*std::forward<_Tp>(__object)).*__pm; }
template<typename _Tp>
auto
_M_call(_Tp&& __ptr, const volatile void*) const
noexcept(noexcept((*__ptr).*std::declval<__pm_type&>()))
-> decltype((*__ptr).*std::declval<__pm_type&>())
{ return (*__ptr).*__pm; }
public:
explicit
_Mem_fn(_Res _Class::*__pm) noexcept : __pm(__pm) { }
_Res&
operator()(_Class& __object) const noexcept
{ return __object.*__pm; }
const _Res&
operator()(const _Class& __object) const noexcept
{ return __object.*__pm; }
_Res&&
operator()(_Class&& __object) const noexcept
{ return std::forward<_Class>(__object).*__pm; }
const _Res&&
operator()(const _Class&& __object) const noexcept
{ return std::forward<const _Class>(__object).*__pm; }
_Res&
operator()(_Class* __object) const noexcept
{ return __object->*__pm; }
const _Res&
operator()(const _Class* __object) const noexcept
{ return __object->*__pm; }
template<typename _Tp, typename _Req = _Require<_NotSame<_Class*, _Tp>>>
auto
operator()(_Tp&& __unknown) const
noexcept(noexcept(std::declval<_Mem_fn*>()->_M_call
(std::forward<_Tp>(__unknown), &__unknown)))
-> decltype(this->_M_call(std::forward<_Tp>(__unknown), &__unknown))
{ return _M_call(std::forward<_Tp>(__unknown), &__unknown); }
template<typename _Tp, typename _Req = _Require<is_base_of<_Class, _Tp>>>
auto
operator()(reference_wrapper<_Tp> __ref) const
noexcept(noexcept(std::declval<_Mem_fn&>()(__ref.get())))
-> decltype((*this)(__ref.get()))
{ return (*this)(__ref.get()); }
private:
_Res _Class::*__pm;
};
template<typename _Tp, typename _Class>
inline _Mem_fn<_Tp _Class::*>
mem_fn(_Tp _Class::* __pm) noexcept
{
return _Mem_fn<_Tp _Class::*>(__pm);
}
template<typename _Tp>
struct is_bind_expression
: public false_type { };
template<typename _Tp>
struct is_placeholder
: public integral_constant<int, 0>
{ };
template<int _Num> struct _Placeholder { };
namespace placeholders
{
extern const _Placeholder<1> _1;
extern const _Placeholder<2> _2;
extern const _Placeholder<3> _3;
extern const _Placeholder<4> _4;
extern const _Placeholder<5> _5;
extern const _Placeholder<6> _6;
extern const _Placeholder<7> _7;
extern const _Placeholder<8> _8;
extern const _Placeholder<9> _9;
extern const _Placeholder<10> _10;
extern const _Placeholder<11> _11;
extern const _Placeholder<12> _12;
extern const _Placeholder<13> _13;
extern const _Placeholder<14> _14;
extern const _Placeholder<15> _15;
extern const _Placeholder<16> _16;
extern const _Placeholder<17> _17;
extern const _Placeholder<18> _18;
extern const _Placeholder<19> _19;
extern const _Placeholder<20> _20;
extern const _Placeholder<21> _21;
extern const _Placeholder<22> _22;
extern const _Placeholder<23> _23;
extern const _Placeholder<24> _24;
extern const _Placeholder<25> _25;
extern const _Placeholder<26> _26;
extern const _Placeholder<27> _27;
extern const _Placeholder<28> _28;
extern const _Placeholder<29> _29;
}
template<int _Num>
struct is_placeholder<_Placeholder<_Num> >
: public integral_constant<int, _Num>
{ };
template<int _Num>
struct is_placeholder<const _Placeholder<_Num> >
: public integral_constant<int, _Num>
{ };
struct _No_tuple_element;
template<std::size_t __i, typename _Tuple, bool _IsSafe>
struct _Safe_tuple_element_impl
: tuple_element<__i, _Tuple> { };
template<std::size_t __i, typename _Tuple>
struct _Safe_tuple_element_impl<__i, _Tuple, false>
{
typedef _No_tuple_element type;
};
template<std::size_t __i, typename _Tuple>
struct _Safe_tuple_element
: _Safe_tuple_element_impl<__i, _Tuple,
(__i < tuple_size<_Tuple>::value)>
{ };
template<typename _Arg,
bool _IsBindExp = is_bind_expression<_Arg>::value,
bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
class _Mu;
template<typename _Tp>
class _Mu<reference_wrapper<_Tp>, false, false>
{
public:
typedef _Tp& result_type;
template<typename _CVRef, typename _Tuple>
result_type
operator()(_CVRef& __arg, _Tuple&) const volatile
{ return __arg.get(); }
};
template<typename _Arg>
class _Mu<_Arg, true, false>
{
public:
template<typename _CVArg, typename... _Args>
auto
operator()(_CVArg& __arg,
tuple<_Args...>& __tuple) const volatile
-> decltype(__arg(declval<_Args>()...))
{
typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
_Indexes;
return this->__call(__arg, __tuple, _Indexes());
}
private:
template<typename _CVArg, typename... _Args, std::size_t... _Indexes>
auto
__call(_CVArg& __arg, tuple<_Args...>& __tuple,
const _Index_tuple<_Indexes...>&) const volatile
-> decltype(__arg(declval<_Args>()...))
{
return __arg(std::forward<_Args>(std::get<_Indexes>(__tuple))...);
}
};
template<typename _Arg>
class _Mu<_Arg, false, true>
{
public:
template<typename _Signature> class result;
template<typename _CVMu, typename _CVArg, typename _Tuple>
class result<_CVMu(_CVArg, _Tuple)>
{
typedef typename _Safe_tuple_element<(is_placeholder<_Arg>::value
- 1), _Tuple>::type
__base_type;
public:
typedef typename add_rvalue_reference<__base_type>::type type;
};
template<typename _Tuple>
typename result<_Mu(_Arg, _Tuple)>::type
operator()(const volatile _Arg&, _Tuple& __tuple) const volatile
{
return std::forward<typename result<_Mu(_Arg, _Tuple)>::type>(
::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple));
}
};
template<typename _Arg>
class _Mu<_Arg, false, false>
{
public:
template<typename _Signature> struct result;
template<typename _CVMu, typename _CVArg, typename _Tuple>
struct result<_CVMu(_CVArg, _Tuple)>
{
typedef typename add_lvalue_reference<_CVArg>::type type;
};
template<typename _CVArg, typename _Tuple>
_CVArg&&
operator()(_CVArg&& __arg, _Tuple&) const volatile
{ return std::forward<_CVArg>(__arg); }
};
template<typename _Tp>
struct _Maybe_wrap_member_pointer
{
typedef _Tp type;
static const _Tp&
__do_wrap(const _Tp& __x)
{ return __x; }
static _Tp&&
__do_wrap(_Tp&& __x)
{ return static_cast<_Tp&&>(__x); }
};
template<typename _Tp, typename _Class>
struct _Maybe_wrap_member_pointer<_Tp _Class::*>
{
typedef _Mem_fn<_Tp _Class::*> type;
static type
__do_wrap(_Tp _Class::* __pm)
{ return type(__pm); }
};
template<>
struct _Maybe_wrap_member_pointer<void>
{
typedef void type;
};
template<std::size_t _Ind, typename... _Tp>
inline auto
__volget(volatile tuple<_Tp...>& __tuple)
-> __tuple_element_t<_Ind, tuple<_Tp...>> volatile&
{ return std::get<_Ind>(const_cast<tuple<_Tp...>&>(__tuple)); }
template<std::size_t _Ind, typename... _Tp>
inline auto
__volget(const volatile tuple<_Tp...>& __tuple)
-> __tuple_element_t<_Ind, tuple<_Tp...>> const volatile&
{ return std::get<_Ind>(const_cast<const tuple<_Tp...>&>(__tuple)); }
template<typename _Signature>
struct _Bind;
template<typename _Functor, typename... _Bound_args>
class _Bind<_Functor(_Bound_args...)>
: public _Weak_result_type<_Functor>
{
typedef _Bind __self_type;
typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
_Bound_indexes;
_Functor _M_f;
tuple<_Bound_args...> _M_bound_args;
template<typename _Result, typename... _Args, std::size_t... _Indexes>
_Result
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
{
return _M_f(_Mu<_Bound_args>()
(std::get<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Result, typename... _Args, std::size_t... _Indexes>
_Result
__call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
{
return _M_f(_Mu<_Bound_args>()
(std::get<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Result, typename... _Args, std::size_t... _Indexes>
_Result
__call_v(tuple<_Args...>&& __args,
_Index_tuple<_Indexes...>) volatile
{
return _M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Result, typename... _Args, std::size_t... _Indexes>
_Result
__call_c_v(tuple<_Args...>&& __args,
_Index_tuple<_Indexes...>) const volatile
{
return _M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
public:
template<typename... _Args>
explicit _Bind(const _Functor& __f, _Args&&... __args)
: _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
{ }
template<typename... _Args>
explicit _Bind(_Functor&& __f, _Args&&... __args)
: _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
{ }
_Bind(const _Bind&) = default;
_Bind(_Bind&& __b)
: _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
{ }
template<typename... _Args, typename _Result
= decltype( std::declval<_Functor>()(
_Mu<_Bound_args>()( std::declval<_Bound_args&>(),
std::declval<tuple<_Args...>&>() )... ) )>
_Result
operator()(_Args&&... __args)
;
template<typename... _Args, typename _Result
= decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
typename add_const<_Functor>::type>::type>()(
_Mu<_Bound_args>()( std::declval<const _Bound_args&>(),
std::declval<tuple<_Args...>&>() )... ) )>
_Result
operator()(_Args&&... __args) const
;
template<typename... _Args, typename _Result
= decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
typename add_volatile<_Functor>::type>::type>()(
_Mu<_Bound_args>()( std::declval<volatile _Bound_args&>(),
std::declval<tuple<_Args...>&>() )... ) )>
_Result
operator()(_Args&&... __args) volatile
;
template<typename... _Args, typename _Result
= decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
typename add_cv<_Functor>::type>::type>()(
_Mu<_Bound_args>()( std::declval<const volatile _Bound_args&>(),
std::declval<tuple<_Args...>&>() )... ) )>
_Result
operator()(_Args&&... __args) const volatile
;
};
template<typename _Result, typename _Signature>
struct _Bind_result;
template<typename _Result, typename _Functor, typename... _Bound_args>
class _Bind_result<_Result, _Functor(_Bound_args...)>
{
typedef _Bind_result __self_type;
typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
_Bound_indexes;
_Functor _M_f;
tuple<_Bound_args...> _M_bound_args;
template<typename _Res>
struct __enable_if_void : enable_if<is_void<_Res>::value, int> { };
template<typename _Res>
struct __disable_if_void : enable_if<!is_void<_Res>::value, int> { };
template<typename _Res, typename... _Args, std::size_t... _Indexes>
_Result
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0)
;
template<typename _Res, typename... _Args, std::size_t... _Indexes>
void
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0)
;
template<typename _Res, typename... _Args, std::size_t... _Indexes>
_Result
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0) const
;
template<typename _Res, typename... _Args, std::size_t... _Indexes>
void
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0) const
;
template<typename _Res, typename... _Args, std::size_t... _Indexes>
_Result
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0) volatile
{
return _M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Res, typename... _Args, std::size_t... _Indexes>
void
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0) volatile
{
_M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Res, typename... _Args, std::size_t... _Indexes>
_Result
__call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
typename __disable_if_void<_Res>::type = 0) const volatile
{
return _M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
template<typename _Res, typename... _Args, std::size_t... _Indexes>
void
__call(tuple<_Args...>&& __args,
_Index_tuple<_Indexes...>,
typename __enable_if_void<_Res>::type = 0) const volatile
{
_M_f(_Mu<_Bound_args>()
(__volget<_Indexes>(_M_bound_args), __args)...);
}
public:
typedef _Result result_type;
template<typename... _Args>
explicit _Bind_result(const _Functor& __f, _Args&&... __args)
: _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
{ }
template<typename... _Args>
explicit _Bind_result(_Functor&& __f, _Args&&... __args)
: _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
{ }
_Bind_result(const _Bind_result&) = default;
_Bind_result(_Bind_result&& __b)
: _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
{ }
template<typename... _Args>
result_type
operator()(_Args&&... __args)
{
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
template<typename... _Args>
result_type
operator()(_Args&&... __args) const
{
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
template<typename... _Args>
result_type
operator()(_Args&&... __args) volatile
{
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
template<typename... _Args>
result_type
operator()(_Args&&... __args) const volatile
{
return this->__call<_Result>(
std::forward_as_tuple(std::forward<_Args>(__args)...),
_Bound_indexes());
}
};
template<typename _Signature>
struct is_bind_expression<_Bind<_Signature> >
: public true_type { };
template<typename _Signature>
struct is_bind_expression<const _Bind<_Signature> >
: public true_type { };
template<typename _Signature>
struct is_bind_expression<volatile _Bind<_Signature> >
: public true_type { };
template<typename _Signature>
struct is_bind_expression<const volatile _Bind<_Signature>>
: public true_type { };
template<typename _Result, typename _Signature>
struct is_bind_expression<_Bind_result<_Result, _Signature>>
: public true_type { };
template<typename _Result, typename _Signature>
struct is_bind_expression<const _Bind_result<_Result, _Signature>>
: public true_type { };
template<typename _Result, typename _Signature>
struct is_bind_expression<volatile _Bind_result<_Result, _Signature>>
: public true_type { };
template<typename _Result, typename _Signature>
struct is_bind_expression<const volatile _Bind_result<_Result, _Signature>>
: public true_type { };
template<typename _Tp, typename _Tp2 = typename decay<_Tp>::type>
using __is_socketlike = __or_<is_integral<_Tp2>, is_enum<_Tp2>>;
template<bool _SocketLike, typename _Func, typename... _BoundArgs>
struct _Bind_helper
{
typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
__maybe_type;
typedef typename __maybe_type::type __func_type;
typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type;
};
template<typename _Func, typename... _BoundArgs>
struct _Bind_helper<true, _Func, _BoundArgs...>
{ };
template<typename _Func, typename... _BoundArgs>
inline typename
_Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
bind(_Func&& __f, _BoundArgs&&... __args)
{
typedef _Bind_helper<false, _Func, _BoundArgs...> __helper_type;
typedef typename __helper_type::__maybe_type __maybe_type;
typedef typename __helper_type::type __result_type;
return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
std::forward<_BoundArgs>(__args)...);
}
template<typename _Result, typename _Func, typename... _BoundArgs>
struct _Bindres_helper
{
typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
__maybe_type;
typedef typename __maybe_type::type __functor_type;
typedef _Bind_result<_Result,
__functor_type(typename decay<_BoundArgs>::type...)>
type;
};
template<typename _Result, typename _Func, typename... _BoundArgs>
inline
typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type
bind(_Func&& __f, _BoundArgs&&... __args)
{
typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type;
typedef typename __helper_type::__maybe_type __maybe_type;
typedef typename __helper_type::type __result_type;
return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
std::forward<_BoundArgs>(__args)...);
}
template<typename _Signature>
struct _Bind_simple;
template<typename _Callable, typename... _Args>
struct _Bind_simple<_Callable(_Args...)>
{
typedef typename result_of<_Callable(_Args...)>::type result_type;
template<typename... _Args2, typename = typename
enable_if< sizeof...(_Args) == sizeof...(_Args2)>::type>
explicit
_Bind_simple(const _Callable& __callable, _Args2&&... __args)
: _M_bound(__callable, std::forward<_Args2>(__args)...)
{ }
template<typename... _Args2, typename = typename
enable_if< sizeof...(_Args) == sizeof...(_Args2)>::type>
explicit
_Bind_simple(_Callable&& __callable, _Args2&&... __args)
: _M_bound(std::move(__callable), std::forward<_Args2>(__args)...)
{ }
_Bind_simple(const _Bind_simple&) = default;
_Bind_simple(_Bind_simple&&) = default;
result_type
operator()()
{
typedef typename _Build_index_tuple<sizeof...(_Args)>::__type _Indices;
return _M_invoke(_Indices());
}
private:
template<std::size_t... _Indices>
typename result_of<_Callable(_Args...)>::type
_M_invoke(_Index_tuple<_Indices...>)
{
return std::forward<_Callable>(std::get<0>(_M_bound))(
std::forward<_Args>(std::get<_Indices+1>(_M_bound))...);
}
std::tuple<_Callable, _Args...> _M_bound;
};
template<typename _Func, typename... _BoundArgs>
struct _Bind_simple_helper
{
typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
__maybe_type;
typedef typename __maybe_type::type __func_type;
typedef _Bind_simple<__func_type(typename decay<_BoundArgs>::type...)>
__type;
};
template<typename _Callable, typename... _Args>
typename _Bind_simple_helper<_Callable, _Args...>::__type
__bind_simple(_Callable&& __callable, _Args&&... __args)
{
typedef _Bind_simple_helper<_Callable, _Args...> __helper_type;
typedef typename __helper_type::__maybe_type __maybe_type;
typedef typename __helper_type::__type __result_type;
return __result_type(
__maybe_type::__do_wrap( std::forward<_Callable>(__callable)),
std::forward<_Args>(__args)...);
}
class bad_function_call : public std::exception
{
public:
virtual ~bad_function_call() noexcept;
const char* what() const noexcept;
};
template<typename _Tp>
struct __is_location_invariant
: __or_<is_pointer<_Tp>, is_member_pointer<_Tp>>::type
{ };
class _Undefined_class;
union _Nocopy_types
{
void* _M_object;
const void* _M_const_object;
void (*_M_function_pointer)();
void (_Undefined_class::*_M_member_pointer)();
};
union _Any_data
{
void* _M_access() { return &_M_pod_data[0]; }
const void* _M_access() const { return &_M_pod_data[0]; }
template<typename _Tp>
_Tp&
_M_access()
{ return *static_cast<_Tp*>(_M_access()); }
template<typename _Tp>
const _Tp&
_M_access() const
;
_Nocopy_types _M_unused;
char _M_pod_data[sizeof(_Nocopy_types)];
};
enum _Manager_operation
{
__get_type_info,
__get_functor_ptr,
__clone_functor,
__destroy_functor
};
template<typename _Tp>
struct _Simple_type_wrapper
{
_Simple_type_wrapper(_Tp __value) ;
_Tp __value;
};
template<typename _Tp>
struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
: __is_location_invariant<_Tp>
{ };
template<typename _Functor>
_Functor&
__callable_functor(_Functor& __f)
;
template<typename _Member, typename _Class>
_Mem_fn<_Member _Class::*>
__callable_functor(_Member _Class::* &__p)
;
template<typename _Member, typename _Class>
_Mem_fn<_Member _Class::*>
__callable_functor(_Member _Class::* const &__p)
;
template<typename _Member, typename _Class>
_Mem_fn<_Member _Class::*>
__callable_functor(_Member _Class::* volatile &__p)
;
template<typename _Member, typename _Class>
_Mem_fn<_Member _Class::*>
__callable_functor(_Member _Class::* const volatile &__p)
;
template<typename _Signature>
class function;
class _Function_base
{
public:
static const std::size_t _M_max_size = sizeof(_Nocopy_types);
static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
template<typename _Functor>
class _Base_manager
{
protected:
static const bool __stored_locally =
(__is_location_invariant<_Functor>::value
&& sizeof(_Functor) <= _M_max_size
&& __alignof__(_Functor) <= _M_max_align
&& (_M_max_align % __alignof__(_Functor) == 0));
typedef integral_constant<bool, __stored_locally> _Local_storage;
static _Functor*
_M_get_pointer(const _Any_data& __source)
;
static void
_M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
;
static void
_M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
;
static void
_M_destroy(_Any_data& __victim, true_type)
;
static void
_M_destroy(_Any_data& __victim, false_type)
;
public:
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
_Manager_operation __op)
;
static void
_M_init_functor(_Any_data& __functor, _Functor&& __f)
;
template<typename _Signature>
static bool
_M_not_empty_function(const function<_Signature>& __f)
;
template<typename _Tp>
static bool
_M_not_empty_function(_Tp* const& __fp)
;
template<typename _Class, typename _Tp>
static bool
_M_not_empty_function(_Tp _Class::* const& __mp)
;
template<typename _Tp>
static bool
_M_not_empty_function(const _Tp&)
;
private:
static void
_M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
;
static void
_M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
;
};
template<typename _Functor>
class _Ref_manager : public _Base_manager<_Functor*>
{
typedef _Function_base::_Base_manager<_Functor*> _Base;
public:
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
_Manager_operation __op)
;
static void
_M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
;
};
_Function_base() ;
~_Function_base()
;
bool _M_empty() const ;
typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
_Manager_operation);
_Any_data _M_functor;
_Manager_type _M_manager;
};
template<typename _Signature, typename _Functor>
class _Function_handler;
template<typename _Res, typename _Functor, typename... _ArgTypes>
class _Function_handler<_Res(_ArgTypes...), _Functor>
: public _Function_base::_Base_manager<_Functor>
{
typedef _Function_base::_Base_manager<_Functor> _Base;
public:
static _Res
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
;
};
template<typename _Functor, typename... _ArgTypes>
class _Function_handler<void(_ArgTypes...), _Functor>
: public _Function_base::_Base_manager<_Functor>
{
typedef _Function_base::_Base_manager<_Functor> _Base;
public:
static void
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
;
};
template<typename _Res, typename _Functor, typename... _ArgTypes>
class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >
: public _Function_base::_Ref_manager<_Functor>
{
typedef _Function_base::_Ref_manager<_Functor> _Base;
public:
static _Res
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
;
};
template<typename _Functor, typename... _ArgTypes>
class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> >
: public _Function_base::_Ref_manager<_Functor>
{
typedef _Function_base::_Ref_manager<_Functor> _Base;
public:
static void
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
;
};
template<typename _Class, typename _Member, typename _Res,
typename... _ArgTypes>
class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
: public _Function_handler<void(_ArgTypes...), _Member _Class::*>
{
typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
_Base;
public:
static _Res
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
;
};
template<typename _Class, typename _Member, typename... _ArgTypes>
class _Function_handler<void(_ArgTypes...), _Member _Class::*>
: public _Function_base::_Base_manager<
_Simple_type_wrapper< _Member _Class::* > >
{
typedef _Member _Class::* _Functor;
typedef _Simple_type_wrapper<_Functor> _Wrapper;
typedef _Function_base::_Base_manager<_Wrapper> _Base;
public:
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
_Manager_operation __op)
;
static void
_M_invoke(const _Any_data& __functor, _ArgTypes... __args)
;
};
template<typename _From, typename _To>
using __check_func_return_type
= __or_<is_void<_To>, is_convertible<_From, _To>>;
template<typename _Res, typename... _ArgTypes>
class function<_Res(_ArgTypes...)>
: public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
private _Function_base
{
typedef _Res _Signature_type(_ArgTypes...);
template<typename _Functor>
using _Invoke = decltype(__callable_functor(std::declval<_Functor&>())
(std::declval<_ArgTypes>()...) );
template<typename _Tp>
using _NotSelf = __not_<is_same<_Tp, function>>;
template<typename _Functor>
using _Callable
= __and_<_NotSelf<_Functor>,
__check_func_return_type<_Invoke<_Functor>, _Res>>;
template<typename _Cond, typename _Tp>
using _Requires = typename enable_if<_Cond::value, _Tp>::type;
public:
typedef _Res result_type;
function() noexcept
: _Function_base() { }
function(nullptr_t) noexcept
: _Function_base() { }
function(const function& __x);
function(function&& __x)
;
template<typename _Functor,
typename = _Requires<_Callable<_Functor>, void>>
function(_Functor);
function&
operator=(const function& __x)
;
function&
operator=(function&& __x)
;
function&
operator=(nullptr_t)
;
template<typename _Functor>
_Requires<_Callable<typename decay<_Functor>::type>, function&>
operator=(_Functor&& __f)
{
function(std::forward<_Functor>(__f)).swap(*this);
return *this;
}
template<typename _Functor>
function&
operator=(reference_wrapper<_Functor> __f) noexcept
{
function(__f).swap(*this);
return *this;
}
void swap(function& __x)
{
std::swap(_M_functor, __x._M_functor);
std::swap(_M_manager, __x._M_manager);
std::swap(_M_invoker, __x._M_invoker);
}
explicit operator bool() const noexcept
{ return !_M_empty(); }
_Res operator()(_ArgTypes... __args) const;
const type_info& target_type() const noexcept;
template<typename _Functor> _Functor* target() noexcept;
template<typename _Functor> const _Functor* target() const noexcept;
private:
typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...);
_Invoker_type _M_invoker;
};
template<typename _Res, typename... _ArgTypes>
const type_info&
function<_Res(_ArgTypes...)>::
target_type() const noexcept
{
if (_M_manager)
{
_Any_data __typeinfo_result;
_M_manager(__typeinfo_result, _M_functor, __get_type_info);
return *__typeinfo_result._M_access<const type_info*>();
}
else
return typeid(void);
}
template<typename _Res, typename... _ArgTypes>
template<typename _Functor>
_Functor*
function<_Res(_ArgTypes...)>::
target() noexcept
{
if (typeid(_Functor) == target_type() && _M_manager)
{
_Any_data __ptr;
if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
&& !is_const<_Functor>::value)
return 0;
else
return __ptr._M_access<_Functor*>();
}
else
return 0;
}
template<typename _Res, typename... _ArgTypes>
template<typename _Functor>
const _Functor*
function<_Res(_ArgTypes...)>::
target() const noexcept
{
if (typeid(_Functor) == target_type() && _M_manager)
{
_Any_data __ptr;
_M_manager(__ptr, _M_functor, __get_functor_ptr);
return __ptr._M_access<const _Functor*>();
}
else
return 0;
}
template<typename _Res, typename... _Args>
inline bool
operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
{ return !static_cast<bool>(__f); }
template<typename _Res, typename... _Args>
inline bool
operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
{ return !static_cast<bool>(__f); }
template<typename _Res, typename... _Args>
inline bool
operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
{ return static_cast<bool>(__f); }
template<typename _Res, typename... _Args>
inline bool
operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
{ return static_cast<bool>(__f); }
template<typename _Res, typename... _Args>
inline void
swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y)
{ __x.swap(__y); }
}
#define _UNIQUE_PTR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename> class auto_ptr;
template<typename _Tp>
struct default_delete
{
constexpr default_delete() noexcept = default;
template<typename _Up, typename = typename
enable_if<is_convertible<_Up*, _Tp*>::value>::type>
default_delete(const default_delete<_Up>&) noexcept { }
void
operator()(_Tp* __ptr) const
{
static_assert(!is_void<_Tp>::value,
"can't delete pointer to incomplete type");
static_assert(sizeof(_Tp)>0,
"can't delete pointer to incomplete type");
delete __ptr;
}
};
template<typename _Tp>
struct default_delete<_Tp[]>
{
private:
template<typename _Up>
using __remove_cv = typename remove_cv<_Up>::type;
template<typename _Up>
using __is_derived_Tp
= __and_< is_base_of<_Tp, _Up>,
__not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
public:
constexpr default_delete() noexcept = default;
template<typename _Up, typename = typename
enable_if<!__is_derived_Tp<_Up>::value>::type>
default_delete(const default_delete<_Up[]>&) noexcept { }
void
operator()(_Tp* __ptr) const
{
static_assert(sizeof(_Tp)>0,
"can't delete pointer to incomplete type");
delete [] __ptr;
}
template<typename _Up>
typename enable_if<__is_derived_Tp<_Up>::value>::type
operator()(_Up*) const = delete;
};
template <typename _Tp, typename _Dp = default_delete<_Tp> >
class unique_ptr
{
class _Pointer
{
template<typename _Up>
static typename _Up::pointer __test(typename _Up::pointer*);
template<typename _Up>
static _Tp* __test(...);
typedef typename remove_reference<_Dp>::type _Del;
public:
typedef decltype(__test<_Del>(0)) type;
};
typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
__tuple_type _M_t;
public:
typedef typename _Pointer::type pointer;
typedef _Tp element_type;
typedef _Dp deleter_type;
constexpr unique_ptr() noexcept
: _M_t()
{ static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
explicit
unique_ptr(pointer __p) noexcept
: _M_t(__p, deleter_type())
{ static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
unique_ptr(pointer __p,
typename conditional<is_reference<deleter_type>::value,
deleter_type, const deleter_type&>::type __d) noexcept
: _M_t(__p, __d) { }
unique_ptr(pointer __p,
typename remove_reference<deleter_type>::type&& __d) noexcept
: _M_t(std::move(__p), std::move(__d))
{ static_assert(!std::is_reference<deleter_type>::value,
"rvalue deleter bound to reference"); }
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
unique_ptr(unique_ptr&& __u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
template<typename _Up, typename _Ep, typename = _Require<
is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
__not_<is_array<_Up>>,
typename conditional<is_reference<_Dp>::value,
is_same<_Ep, _Dp>,
is_convertible<_Ep, _Dp>>::type>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }
template<typename _Up, typename = _Require<
is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
unique_ptr(auto_ptr<_Up>&& __u) noexcept;
~unique_ptr() noexcept
{
auto& __ptr = std::get<0>(_M_t);
if (__ptr != nullptr)
get_deleter()(__ptr);
__ptr = pointer();
}
unique_ptr&
operator=(unique_ptr&& __u) noexcept
{
reset(__u.release());
get_deleter() = std::forward<deleter_type>(__u.get_deleter());
return *this;
}
template<typename _Up, typename _Ep>
typename enable_if< __and_<
is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
__not_<is_array<_Up>>
>::value,
unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
reset(__u.release());
get_deleter() = std::forward<_Ep>(__u.get_deleter());
return *this;
}
unique_ptr&
operator=(nullptr_t) noexcept
{
reset();
return *this;
}
typename add_lvalue_reference<element_type>::type
operator*() const
{
;
return *get();
}
pointer
operator->() const noexcept
{
;
return get();
}
pointer
get() const noexcept
{ return std::get<0>(_M_t); }
deleter_type&
get_deleter() noexcept
{ return std::get<1>(_M_t); }
const deleter_type&
get_deleter() const noexcept
{ return std::get<1>(_M_t); }
explicit operator bool() const noexcept
{ return get() == pointer() ? false : true; }
pointer
release() noexcept
{
pointer __p = get();
std::get<0>(_M_t) = pointer();
return __p;
}
void
reset(pointer __p = pointer()) noexcept
{
using std::swap;
swap(std::get<0>(_M_t), __p);
if (__p != pointer())
get_deleter()(__p);
}
void
swap(unique_ptr& __u) noexcept
{
using std::swap;
swap(_M_t, __u._M_t);
}
unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;
};
template<typename _Tp, typename _Dp>
class unique_ptr<_Tp[], _Dp>
{
class _Pointer
{
template<typename _Up>
static typename _Up::pointer __test(typename _Up::pointer*);
template<typename _Up>
static _Tp* __test(...);
typedef typename remove_reference<_Dp>::type _Del;
public:
typedef decltype(__test<_Del>(0)) type;
};
typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
__tuple_type _M_t;
template<typename _Up>
using __remove_cv = typename remove_cv<_Up>::type;
template<typename _Up>
using __is_derived_Tp
= __and_< is_base_of<_Tp, _Up>,
__not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
template<typename _Up, typename _Ep,
typename _Tp_pointer = typename _Pointer::type,
typename _Up_pointer = typename unique_ptr<_Up, _Ep>::pointer>
using __safe_conversion = __and_<
is_convertible<_Up_pointer, _Tp_pointer>,
is_array<_Up>,
__or_<__not_<is_pointer<_Up_pointer>>,
__not_<is_pointer<_Tp_pointer>>,
__not_<__is_derived_Tp<typename remove_extent<_Up>::type>>
>
>;
public:
typedef typename _Pointer::type pointer;
typedef _Tp element_type;
typedef _Dp deleter_type;
constexpr unique_ptr() noexcept
: _M_t()
{ static_assert(!std::is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
explicit
unique_ptr(pointer __p) noexcept
: _M_t(__p, deleter_type())
{ static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
template<typename _Up, typename = _Require<is_pointer<pointer>,
is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
explicit
unique_ptr(_Up* __p) = delete;
unique_ptr(pointer __p,
typename conditional<is_reference<deleter_type>::value,
deleter_type, const deleter_type&>::type __d) noexcept
: _M_t(__p, __d) { }
unique_ptr(pointer __p, typename
remove_reference<deleter_type>::type&& __d) noexcept
: _M_t(std::move(__p), std::move(__d))
{ static_assert(!is_reference<deleter_type>::value,
"rvalue deleter bound to reference"); }
unique_ptr(unique_ptr&& __u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
template<typename _Up, typename _Ep,
typename = _Require<__safe_conversion<_Up, _Ep>,
typename conditional<is_reference<_Dp>::value,
is_same<_Ep, _Dp>,
is_convertible<_Ep, _Dp>>::type
>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }
~unique_ptr()
{
auto& __ptr = std::get<0>(_M_t);
if (__ptr != nullptr)
get_deleter()(__ptr);
__ptr = pointer();
}
unique_ptr&
operator=(unique_ptr&& __u) noexcept
{
reset(__u.release());
get_deleter() = std::forward<deleter_type>(__u.get_deleter());
return *this;
}
template<typename _Up, typename _Ep>
typename
enable_if<__safe_conversion<_Up, _Ep>::value, unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
reset(__u.release());
get_deleter() = std::forward<_Ep>(__u.get_deleter());
return *this;
}
unique_ptr&
operator=(nullptr_t) noexcept
{
reset();
return *this;
}
typename std::add_lvalue_reference<element_type>::type
operator[](size_t __i) const
{
;
return get()[__i];
}
pointer
get() const noexcept
{ return std::get<0>(_M_t); }
deleter_type&
get_deleter() noexcept
{ return std::get<1>(_M_t); }
const deleter_type&
get_deleter() const noexcept
{ return std::get<1>(_M_t); }
explicit operator bool() const noexcept
{ return get() == pointer() ? false : true; }
pointer
release() noexcept
{
pointer __p = get();
std::get<0>(_M_t) = pointer();
return __p;
}
void
reset(pointer __p = pointer()) noexcept
{
using std::swap;
swap(std::get<0>(_M_t), __p);
if (__p != nullptr)
get_deleter()(__p);
}
template<typename _Up, typename = _Require<is_pointer<pointer>,
is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
void reset(_Up*) = delete;
void
swap(unique_ptr& __u) noexcept
{
using std::swap;
swap(_M_t, __u._M_t);
}
unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;
template<typename _Up, typename = _Require<is_pointer<pointer>,
is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
unique_ptr(_Up*, typename
conditional<is_reference<deleter_type>::value,
deleter_type, const deleter_type&>::type) = delete;
template<typename _Up, typename = _Require<is_pointer<pointer>,
is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
unique_ptr(_Up*, typename
remove_reference<deleter_type>::type&&) = delete;
};
template<typename _Tp, typename _Dp>
inline void
swap(unique_ptr<_Tp, _Dp>& __x,
unique_ptr<_Tp, _Dp>& __y) noexcept
{ __x.swap(__y); }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator==(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return __x.get() == __y.get(); }
template<typename _Tp, typename _Dp>
inline bool
operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
{ return !__x; }
template<typename _Tp, typename _Dp>
inline bool
operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
{ return !__x; }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator!=(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return __x.get() != __y.get(); }
template<typename _Tp, typename _Dp>
inline bool
operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
{ return (bool)__x; }
template<typename _Tp, typename _Dp>
inline bool
operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
{ return (bool)__x; }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator<(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{
typedef typename
std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
return std::less<_CT>()(__x.get(), __y.get());
}
template<typename _Tp, typename _Dp>
inline bool
operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
{ return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
nullptr); }
template<typename _Tp, typename _Dp>
inline bool
operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
{ return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
__x.get()); }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator<=(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return !(__y < __x); }
template<typename _Tp, typename _Dp>
inline bool
operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
{ return !(nullptr < __x); }
template<typename _Tp, typename _Dp>
inline bool
operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
{ return !(__x < nullptr); }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator>(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return (__y < __x); }
template<typename _Tp, typename _Dp>
inline bool
operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
{ return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
__x.get()); }
template<typename _Tp, typename _Dp>
inline bool
operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
{ return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
nullptr); }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator>=(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return !(__x < __y); }
template<typename _Tp, typename _Dp>
inline bool
operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
{ return !(__x < nullptr); }
template<typename _Tp, typename _Dp>
inline bool
operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
{ return !(nullptr < __x); }
template<typename _Tp, typename _Dp>
struct hash<unique_ptr<_Tp, _Dp>>
: public __hash_base<size_t, unique_ptr<_Tp, _Dp>>
{
size_t
operator()(const unique_ptr<_Tp, _Dp>& __u) const noexcept
{
typedef unique_ptr<_Tp, _Dp> _UP;
return std::hash<typename _UP::pointer>()(__u.get());
}
};
}
#define _SHARED_PTR_H 1
#define _SHARED_PTR_BASE_H 1
#define _ALLOCATED_PTR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc>
struct __allocated_ptr
{
using pointer = typename allocator_traits<_Alloc>::pointer;
using value_type = typename allocator_traits<_Alloc>::value_type;
__allocated_ptr(_Alloc& __a, pointer __ptr) noexcept
: _M_alloc(&__a), _M_ptr(__ptr)
{ }
template<typename _Ptr,
typename _Req = _Require<is_same<_Ptr, value_type*>>>
__allocated_ptr(_Alloc& __a, _Ptr __ptr)
: _M_alloc(&__a), _M_ptr(pointer_traits<pointer>::pointer_to(*__ptr))
{ }
__allocated_ptr(__allocated_ptr&& __gd) noexcept
: _M_alloc(__gd._M_alloc), _M_ptr(__gd._M_ptr)
{ __gd._M_ptr = nullptr; }
~__allocated_ptr()
{
if (_M_ptr != nullptr)
std::allocator_traits<_Alloc>::deallocate(*_M_alloc, _M_ptr, 1);
}
__allocated_ptr&
operator=(std::nullptr_t) noexcept
{
_M_ptr = nullptr;
return *this;
}
value_type* get() { return _S_raw_ptr(_M_ptr); }
private:
value_type* _S_raw_ptr(value_type* __ptr) { return __ptr; }
template<typename _Ptr>
auto _S_raw_ptr(_Ptr __ptr) -> decltype(_S_raw_ptr(__ptr.operator->()))
{ return _S_raw_ptr(__ptr.operator->()); }
_Alloc* _M_alloc;
pointer _M_ptr;
};
template<typename _Alloc>
__allocated_ptr<_Alloc>
__allocate_guarded(_Alloc& __a)
;
}
#define _ALIGNED_BUFFER_H 1
namespace __gnu_cxx
{
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()); }
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename> class auto_ptr;
class bad_weak_ptr : public std::exception
{
public:
virtual char const*
what() const noexcept;
virtual ~bad_weak_ptr() noexcept;
};
void
__throw_bad_weak_ptr()
;
using __gnu_cxx::_Lock_policy;
using __gnu_cxx::__default_lock_policy;
using __gnu_cxx::_S_single;
using __gnu_cxx::_S_mutex;
using __gnu_cxx::_S_atomic;
template<_Lock_policy _Lp>
class _Mutex_base
{
protected:
enum { _S_need_barriers = 0 };
};
template<>
class _Mutex_base<_S_mutex>
: public __gnu_cxx::__mutex
{
protected:
enum { _S_need_barriers = 1 };
};
template<_Lock_policy _Lp = __default_lock_policy>
class _Sp_counted_base
: public _Mutex_base<_Lp>
{
public:
_Sp_counted_base() noexcept
: _M_use_count(1), _M_weak_count(1) { }
virtual
~_Sp_counted_base() noexcept
{ }
virtual void
_M_dispose() noexcept = 0;
virtual void
_M_destroy() noexcept
{ delete this; }
virtual void*
_M_get_deleter(const std::type_info&) noexcept = 0;
void
_M_add_ref_copy()
;
void
_M_add_ref_lock();
bool
_M_add_ref_lock_nothrow();
void
_M_release() noexcept
{
;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
{
;
_M_dispose();
if (_Mutex_base<_Lp>::_S_need_barriers)
{
__asm __volatile ("":::"memory");
__asm __volatile ("":::"memory");
}
;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
-1) == 1)
{
;
_M_destroy();
}
}
}
void
_M_weak_add_ref() noexcept
{ __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }
void
_M_weak_release() noexcept
{
;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
{
;
if (_Mutex_base<_Lp>::_S_need_barriers)
{
__asm __volatile ("":::"memory");
__asm __volatile ("":::"memory");
}
_M_destroy();
}
}
long
_M_get_use_count() const noexcept
{
return __atomic_load_n(&_M_use_count, 0);
}
private:
_Sp_counted_base(_Sp_counted_base const&) = delete;
_Sp_counted_base& operator=(_Sp_counted_base const&) = delete;
_Atomic_word _M_use_count;
_Atomic_word _M_weak_count;
};
template<>
inline void
_Sp_counted_base<_S_single>::_M_release() noexcept
{
if (--_M_use_count == 0)
{
_M_dispose();
if (--_M_weak_count == 0)
_M_destroy();
}
}
template<>
inline void
_Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept
{ ++_M_weak_count; }
template<>
inline void
_Sp_counted_base<_S_single>::_M_weak_release() noexcept
{
if (--_M_weak_count == 0)
_M_destroy();
}
template<>
inline long
_Sp_counted_base<_S_single>::_M_get_use_count() const noexcept
{ return _M_use_count; }
template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
class __shared_ptr;
template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
class __weak_ptr;
template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
class __enable_shared_from_this;
template<typename _Tp>
class shared_ptr;
template<typename _Tp>
class weak_ptr;
template<typename _Tp>
struct owner_less;
template<typename _Tp>
class enable_shared_from_this;
template<_Lock_policy _Lp = __default_lock_policy>
class __weak_count;
template<_Lock_policy _Lp = __default_lock_policy>
class __shared_count;
template<typename _Ptr, _Lock_policy _Lp>
class _Sp_counted_ptr final : public _Sp_counted_base<_Lp>
{
public:
explicit
_Sp_counted_ptr(_Ptr __p) noexcept
: _M_ptr(__p) { }
virtual void
_M_dispose() noexcept
{ delete _M_ptr; }
virtual void
_M_destroy() noexcept
{ delete this; }
virtual void*
_M_get_deleter(const std::type_info&) noexcept
{ return nullptr; }
_Sp_counted_ptr(const _Sp_counted_ptr&) = delete;
_Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete;
private:
_Ptr _M_ptr;
};
template<>
inline void
_Sp_counted_ptr<nullptr_t, _S_single>::_M_dispose() noexcept { }
template<>
inline void
_Sp_counted_ptr<nullptr_t, _S_mutex>::_M_dispose() noexcept { }
template<>
inline void
_Sp_counted_ptr<nullptr_t, _S_atomic>::_M_dispose() noexcept { }
template<int _Nm, typename _Tp,
bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
struct _Sp_ebo_helper;
template<int _Nm, typename _Tp>
struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp
{
explicit _Sp_ebo_helper(const _Tp& __tp) ;
static _Tp&
_S_get(_Sp_ebo_helper& __eboh) ;
};
template<int _Nm, typename _Tp>
struct _Sp_ebo_helper<_Nm, _Tp, false>
{
explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { }
static _Tp&
_S_get(_Sp_ebo_helper& __eboh)
{ return __eboh._M_tp; }
private:
_Tp _M_tp;
};
template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
class _Sp_counted_deleter final : public _Sp_counted_base<_Lp>
{
class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc>
{
typedef _Sp_ebo_helper<0, _Deleter> _Del_base;
typedef _Sp_ebo_helper<1, _Alloc> _Alloc_base;
public:
_Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
: _M_ptr(__p), _Del_base(__d), _Alloc_base(__a)
{ }
_Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); }
_Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); }
_Ptr _M_ptr;
};
public:
using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_deleter>;
_Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept
: _M_impl(__p, __d, _Alloc()) { }
_Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
: _M_impl(__p, __d, __a) { }
~_Sp_counted_deleter() noexcept { }
virtual void
_M_dispose() noexcept
{ _M_impl._M_del()(_M_impl._M_ptr); }
virtual void
_M_destroy() noexcept
{
__allocator_type __a(_M_impl._M_alloc());
__allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
this->~_Sp_counted_deleter();
}
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept
{
return __ti == typeid(_Deleter) ? &_M_impl._M_del() : nullptr;
}
private:
_Impl _M_impl;
};
struct _Sp_make_shared_tag { };
template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp>
{
class _Impl : _Sp_ebo_helper<0, _Alloc>
{
typedef _Sp_ebo_helper<0, _Alloc> _A_base;
public:
explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { }
_Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); }
__gnu_cxx::__aligned_buffer<_Tp> _M_storage;
};
public:
using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>;
template<typename... _Args>
_Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
: _M_impl(__a)
{
allocator_traits<_Alloc>::construct(__a, _M_ptr(),
std::forward<_Args>(__args)...);
}
~_Sp_counted_ptr_inplace() noexcept { }
virtual void
_M_dispose() noexcept
{
allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
}
virtual void
_M_destroy() noexcept
{
__allocator_type __a(_M_impl._M_alloc());
__allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
this->~_Sp_counted_ptr_inplace();
}
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept
{
if (__ti == typeid(_Sp_make_shared_tag))
return const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
return nullptr;
}
private:
_Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); }
_Impl _M_impl;
};
template<_Lock_policy _Lp>
class __shared_count
{
public:
constexpr __shared_count() noexcept : _M_pi(0)
{ }
template<typename _Ptr>
explicit
__shared_count(_Ptr __p) : _M_pi(0)
{
try
{
_M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
}
catch(...)
{
delete __p;
throw;
}
}
template<typename _Ptr, typename _Deleter>
__shared_count(_Ptr __p, _Deleter __d)
: __shared_count(__p, std::move(__d), allocator<void>())
{ }
template<typename _Ptr, typename _Deleter, typename _Alloc>
__shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
{
typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
try
{
typename _Sp_cd_type::__allocator_type __a2(__a);
auto __guard = std::__allocate_guarded(__a2);
_Sp_cd_type* __mem = __guard.get();
::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a));
_M_pi = __mem;
__guard = nullptr;
}
catch(...)
{
__d(__p);
throw;
}
}
template<typename _Tp, typename _Alloc, typename... _Args>
__shared_count(_Sp_make_shared_tag, _Tp*, const _Alloc& __a,
_Args&&... __args)
: _M_pi(0)
{
typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
typename _Sp_cp_type::__allocator_type __a2(__a);
auto __guard = std::__allocate_guarded(__a2);
_Sp_cp_type* __mem = __guard.get();
::new (__mem) _Sp_cp_type(std::move(__a),
std::forward<_Args>(__args)...);
_M_pi = __mem;
__guard = nullptr;
}
template<typename _Tp>
explicit
__shared_count(std::auto_ptr<_Tp>&& __r);
template<typename _Tp, typename _Del>
explicit
__shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0)
{
using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
using _Del2 = typename conditional<is_reference<_Del>::value,
reference_wrapper<typename remove_reference<_Del>::type>,
_Del>::type;
using _Sp_cd_type
= _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
using _Alloc = allocator<_Sp_cd_type>;
using _Alloc_traits = allocator_traits<_Alloc>;
_Alloc __a;
_Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1);
_Alloc_traits::construct(__a, __mem, __r.release(),
__r.get_deleter());
_M_pi = __mem;
}
explicit __shared_count(const __weak_count<_Lp>& __r);
explicit __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t);
~__shared_count() noexcept
{
if (_M_pi != nullptr)
_M_pi->_M_release();
}
__shared_count(const __shared_count& __r) noexcept
: _M_pi(__r._M_pi)
{
if (_M_pi != 0)
_M_pi->_M_add_ref_copy();
}
__shared_count&
operator=(const __shared_count& __r) noexcept
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != _M_pi)
{
if (__tmp != 0)
__tmp->_M_add_ref_copy();
if (_M_pi != 0)
_M_pi->_M_release();
_M_pi = __tmp;
}
return *this;
}
void
_M_swap(__shared_count& __r) noexcept
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
}
long
_M_get_use_count() const noexcept
{ return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
bool
_M_unique() const noexcept
{ return this->_M_get_use_count() == 1; }
void*
_M_get_deleter(const std::type_info& __ti) const noexcept
{ return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; }
bool
_M_less(const __shared_count& __rhs) const noexcept
{ return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
bool
_M_less(const __weak_count<_Lp>& __rhs) const noexcept
{ return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
friend inline bool
operator==(const __shared_count& __a, const __shared_count& __b) noexcept
{ return __a._M_pi == __b._M_pi; }
private:
friend class __weak_count<_Lp>;
_Sp_counted_base<_Lp>* _M_pi;
};
template<_Lock_policy _Lp>
class __weak_count
{
public:
constexpr __weak_count() noexcept : _M_pi(0)
{ }
__weak_count(const __shared_count<_Lp>& __r) noexcept
: _M_pi(__r._M_pi)
{
if (_M_pi != 0)
_M_pi->_M_weak_add_ref();
}
__weak_count(const __weak_count<_Lp>& __r) noexcept
: _M_pi(__r._M_pi)
{
if (_M_pi != 0)
_M_pi->_M_weak_add_ref();
}
~__weak_count() noexcept
{
if (_M_pi != 0)
_M_pi->_M_weak_release();
}
__weak_count<_Lp>&
operator=(const __shared_count<_Lp>& __r) noexcept
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != 0)
__tmp->_M_weak_add_ref();
if (_M_pi != 0)
_M_pi->_M_weak_release();
_M_pi = __tmp;
return *this;
}
__weak_count<_Lp>&
operator=(const __weak_count<_Lp>& __r) noexcept
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != 0)
__tmp->_M_weak_add_ref();
if (_M_pi != 0)
_M_pi->_M_weak_release();
_M_pi = __tmp;
return *this;
}
void
_M_swap(__weak_count<_Lp>& __r) noexcept
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
}
long
_M_get_use_count() const noexcept
{ return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
bool
_M_less(const __weak_count& __rhs) const noexcept
{ return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
bool
_M_less(const __shared_count<_Lp>& __rhs) const noexcept
{ return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
friend inline bool
operator==(const __weak_count& __a, const __weak_count& __b) noexcept
{ return __a._M_pi == __b._M_pi; }
private:
friend class __shared_count<_Lp>;
_Sp_counted_base<_Lp>* _M_pi;
};
template<_Lock_policy _Lp>
inline
__shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r)
: _M_pi(__r._M_pi)
{
if (_M_pi != nullptr)
_M_pi->_M_add_ref_lock();
else
__throw_bad_weak_ptr();
}
template<_Lock_policy _Lp>
inline
__shared_count<_Lp>::
__shared_count(const __weak_count<_Lp>& __r, std::nothrow_t)
: _M_pi(__r._M_pi)
{
if (_M_pi != nullptr)
if (!_M_pi->_M_add_ref_lock_nothrow())
_M_pi = nullptr;
}
template<_Lock_policy _Lp, typename _Tp1, typename _Tp2>
void
__enable_shared_from_this_helper(const __shared_count<_Lp>&,
const __enable_shared_from_this<_Tp1,
_Lp>*, const _Tp2*) noexcept;
template<typename _Tp1, typename _Tp2>
void
__enable_shared_from_this_helper(const __shared_count<>&,
const enable_shared_from_this<_Tp1>*,
const _Tp2*) noexcept;
template<_Lock_policy _Lp>
inline void
__enable_shared_from_this_helper(const __shared_count<_Lp>&, ...) noexcept
{ }
template<typename _Tp, _Lock_policy _Lp>
class __shared_ptr
{
public:
typedef _Tp element_type;
constexpr __shared_ptr() noexcept
: _M_ptr(0), _M_refcount()
{ }
template<typename _Tp1>
explicit __shared_ptr(_Tp1* __p)
: _M_ptr(__p), _M_refcount(__p)
{
static_assert( !is_void<_Tp1>::value, "incomplete type" );
static_assert( sizeof(_Tp1) > 0, "incomplete type" );
__enable_shared_from_this_helper(_M_refcount, __p, __p);
}
template<typename _Tp1, typename _Deleter>
__shared_ptr(_Tp1* __p, _Deleter __d)
: _M_ptr(__p), _M_refcount(__p, __d)
{
__enable_shared_from_this_helper(_M_refcount, __p, __p);
}
template<typename _Tp1, typename _Deleter, typename _Alloc>
__shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)
: _M_ptr(__p), _M_refcount(__p, __d, std::move(__a))
{
__enable_shared_from_this_helper(_M_refcount, __p, __p);
}
template<typename _Deleter>
__shared_ptr(nullptr_t __p, _Deleter __d)
: _M_ptr(0), _M_refcount(__p, __d)
{ }
template<typename _Deleter, typename _Alloc>
__shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
: _M_ptr(0), _M_refcount(__p, __d, std::move(__a))
{ }
template<typename _Tp1>
__shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, _Tp* __p) noexcept
: _M_ptr(__p), _M_refcount(__r._M_refcount)
{ }
__shared_ptr(const __shared_ptr&) noexcept = default;
__shared_ptr& operator=(const __shared_ptr&) noexcept = default;
~__shared_ptr() = default;
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
__shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
{ }
__shared_ptr(__shared_ptr&& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount()
{
_M_refcount._M_swap(__r._M_refcount);
__r._M_ptr = 0;
}
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
__shared_ptr(__shared_ptr<_Tp1, _Lp>&& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount()
{
_M_refcount._M_swap(__r._M_refcount);
__r._M_ptr = 0;
}
template<typename _Tp1>
explicit __shared_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
: _M_refcount(__r._M_refcount)
{
_M_ptr = __r._M_ptr;
}
template<typename _Tp1, typename _Del>
__shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r)
: _M_ptr(__r.get()), _M_refcount()
{
auto __raw = _S_raw_ptr(__r.get());
_M_refcount = __shared_count<_Lp>(std::move(__r));
__enable_shared_from_this_helper(_M_refcount, __raw, __raw);
}
template<typename _Tp1>
__shared_ptr(std::auto_ptr<_Tp1>&& __r);
constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { }
template<typename _Tp1>
__shared_ptr&
operator=(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
{
_M_ptr = __r._M_ptr;
_M_refcount = __r._M_refcount;
return *this;
}
template<typename _Tp1>
__shared_ptr&
operator=(std::auto_ptr<_Tp1>&& __r)
{
__shared_ptr(std::move(__r)).swap(*this);
return *this;
}
__shared_ptr&
operator=(__shared_ptr&& __r) noexcept
{
__shared_ptr(std::move(__r)).swap(*this);
return *this;
}
template<class _Tp1>
__shared_ptr&
operator=(__shared_ptr<_Tp1, _Lp>&& __r) noexcept
{
__shared_ptr(std::move(__r)).swap(*this);
return *this;
}
template<typename _Tp1, typename _Del>
__shared_ptr&
operator=(std::unique_ptr<_Tp1, _Del>&& __r)
{
__shared_ptr(std::move(__r)).swap(*this);
return *this;
}
void
reset() noexcept
{ __shared_ptr().swap(*this); }
template<typename _Tp1>
void
reset(_Tp1* __p)
{
;
__shared_ptr(__p).swap(*this);
}
template<typename _Tp1, typename _Deleter>
void
reset(_Tp1* __p, _Deleter __d)
{ __shared_ptr(__p, __d).swap(*this); }
template<typename _Tp1, typename _Deleter, typename _Alloc>
void
reset(_Tp1* __p, _Deleter __d, _Alloc __a)
{ __shared_ptr(__p, __d, std::move(__a)).swap(*this); }
typename std::add_lvalue_reference<_Tp>::type
operator*() const noexcept
{
;
return *_M_ptr;
}
_Tp*
operator->() const noexcept
{
;
return _M_ptr;
}
_Tp*
get() const noexcept
{ return _M_ptr; }
explicit operator bool() const
{ return _M_ptr == 0 ? false : true; }
bool
unique() const noexcept
{ return _M_refcount._M_unique(); }
long
use_count() const noexcept
{ return _M_refcount._M_get_use_count(); }
void
swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
{
std::swap(_M_ptr, __other._M_ptr);
_M_refcount._M_swap(__other._M_refcount);
}
template<typename _Tp1>
bool
owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const
{ return _M_refcount._M_less(__rhs._M_refcount); }
template<typename _Tp1>
bool
owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const
{ return _M_refcount._M_less(__rhs._M_refcount); }
protected:
template<typename _Alloc, typename... _Args>
__shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
_Args&&... __args)
: _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a,
std::forward<_Args>(__args)...)
{
void* __p = _M_refcount._M_get_deleter(typeid(__tag));
_M_ptr = static_cast<_Tp*>(__p);
__enable_shared_from_this_helper(_M_refcount, _M_ptr, _M_ptr);
}
template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
typename... _Args>
friend __shared_ptr<_Tp1, _Lp1>
__allocate_shared(const _Alloc& __a, _Args&&... __args);
__shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t)
: _M_refcount(__r._M_refcount, std::nothrow)
{
_M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr;
}
friend class __weak_ptr<_Tp, _Lp>;
private:
void*
_M_get_deleter(const std::type_info& __ti) const noexcept
{ return _M_refcount._M_get_deleter(__ti); }
template<typename _Tp1>
static _Tp1*
_S_raw_ptr(_Tp1* __ptr)
{ return __ptr; }
template<typename _Tp1>
static auto
_S_raw_ptr(_Tp1 __ptr) -> decltype(std::__addressof(*__ptr))
{ return std::__addressof(*__ptr); }
template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept;
_Tp* _M_ptr;
__shared_count<_Lp> _M_refcount;
};
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool
operator==(const __shared_ptr<_Tp1, _Lp>& __a,
const __shared_ptr<_Tp2, _Lp>& __b) noexcept
{ return __a.get() == __b.get(); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
{ return !__a; }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
{ return !__a; }
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool
operator!=(const __shared_ptr<_Tp1, _Lp>& __a,
const __shared_ptr<_Tp2, _Lp>& __b) noexcept
{ return __a.get() != __b.get(); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
{ return (bool)__a; }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
{ return (bool)__a; }
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool
operator<(const __shared_ptr<_Tp1, _Lp>& __a,
const __shared_ptr<_Tp2, _Lp>& __b) noexcept
{
typedef typename std::common_type<_Tp1*, _Tp2*>::type _CT;
return std::less<_CT>()(__a.get(), __b.get());
}
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
{ return std::less<_Tp*>()(__a.get(), nullptr); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
{ return std::less<_Tp*>()(nullptr, __a.get()); }
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool
operator<=(const __shared_ptr<_Tp1, _Lp>& __a,
const __shared_ptr<_Tp2, _Lp>& __b) noexcept
{ return !(__b < __a); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
{ return !(nullptr < __a); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
{ return !(__a < nullptr); }
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool
operator>(const __shared_ptr<_Tp1, _Lp>& __a,
const __shared_ptr<_Tp2, _Lp>& __b) noexcept
{ return (__b < __a); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
{ return std::less<_Tp*>()(nullptr, __a.get()); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
{ return std::less<_Tp*>()(__a.get(), nullptr); }
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
inline bool
operator>=(const __shared_ptr<_Tp1, _Lp>& __a,
const __shared_ptr<_Tp2, _Lp>& __b) noexcept
{ return !(__a < __b); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
{ return !(__a < nullptr); }
template<typename _Tp, _Lock_policy _Lp>
inline bool
operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
{ return !(nullptr < __a); }
template<typename _Sp>
struct _Sp_less : public binary_function<_Sp, _Sp, bool>
{
bool
operator()(const _Sp& __lhs, const _Sp& __rhs) const noexcept
{
typedef typename _Sp::element_type element_type;
return std::less<element_type*>()(__lhs.get(), __rhs.get());
}
};
template<typename _Tp, _Lock_policy _Lp>
struct less<__shared_ptr<_Tp, _Lp>>
: public _Sp_less<__shared_ptr<_Tp, _Lp>>
{ };
template<typename _Tp, _Lock_policy _Lp>
inline void
swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept
{ __a.swap(__b); }
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
inline __shared_ptr<_Tp, _Lp>
static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
{ return __shared_ptr<_Tp, _Lp>(__r, static_cast<_Tp*>(__r.get())); }
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
inline __shared_ptr<_Tp, _Lp>
const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
{ return __shared_ptr<_Tp, _Lp>(__r, const_cast<_Tp*>(__r.get())); }
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
inline __shared_ptr<_Tp, _Lp>
dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
{
if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
return __shared_ptr<_Tp, _Lp>(__r, __p);
return __shared_ptr<_Tp, _Lp>();
}
template<typename _Tp, _Lock_policy _Lp>
class __weak_ptr
{
public:
typedef _Tp element_type;
constexpr __weak_ptr() noexcept
: _M_ptr(0), _M_refcount()
{ }
__weak_ptr(const __weak_ptr&) noexcept = default;
__weak_ptr& operator=(const __weak_ptr&) noexcept = default;
~__weak_ptr() = default;
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
__weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r) noexcept
: _M_refcount(__r._M_refcount)
{ _M_ptr = __r.lock().get(); }
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
__weak_ptr(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
{ }
template<typename _Tp1>
__weak_ptr&
operator=(const __weak_ptr<_Tp1, _Lp>& __r) noexcept
{
_M_ptr = __r.lock().get();
_M_refcount = __r._M_refcount;
return *this;
}
template<typename _Tp1>
__weak_ptr&
operator=(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
{
_M_ptr = __r._M_ptr;
_M_refcount = __r._M_refcount;
return *this;
}
__shared_ptr<_Tp, _Lp>
lock() const noexcept
{ return __shared_ptr<element_type, _Lp>(*this, std::nothrow); }
long
use_count() const noexcept
{ return _M_refcount._M_get_use_count(); }
bool
expired() const noexcept
{ return _M_refcount._M_get_use_count() == 0; }
template<typename _Tp1>
bool
owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const
{ return _M_refcount._M_less(__rhs._M_refcount); }
template<typename _Tp1>
bool
owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const
{ return _M_refcount._M_less(__rhs._M_refcount); }
void
reset() noexcept
{ __weak_ptr().swap(*this); }
void
swap(__weak_ptr& __s) noexcept
{
std::swap(_M_ptr, __s._M_ptr);
_M_refcount._M_swap(__s._M_refcount);
}
private:
void
_M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept
{
_M_ptr = __ptr;
_M_refcount = __refcount;
}
template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
friend class __enable_shared_from_this<_Tp, _Lp>;
friend class enable_shared_from_this<_Tp>;
_Tp* _M_ptr;
__weak_count<_Lp> _M_refcount;
};
template<typename _Tp, _Lock_policy _Lp>
inline void
swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept
{ __a.swap(__b); }
template<typename _Tp, typename _Tp1>
struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
{
bool
operator()(const _Tp& __lhs, const _Tp& __rhs) const
{ return __lhs.owner_before(__rhs); }
bool
operator()(const _Tp& __lhs, const _Tp1& __rhs) const
{ return __lhs.owner_before(__rhs); }
bool
operator()(const _Tp1& __lhs, const _Tp& __rhs) const
{ return __lhs.owner_before(__rhs); }
};
template<typename _Tp, _Lock_policy _Lp>
struct owner_less<__shared_ptr<_Tp, _Lp>>
: public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
{ };
template<typename _Tp, _Lock_policy _Lp>
struct owner_less<__weak_ptr<_Tp, _Lp>>
: public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
{ };
template<typename _Tp, _Lock_policy _Lp>
class __enable_shared_from_this
{
protected:
constexpr __enable_shared_from_this() noexcept { }
__enable_shared_from_this(const __enable_shared_from_this&) noexcept { }
__enable_shared_from_this&
operator=(const __enable_shared_from_this&) noexcept
{ return *this; }
~__enable_shared_from_this() { }
public:
__shared_ptr<_Tp, _Lp>
shared_from_this()
{ return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }
__shared_ptr<const _Tp, _Lp>
shared_from_this() const
{ return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }
private:
template<typename _Tp1>
void
_M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept
{ _M_weak_this._M_assign(__p, __n); }
template<typename _Tp1>
friend void
__enable_shared_from_this_helper(const __shared_count<_Lp>& __pn,
const __enable_shared_from_this* __pe,
const _Tp1* __px) noexcept
{
if (__pe != 0)
__pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
}
mutable __weak_ptr<_Tp, _Lp> _M_weak_this;
};
template<typename _Tp, _Lock_policy _Lp, typename _Alloc, typename... _Args>
inline __shared_ptr<_Tp, _Lp>
__allocate_shared(const _Alloc& __a, _Args&&... __args)
{
return __shared_ptr<_Tp, _Lp>(_Sp_make_shared_tag(), __a,
std::forward<_Args>(__args)...);
}
template<typename _Tp, _Lock_policy _Lp, typename... _Args>
inline __shared_ptr<_Tp, _Lp>
__make_shared(_Args&&... __args)
{
typedef typename std::remove_const<_Tp>::type _Tp_nc;
return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
std::forward<_Args>(__args)...);
}
template<typename _Tp, _Lock_policy _Lp>
struct hash<__shared_ptr<_Tp, _Lp>>
: public __hash_base<size_t, __shared_ptr<_Tp, _Lp>>
{
size_t
operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept
{ return std::hash<_Tp*>()(__s.get()); }
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
inline std::basic_ostream<_Ch, _Tr>&
operator<<(std::basic_ostream<_Ch, _Tr>& __os,
const __shared_ptr<_Tp, _Lp>& __p)
{
__os << __p.get();
return __os;
}
template<typename _Del, typename _Tp, _Lock_policy _Lp>
inline _Del*
get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept
{
return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
}
template<typename _Tp>
class shared_ptr : public __shared_ptr<_Tp>
{
public:
constexpr shared_ptr() noexcept
: __shared_ptr<_Tp>() { }
shared_ptr(const shared_ptr&) noexcept = default;
template<typename _Tp1>
explicit shared_ptr(_Tp1* __p)
: __shared_ptr<_Tp>(__p) { }
template<typename _Tp1, typename _Deleter>
shared_ptr(_Tp1* __p, _Deleter __d)
: __shared_ptr<_Tp>(__p, __d) { }
template<typename _Deleter>
shared_ptr(nullptr_t __p, _Deleter __d)
: __shared_ptr<_Tp>(__p, __d) { }
template<typename _Tp1, typename _Deleter, typename _Alloc>
shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)
: __shared_ptr<_Tp>(__p, __d, std::move(__a)) { }
template<typename _Deleter, typename _Alloc>
shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
: __shared_ptr<_Tp>(__p, __d, std::move(__a)) { }
template<typename _Tp1>
shared_ptr(const shared_ptr<_Tp1>& __r, _Tp* __p) noexcept
: __shared_ptr<_Tp>(__r, __p) { }
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
shared_ptr(const shared_ptr<_Tp1>& __r) noexcept
: __shared_ptr<_Tp>(__r) { }
shared_ptr(shared_ptr&& __r) noexcept
: __shared_ptr<_Tp>(std::move(__r)) { }
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
shared_ptr(shared_ptr<_Tp1>&& __r) noexcept
: __shared_ptr<_Tp>(std::move(__r)) { }
template<typename _Tp1>
explicit shared_ptr(const weak_ptr<_Tp1>& __r)
: __shared_ptr<_Tp>(__r) { }
template<typename _Tp1>
shared_ptr(std::auto_ptr<_Tp1>&& __r);
template<typename _Tp1, typename _Del>
shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r)
: __shared_ptr<_Tp>(std::move(__r)) { }
constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }
shared_ptr& operator=(const shared_ptr&) noexcept = default;
template<typename _Tp1>
shared_ptr&
operator=(const shared_ptr<_Tp1>& __r) noexcept
{
this->__shared_ptr<_Tp>::operator=(__r);
return *this;
}
template<typename _Tp1>
shared_ptr&
operator=(std::auto_ptr<_Tp1>&& __r)
{
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
}
shared_ptr&
operator=(shared_ptr&& __r) noexcept
{
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
}
template<class _Tp1>
shared_ptr&
operator=(shared_ptr<_Tp1>&& __r) noexcept
{
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
}
template<typename _Tp1, typename _Del>
shared_ptr&
operator=(std::unique_ptr<_Tp1, _Del>&& __r)
{
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
}
private:
template<typename _Alloc, typename... _Args>
shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
_Args&&... __args)
: __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...)
{ }
template<typename _Tp1, typename _Alloc, typename... _Args>
friend shared_ptr<_Tp1>
allocate_shared(const _Alloc& __a, _Args&&... __args);
shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t)
: __shared_ptr<_Tp>(__r, std::nothrow) { }
friend class weak_ptr<_Tp>;
};
template<typename _Tp1, typename _Tp2>
inline bool
operator==(const shared_ptr<_Tp1>& __a,
const shared_ptr<_Tp2>& __b) noexcept
{ return __a.get() == __b.get(); }
template<typename _Tp>
inline bool
operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
{ return !__a; }
template<typename _Tp>
inline bool
operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
{ return !__a; }
template<typename _Tp1, typename _Tp2>
inline bool
operator!=(const shared_ptr<_Tp1>& __a,
const shared_ptr<_Tp2>& __b) noexcept
{ return __a.get() != __b.get(); }
template<typename _Tp>
inline bool
operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
{ return (bool)__a; }
template<typename _Tp>
inline bool
operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
{ return (bool)__a; }
template<typename _Tp1, typename _Tp2>
inline bool
operator<(const shared_ptr<_Tp1>& __a,
const shared_ptr<_Tp2>& __b) noexcept
{
typedef typename std::common_type<_Tp1*, _Tp2*>::type _CT;
return std::less<_CT>()(__a.get(), __b.get());
}
template<typename _Tp>
inline bool
operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
{ return std::less<_Tp*>()(__a.get(), nullptr); }
template<typename _Tp>
inline bool
operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
{ return std::less<_Tp*>()(nullptr, __a.get()); }
template<typename _Tp1, typename _Tp2>
inline bool
operator<=(const shared_ptr<_Tp1>& __a,
const shared_ptr<_Tp2>& __b) noexcept
{ return !(__b < __a); }
template<typename _Tp>
inline bool
operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
{ return !(nullptr < __a); }
template<typename _Tp>
inline bool
operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
{ return !(__a < nullptr); }
template<typename _Tp1, typename _Tp2>
inline bool
operator>(const shared_ptr<_Tp1>& __a,
const shared_ptr<_Tp2>& __b) noexcept
{ return (__b < __a); }
template<typename _Tp>
inline bool
operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
{ return std::less<_Tp*>()(nullptr, __a.get()); }
template<typename _Tp>
inline bool
operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
{ return std::less<_Tp*>()(__a.get(), nullptr); }
template<typename _Tp1, typename _Tp2>
inline bool
operator>=(const shared_ptr<_Tp1>& __a,
const shared_ptr<_Tp2>& __b) noexcept
{ return !(__a < __b); }
template<typename _Tp>
inline bool
operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
{ return !(__a < nullptr); }
template<typename _Tp>
inline bool
operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
{ return !(nullptr < __a); }
template<typename _Tp>
struct less<shared_ptr<_Tp>> : public _Sp_less<shared_ptr<_Tp>>
{ };
template<typename _Tp>
inline void
swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept
{ __a.swap(__b); }
template<typename _Tp, typename _Tp1>
inline shared_ptr<_Tp>
static_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept
{ return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get())); }
template<typename _Tp, typename _Tp1>
inline shared_ptr<_Tp>
const_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept
{ return shared_ptr<_Tp>(__r, const_cast<_Tp*>(__r.get())); }
template<typename _Tp, typename _Tp1>
inline shared_ptr<_Tp>
dynamic_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept
{
if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
return shared_ptr<_Tp>(__r, __p);
return shared_ptr<_Tp>();
}
template<typename _Tp>
class weak_ptr : public __weak_ptr<_Tp>
{
public:
constexpr weak_ptr() noexcept
: __weak_ptr<_Tp>() { }
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
weak_ptr(const weak_ptr<_Tp1>& __r) noexcept
: __weak_ptr<_Tp>(__r) { }
template<typename _Tp1, typename = typename
std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
weak_ptr(const shared_ptr<_Tp1>& __r) noexcept
: __weak_ptr<_Tp>(__r) { }
template<typename _Tp1>
weak_ptr&
operator=(const weak_ptr<_Tp1>& __r) noexcept
{
this->__weak_ptr<_Tp>::operator=(__r);
return *this;
}
template<typename _Tp1>
weak_ptr&
operator=(const shared_ptr<_Tp1>& __r) noexcept
{
this->__weak_ptr<_Tp>::operator=(__r);
return *this;
}
shared_ptr<_Tp>
lock() const noexcept
{ return shared_ptr<_Tp>(*this, std::nothrow); }
};
template<typename _Tp>
inline void
swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept
{ __a.swap(__b); }
template<typename _Tp>
struct owner_less;
template<typename _Tp>
struct owner_less<shared_ptr<_Tp>>
: public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
{ };
template<typename _Tp>
struct owner_less<weak_ptr<_Tp>>
: public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
{ };
template<typename _Tp>
class enable_shared_from_this
{
protected:
constexpr enable_shared_from_this() noexcept { }
enable_shared_from_this(const enable_shared_from_this&) noexcept { }
enable_shared_from_this&
operator=(const enable_shared_from_this&) noexcept
{ return *this; }
~enable_shared_from_this() { }
public:
shared_ptr<_Tp>
shared_from_this()
{ return shared_ptr<_Tp>(this->_M_weak_this); }
shared_ptr<const _Tp>
shared_from_this() const
{ return shared_ptr<const _Tp>(this->_M_weak_this); }
private:
template<typename _Tp1>
void
_M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept
{ _M_weak_this._M_assign(__p, __n); }
template<typename _Tp1>
friend void
__enable_shared_from_this_helper(const __shared_count<>& __pn,
const enable_shared_from_this* __pe,
const _Tp1* __px) noexcept
{
if (__pe != 0)
__pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
}
mutable weak_ptr<_Tp> _M_weak_this;
};
template<typename _Tp, typename _Alloc, typename... _Args>
inline shared_ptr<_Tp>
allocate_shared(const _Alloc& __a, _Args&&... __args)
{
return shared_ptr<_Tp>(_Sp_make_shared_tag(), __a,
std::forward<_Args>(__args)...);
}
template<typename _Tp, typename... _Args>
inline shared_ptr<_Tp>
make_shared(_Args&&... __args)
{
typedef typename std::remove_const<_Tp>::type _Tp_nc;
return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
std::forward<_Args>(__args)...);
}
template<typename _Tp>
struct hash<shared_ptr<_Tp>>
: public __hash_base<size_t, shared_ptr<_Tp>>
{
size_t
operator()(const shared_ptr<_Tp>& __s) const noexcept
{ return std::hash<_Tp*>()(__s.get()); }
};
}
#define _BACKWARD_AUTO_PTR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp1>
struct auto_ptr_ref
{
_Tp1* _M_ptr;
explicit
auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
} __attribute__ ((__deprecated__));
template<typename _Tp>
class auto_ptr
{
private:
_Tp* _M_ptr;
public:
typedef _Tp element_type;
explicit
auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
auto_ptr(auto_ptr& __a) throw() ;
template<typename _Tp1>
auto_ptr(auto_ptr<_Tp1>& __a) throw() ;
auto_ptr&
operator=(auto_ptr& __a) throw()
;
template<typename _Tp1>
auto_ptr&
operator=(auto_ptr<_Tp1>& __a) throw()
;
~auto_ptr() ;
element_type&
operator*() const throw()
;
element_type*
operator->() const throw()
;
element_type*
get() const throw() ;
element_type*
release() throw()
;
void
reset(element_type* __p = 0) throw()
;
auto_ptr(auto_ptr_ref<element_type> __ref) throw() ;
auto_ptr&
operator=(auto_ptr_ref<element_type> __ref) throw()
;
template<typename _Tp1>
operator auto_ptr_ref<_Tp1>() throw()
;
template<typename _Tp1>
operator auto_ptr<_Tp1>() throw()
;
} __attribute__ ((__deprecated__));
template<>
class auto_ptr<void>
{
public:
typedef void element_type;
} __attribute__ ((__deprecated__));
template<typename _Tp, _Lock_policy _Lp>
template<typename _Tp1>
inline
__shared_ptr<_Tp, _Lp>::__shared_ptr(std::auto_ptr<_Tp1>&& __r)
: _M_ptr(__r.get()), _M_refcount()
{
static_assert( sizeof(_Tp1) > 0, "incomplete type" );
_Tp1* __tmp = __r.get();
_M_refcount = __shared_count<_Lp>(std::move(__r));
__enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
}
template<typename _Tp>
template<typename _Tp1>
inline
shared_ptr<_Tp>::shared_ptr(std::auto_ptr<_Tp1>&& __r)
: __shared_ptr<_Tp>(std::move(__r)) { }
template<typename _Tp, typename _Dp>
template<typename _Up, typename>
inline
unique_ptr<_Tp, _Dp>::unique_ptr(auto_ptr<_Up>&& __u) noexcept
: _M_t(__u.release(), deleter_type()) { }
}
namespace boost {
namespace asio {
namespace detail {
using std::addressof;
}
}
}
#define BOOST_ASIO_HANDLER_ALLOC_HOOK_HPP
namespace boost {
namespace asio {
inline void* asio_handler_allocate(
std::size_t size, ...);
inline void asio_handler_deallocate(
void* pointer, std::size_t size, ...);
}
}
#define BOOST_ASIO_IMPL_HANDLER_ALLOC_HOOK_IPP
#define BOOST_ASIO_DETAIL_CALL_STACK_HPP
#define BOOST_ASIO_DETAIL_TSS_PTR_HPP
#define BOOST_ASIO_DETAIL_KEYWORD_TSS_PTR_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename T>
class keyword_tss_ptr
: private noncopyable
{
public:
keyword_tss_ptr()
;
~keyword_tss_ptr()
;
operator T*() const
;
void operator=(T* value)
;
private:
static __thread T* value_;
};
template <typename T>
__thread T* keyword_tss_ptr<T>::value_;
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename T>
class tss_ptr
: public keyword_tss_ptr<T>
{
public:
void operator=(T* value)
;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Key, typename Value = unsigned char>
class call_stack
{
public:
class context
: private noncopyable
{
public:
explicit context(Key* k)
;
context(Key* k, Value& v)
;
~context()
;
Value* next_by_key() const
;
private:
friend class call_stack<Key, Value>;
Key* key_;
Value* value_;
context* next_;
};
friend class context;
static Value* contains(Key* k)
;
static Value* top()
;
private:
static tss_ptr<context> top_;
};
template <typename Key, typename Value>
tss_ptr<typename call_stack<Key, Value>::context>
call_stack<Key, Value>::top_;
}
}
}
#define BOOST_ASIO_DETAIL_TASK_IO_SERVICE_THREAD_INFO_HPP
#define BOOST_ASIO_DETAIL_EVENT_HPP
#define BOOST_ASIO_DETAIL_POSIX_EVENT_HPP
#define BOOST_ASIO_DETAIL_ASSERT_HPP
#undef BOOST_ASSERT
#define _ASSERT_H 1
#define __ASSERT_VOID_CAST static_cast<void>
#define assert(expr) (__ASSERT_VOID_CAST (0))
#define assert_perror(errnum) (__ASSERT_VOID_CAST (0))
#define BOOST_ASSERT(expr) assert(expr)
#undef BOOST_ASSERT_MSG
#define BOOST_ASSERT_MSG(expr,msg) ((void)0)
#undef BOOST_VERIFY
#define BOOST_VERIFY(expr) ((void)(expr))
#define BOOST_ASIO_ASSERT(expr) BOOST_ASSERT(expr)
namespace boost {
namespace asio {
namespace detail {
class posix_event
: private noncopyable
{
public:
inline posix_event();
~posix_event()
;
template <typename Lock>
void signal(Lock& lock)
;
template <typename Lock>
void signal_and_unlock(Lock& lock)
;
template <typename Lock>
void clear(Lock& lock)
;
template <typename Lock>
void wait(Lock& lock)
;
private:
::pthread_cond_t cond_;
bool signalled_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_POSIX_EVENT_IPP
#define BOOST_ASIO_DETAIL_THROW_ERROR_HPP
#define BOOST_ERROR_CODE_HPP
#define BOOST_SYSTEM_CONFIG_HPP
#define BOOST_SYSTEM_API_CONFIG_HPP
#define BOOST_POSIX_API
#define BOOST_SYSTEM_STATIC_LINK
#define BOOST_SYSTEM_DECL
#define BOOST_LIB_NAME boost_system
#undef BOOST_LIB_NAME
#define BOOST_CSTDINT_HPP
namespace boost
{
using ::int8_t;
using ::int_least8_t;
using ::int_fast8_t;
using ::uint8_t;
using ::uint_least8_t;
using ::uint_fast8_t;
using ::int16_t;
using ::int_least16_t;
using ::int_fast16_t;
using ::uint16_t;
using ::uint_least16_t;
using ::uint_fast16_t;
using ::int32_t;
using ::int_least32_t;
using ::int_fast32_t;
using ::uint32_t;
using ::uint_least32_t;
using ::uint_fast32_t;
using ::int64_t;
using ::int_least64_t;
using ::int_fast64_t;
using ::uint64_t;
using ::uint_least64_t;
using ::uint_fast64_t;
using ::intmax_t;
using ::uintmax_t;
}
namespace boost {
using ::intptr_t;
using ::uintptr_t;
}
#define BOOST_HAS_INTPTR_T
#undef BOOST_ASSERT
#undef _ASSERT_H
#undef assert
#undef __ASSERT_VOID_CAST
#undef assert_perror
#define _ASSERT_H 1
#define __ASSERT_VOID_CAST static_cast<void>
#define assert(expr) (__ASSERT_VOID_CAST (0))
#define assert_perror(errnum) (__ASSERT_VOID_CAST (0))
#define BOOST_ASSERT(expr) assert(expr)
#undef BOOST_ASSERT_MSG
#define BOOST_ASSERT_MSG(expr,msg) ((void)0)
#undef BOOST_VERIFY
#define BOOST_VERIFY(expr) ((void)(expr))
#define BOOST_OPERATORS_HPP
#define BOOST_ITERATOR_HPP
#define _GLIBCXX_ITERATOR 1
#define _GLIBCXX_OSTREAM 1
#define _GLIBCXX_IOS 1
#define _IOS_BASE_H 1
#define _LOCALE_CLASSES_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
class locale
{
public:
typedef int category;
class facet;
class id;
class _Impl;
friend class facet;
friend class _Impl;
template<typename _Facet>
friend bool
has_facet(const locale&) throw();
template<typename _Facet>
friend const _Facet&
use_facet(const locale&);
template<typename _Cache>
friend struct __use_cache;
static const category none = 0;
static const category ctype = 1L << 0;
static const category numeric = 1L << 1;
static const category collate = 1L << 2;
static const category time = 1L << 3;
static const category monetary = 1L << 4;
static const category messages = 1L << 5;
static const category all = (ctype | numeric | collate |
time | monetary | messages);
locale() throw();
locale(const locale& __other) throw();
explicit
locale(const char* __s);
locale(const locale& __base, const char* __s, category __cat);
locale(const locale& __base, const locale& __add, category __cat);
template<typename _Facet>
locale(const locale& __other, _Facet* __f);
~locale() throw();
const locale&
operator=(const locale& __other) throw();
template<typename _Facet>
locale
combine(const locale& __other) const;
string
name() const;
bool
operator==(const locale& __other) const throw();
bool
operator!=(const locale& __other) const throw()
;
template<typename _Char, typename _Traits, typename _Alloc>
bool
operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
const basic_string<_Char, _Traits, _Alloc>& __s2) const;
static locale
global(const locale& __loc);
static const locale&
classic();
private:
_Impl* _M_impl;
static _Impl* _S_classic;
static _Impl* _S_global;
static const char* const* const _S_categories;
enum { _S_categories_size = 6 + 6 };
static __gthread_once_t _S_once;
explicit
locale(_Impl*) throw();
static void
_S_initialize();
static void
_S_initialize_once() throw();
static category
_S_normalize_category(category);
void
_M_coalesce(const locale& __base, const locale& __add, category __cat);
};
class locale::facet
{
private:
friend class locale;
friend class locale::_Impl;
mutable _Atomic_word _M_refcount;
static __c_locale _S_c_locale;
static const char _S_c_name[2];
static __gthread_once_t _S_once;
static void
_S_initialize_once();
protected:
explicit
facet(size_t __refs = 0) throw()
;
virtual
~facet();
static void
_S_create_c_locale(__c_locale& __cloc, const char* __s,
__c_locale __old = 0);
static __c_locale
_S_clone_c_locale(__c_locale& __cloc) throw();
static void
_S_destroy_c_locale(__c_locale& __cloc);
static __c_locale
_S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);
static __c_locale
_S_get_c_locale();
__attribute__ ((__const__)) static const char*
_S_get_c_name() throw();
private:
void
_M_add_reference() const throw()
;
void
_M_remove_reference() const throw()
;
facet(const facet&);
facet&
operator=(const facet&);
};
class locale::id
{
private:
friend class locale;
friend class locale::_Impl;
template<typename _Facet>
friend const _Facet&
use_facet(const locale&);
template<typename _Facet>
friend bool
has_facet(const locale&) throw();
mutable size_t _M_index;
static _Atomic_word _S_refcount;
void
operator=(const id&);
id(const id&);
public:
id() ;
size_t
_M_id() const throw();
};
class locale::_Impl
{
public:
friend class locale;
friend class locale::facet;
template<typename _Facet>
friend bool
has_facet(const locale&) throw();
template<typename _Facet>
friend const _Facet&
use_facet(const locale&);
template<typename _Cache>
friend struct __use_cache;
private:
_Atomic_word _M_refcount;
const facet** _M_facets;
size_t _M_facets_size;
const facet** _M_caches;
char** _M_names;
static const locale::id* const _S_id_ctype[];
static const locale::id* const _S_id_numeric[];
static const locale::id* const _S_id_collate[];
static const locale::id* const _S_id_time[];
static const locale::id* const _S_id_monetary[];
static const locale::id* const _S_id_messages[];
static const locale::id* const* const _S_facet_categories[];
void
_M_add_reference() throw()
;
void
_M_remove_reference() throw()
;
_Impl(const _Impl&, size_t);
_Impl(const char*, size_t);
_Impl(size_t) throw();
~_Impl() throw();
_Impl(const _Impl&);
void
operator=(const _Impl&);
bool
_M_check_same_name()
;
void
_M_replace_categories(const _Impl*, category);
void
_M_replace_category(const _Impl*, const locale::id* const*);
void
_M_replace_facet(const _Impl*, const locale::id*);
void
_M_install_facet(const locale::id*, const facet*);
template<typename _Facet>
void
_M_init_facet(_Facet* __facet)
;
void
_M_install_cache(const facet*, size_t);
};
template<typename _CharT>
class collate : public locale::facet
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
protected:
__c_locale _M_c_locale_collate;
public:
static locale::id id;
explicit
collate(size_t __refs = 0)
;
explicit
collate(__c_locale __cloc, size_t __refs = 0)
;
int
compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const
;
string_type
transform(const _CharT* __lo, const _CharT* __hi) const
;
long
hash(const _CharT* __lo, const _CharT* __hi) const
;
int
_M_compare(const _CharT*, const _CharT*) const throw();
size_t
_M_transform(_CharT*, const _CharT*, size_t) const throw();
protected:
virtual
~collate()
;
virtual int
do_compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const;
virtual string_type
do_transform(const _CharT* __lo, const _CharT* __hi) const;
virtual long
do_hash(const _CharT* __lo, const _CharT* __hi) const;
};
template<typename _CharT>
locale::id collate<_CharT>::id;
template<>
int
collate<char>::_M_compare(const char*, const char*) const throw();
template<>
size_t
collate<char>::_M_transform(char*, const char*, size_t) const throw();
template<>
int
collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();
template<>
size_t
collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();
template<typename _CharT>
class collate_byname : public collate<_CharT>
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
explicit
collate_byname(const char* __s, size_t __refs = 0)
;
protected:
virtual
~collate_byname() ;
};
}
#define _LOCALE_CLASSES_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Facet>
bool
has_facet(const locale& __loc) throw()
;
template<typename _Facet>
const _Facet&
use_facet(const locale& __loc)
;
extern template class collate<char>;
extern template class collate_byname<char>;
extern template
const collate<char>&
use_facet<collate<char> >(const locale&);
extern template
bool
has_facet<collate<char> >(const locale&);
extern template class collate<wchar_t>;
extern template class collate_byname<wchar_t>;
extern template
const collate<wchar_t>&
use_facet<collate<wchar_t> >(const locale&);
extern template
bool
has_facet<collate<wchar_t> >(const locale&);
}
namespace std __attribute__ ((__visibility__ ("default")))
{
enum _Ios_Fmtflags
{
_S_boolalpha = 1L << 0,
_S_dec = 1L << 1,
_S_fixed = 1L << 2,
_S_hex = 1L << 3,
_S_internal = 1L << 4,
_S_left = 1L << 5,
_S_oct = 1L << 6,
_S_right = 1L << 7,
_S_scientific = 1L << 8,
_S_showbase = 1L << 9,
_S_showpoint = 1L << 10,
_S_showpos = 1L << 11,
_S_skipws = 1L << 12,
_S_unitbuf = 1L << 13,
_S_uppercase = 1L << 14,
_S_adjustfield = _S_left | _S_right | _S_internal,
_S_basefield = _S_dec | _S_oct | _S_hex,
_S_floatfield = _S_scientific | _S_fixed,
_S_ios_fmtflags_end = 1L << 16
};
inline constexpr _Ios_Fmtflags
operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
inline constexpr _Ios_Fmtflags
operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
inline constexpr _Ios_Fmtflags
operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
{ return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
inline constexpr _Ios_Fmtflags
operator~(_Ios_Fmtflags __a)
{ return _Ios_Fmtflags(~static_cast<int>(__a)); }
inline const _Ios_Fmtflags&
operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
{ return __a = __a | __b; }
inline const _Ios_Fmtflags&
operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
{ return __a = __a & __b; }
inline const _Ios_Fmtflags&
operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
{ return __a = __a ^ __b; }
enum _Ios_Openmode
{
_S_app = 1L << 0,
_S_ate = 1L << 1,
_S_bin = 1L << 2,
_S_in = 1L << 3,
_S_out = 1L << 4,
_S_trunc = 1L << 5,
_S_ios_openmode_end = 1L << 16
};
inline constexpr _Ios_Openmode
operator&(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
inline constexpr _Ios_Openmode
operator|(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
inline constexpr _Ios_Openmode
operator^(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
inline constexpr _Ios_Openmode
operator~(_Ios_Openmode __a)
{ return _Ios_Openmode(~static_cast<int>(__a)); }
inline const _Ios_Openmode&
operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
{ return __a = __a | __b; }
inline const _Ios_Openmode&
operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
{ return __a = __a & __b; }
inline const _Ios_Openmode&
operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
{ return __a = __a ^ __b; }
enum _Ios_Iostate
{
_S_goodbit = 0,
_S_badbit = 1L << 0,
_S_eofbit = 1L << 1,
_S_failbit = 1L << 2,
_S_ios_iostate_end = 1L << 16
};
inline constexpr _Ios_Iostate
operator&(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
inline constexpr _Ios_Iostate
operator|(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
inline constexpr _Ios_Iostate
operator^(_Ios_Iostate __a, _Ios_Iostate __b)
{ return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
inline constexpr _Ios_Iostate
operator~(_Ios_Iostate __a)
{ return _Ios_Iostate(~static_cast<int>(__a)); }
inline const _Ios_Iostate&
operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
{ return __a = __a | __b; }
inline const _Ios_Iostate&
operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
{ return __a = __a & __b; }
inline const _Ios_Iostate&
operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
{ return __a = __a ^ __b; }
enum _Ios_Seekdir
{
_S_beg = 0,
_S_cur = 1,
_S_end = 2,
_S_ios_seekdir_end = 1L << 16
};
class ios_base
{
public:
class failure : public exception
{
public:
explicit
failure(const string& __str) throw();
virtual
~failure() throw();
virtual const char*
what() const throw();
private:
string _M_msg;
};
typedef _Ios_Fmtflags fmtflags;
static const fmtflags boolalpha = _S_boolalpha;
static const fmtflags dec = _S_dec;
static const fmtflags fixed = _S_fixed;
static const fmtflags hex = _S_hex;
static const fmtflags internal = _S_internal;
static const fmtflags left = _S_left;
static const fmtflags oct = _S_oct;
static const fmtflags right = _S_right;
static const fmtflags scientific = _S_scientific;
static const fmtflags showbase = _S_showbase;
static const fmtflags showpoint = _S_showpoint;
static const fmtflags showpos = _S_showpos;
static const fmtflags skipws = _S_skipws;
static const fmtflags unitbuf = _S_unitbuf;
static const fmtflags uppercase = _S_uppercase;
static const fmtflags adjustfield = _S_adjustfield;
static const fmtflags basefield = _S_basefield;
static const fmtflags floatfield = _S_floatfield;
typedef _Ios_Iostate iostate;
static const iostate badbit = _S_badbit;
static const iostate eofbit = _S_eofbit;
static const iostate failbit = _S_failbit;
static const iostate goodbit = _S_goodbit;
typedef _Ios_Openmode openmode;
static const openmode app = _S_app;
static const openmode ate = _S_ate;
static const openmode binary = _S_bin;
static const openmode in = _S_in;
static const openmode out = _S_out;
static const openmode trunc = _S_trunc;
typedef _Ios_Seekdir seekdir;
static const seekdir beg = _S_beg;
static const seekdir cur = _S_cur;
static const seekdir end = _S_end;
typedef int io_state;
typedef int open_mode;
typedef int seek_dir;
typedef std::streampos streampos;
typedef std::streamoff streamoff;
enum event
{
erase_event,
imbue_event,
copyfmt_event
};
typedef void (*event_callback) (event __e, ios_base& __b, int __i);
void
register_callback(event_callback __fn, int __index);
protected:
streamsize _M_precision;
streamsize _M_width;
fmtflags _M_flags;
iostate _M_exception;
iostate _M_streambuf_state;
struct _Callback_list
{
_Callback_list* _M_next;
ios_base::event_callback _M_fn;
int _M_index;
_Atomic_word _M_refcount;
_Callback_list(ios_base::event_callback __fn, int __index,
_Callback_list* __cb) ;
void
_M_add_reference() ;
int
_M_remove_reference()
;
};
_Callback_list* _M_callbacks;
void
_M_call_callbacks(event __ev) throw();
void
_M_dispose_callbacks(void) throw();
struct _Words
{
void* _M_pword;
long _M_iword;
_Words() ;
};
_Words _M_word_zero;
enum { _S_local_word_size = 8 };
_Words _M_local_word[_S_local_word_size];
int _M_word_size;
_Words* _M_word;
_Words&
_M_grow_words(int __index, bool __iword);
locale _M_ios_locale;
void
_M_init() throw();
public:
class Init
{
friend class ios_base;
public:
Init();
~Init();
private:
static _Atomic_word _S_refcount;
static bool _S_synced_with_stdio;
};
fmtflags
flags() const
;
fmtflags
flags(fmtflags __fmtfl)
;
fmtflags
setf(fmtflags __fmtfl)
;
fmtflags
setf(fmtflags __fmtfl, fmtflags __mask)
;
void
unsetf(fmtflags __mask)
;
streamsize
precision() const
;
streamsize
precision(streamsize __prec)
;
streamsize
width() const
;
streamsize
width(streamsize __wide)
;
static bool
sync_with_stdio(bool __sync = true);
locale
imbue(const locale& __loc) throw();
locale
getloc() const
;
const locale&
_M_getloc() const
;
static int
xalloc() throw();
long&
iword(int __ix)
;
void*&
pword(int __ix)
;
virtual ~ios_base();
protected:
ios_base() throw ();
public:
ios_base(const ios_base&) = delete;
ios_base&
operator=(const ios_base&) = delete;
protected:
void
_M_move(ios_base&) noexcept;
void
_M_swap(ios_base& __rhs) noexcept;
};
ios_base&
boolalpha(ios_base& __base)
;
ios_base&
noboolalpha(ios_base& __base)
;
ios_base&
showbase(ios_base& __base)
;
ios_base&
noshowbase(ios_base& __base)
;
ios_base&
showpoint(ios_base& __base)
;
ios_base&
noshowpoint(ios_base& __base)
;
ios_base&
showpos(ios_base& __base)
;
ios_base&
noshowpos(ios_base& __base)
;
ios_base&
skipws(ios_base& __base)
;
ios_base&
noskipws(ios_base& __base)
;
ios_base&
uppercase(ios_base& __base)
;
ios_base&
nouppercase(ios_base& __base)
;
ios_base&
unitbuf(ios_base& __base)
;
ios_base&
nounitbuf(ios_base& __base)
;
ios_base&
internal(ios_base& __base)
;
ios_base&
left(ios_base& __base)
;
ios_base&
right(ios_base& __base)
;
ios_base&
dec(ios_base& __base)
;
ios_base&
hex(ios_base& __base)
;
ios_base&
oct(ios_base& __base)
;
ios_base&
fixed(ios_base& __base)
;
ios_base&
scientific(ios_base& __base)
;
}
#define _GLIBXX_STREAMBUF 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
streamsize
__copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
basic_streambuf<_CharT, _Traits>*, bool&);
template<typename _CharT, typename _Traits>
class basic_streambuf
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef basic_streambuf<char_type, traits_type> __streambuf_type;
friend class basic_ios<char_type, traits_type>;
friend class basic_istream<char_type, traits_type>;
friend class basic_ostream<char_type, traits_type>;
friend class istreambuf_iterator<char_type, traits_type>;
friend class ostreambuf_iterator<char_type, traits_type>;
friend streamsize
__copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&);
template<bool _IsMove, typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
_CharT2*>::__type
__copy_move_a2(istreambuf_iterator<_CharT2>,
istreambuf_iterator<_CharT2>, _CharT2*);
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
istreambuf_iterator<_CharT2> >::__type
find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
const _CharT2&);
template<typename _CharT2, typename _Traits2>
friend basic_istream<_CharT2, _Traits2>&
operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
template<typename _CharT2, typename _Traits2, typename _Alloc>
friend basic_istream<_CharT2, _Traits2>&
operator>>(basic_istream<_CharT2, _Traits2>&,
basic_string<_CharT2, _Traits2, _Alloc>&);
template<typename _CharT2, typename _Traits2, typename _Alloc>
friend basic_istream<_CharT2, _Traits2>&
getline(basic_istream<_CharT2, _Traits2>&,
basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);
protected:
char_type* _M_in_beg;
char_type* _M_in_cur;
char_type* _M_in_end;
char_type* _M_out_beg;
char_type* _M_out_cur;
char_type* _M_out_end;
locale _M_buf_locale;
public:
virtual
~basic_streambuf()
;
locale
pubimbue(const locale& __loc)
;
locale
getloc() const
;
basic_streambuf*
pubsetbuf(char_type* __s, streamsize __n)
;
pos_type
pubseekoff(off_type __off, ios_base::seekdir __way,
ios_base::openmode __mode = ios_base::in | ios_base::out)
;
pos_type
pubseekpos(pos_type __sp,
ios_base::openmode __mode = ios_base::in | ios_base::out)
;
int
pubsync() ;
streamsize
in_avail()
;
int_type
snextc()
;
int_type
sbumpc()
;
int_type
sgetc()
;
streamsize
sgetn(char_type* __s, streamsize __n)
;
int_type
sputbackc(char_type __c)
;
int_type
sungetc()
;
int_type
sputc(char_type __c)
;
streamsize
sputn(const char_type* __s, streamsize __n)
;
protected:
basic_streambuf()
;
char_type*
eback() const ;
char_type*
gptr() const ;
char_type*
egptr() const ;
void
gbump(int __n) ;
void
setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
;
char_type*
pbase() const ;
char_type*
pptr() const ;
char_type*
epptr() const ;
void
pbump(int __n) ;
void
setp(char_type* __pbeg, char_type* __pend)
;
virtual void
imbue(const locale& __loc)
;
virtual basic_streambuf<char_type,_Traits>*
setbuf(char_type*, streamsize)
;
virtual pos_type
seekoff(off_type, ios_base::seekdir,
ios_base::openmode = ios_base::in | ios_base::out)
;
virtual pos_type
seekpos(pos_type,
ios_base::openmode = ios_base::in | ios_base::out)
;
virtual int
sync() ;
virtual streamsize
showmanyc() ;
virtual streamsize
xsgetn(char_type* __s, streamsize __n);
virtual int_type
underflow()
;
virtual int_type
uflow()
;
virtual int_type
pbackfail(int_type __c = traits_type::eof())
;
virtual streamsize
xsputn(const char_type* __s, streamsize __n);
virtual int_type
overflow(int_type __c = traits_type::eof())
;
public:
void
stossc()
;
void
__safe_gbump(streamsize __n) ;
void
__safe_pbump(streamsize __n) ;
protected:
basic_streambuf(const basic_streambuf&);
basic_streambuf&
operator=(const basic_streambuf&);
void
swap(basic_streambuf& __sb)
;
};
template<typename _CharT, typename _Traits>
std::basic_streambuf<_CharT, _Traits>::
basic_streambuf(const basic_streambuf&) = default;
template<typename _CharT, typename _Traits>
std::basic_streambuf<_CharT, _Traits>&
std::basic_streambuf<_CharT, _Traits>::
operator=(const basic_streambuf&) = default;
template<>
streamsize
__copy_streambufs_eof(basic_streambuf<char>* __sbin,
basic_streambuf<char>* __sbout, bool& __ineof);
template<>
streamsize
__copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
basic_streambuf<wchar_t>* __sbout, bool& __ineof);
}
#define _STREAMBUF_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
streamsize
__copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
basic_streambuf<_CharT, _Traits>* __sbout,
bool& __ineof)
;
template<typename _CharT, typename _Traits>
streamsize
__copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
basic_streambuf<_CharT, _Traits>* __sbout)
;
extern template class basic_streambuf<char>;
extern template
streamsize
__copy_streambufs(basic_streambuf<char>*,
basic_streambuf<char>*);
extern template
streamsize
__copy_streambufs_eof(basic_streambuf<char>*,
basic_streambuf<char>*, bool&);
extern template class basic_streambuf<wchar_t>;
extern template
streamsize
__copy_streambufs(basic_streambuf<wchar_t>*,
basic_streambuf<wchar_t>*);
extern template
streamsize
__copy_streambufs_eof(basic_streambuf<wchar_t>*,
basic_streambuf<wchar_t>*, bool&);
}
#define _BASIC_IOS_H 1
#define _LOCALE_FACETS_H 1
#define _WCTYPE_H 1
#define __need_wint_t
#undef __need_mbstate_t
#undef __need_wint_t
#undef __need_iswxxx
#define __iswxxx_defined 1
typedef unsigned long int wctype_t;
#define _ISwbit(bit) ((bit) < 8 ? (int) ((1UL << (bit)) << 24) : ((bit) < 16 ? (int) ((1UL << (bit)) << 8) : ((bit) < 24 ? (int) ((1UL << (bit)) >> 8) : (int) ((1UL << (bit)) >> 24))))
enum
{
__ISwupper = 0,
__ISwlower = 1,
__ISwalpha = 2,
__ISwdigit = 3,
__ISwxdigit = 4,
__ISwspace = 5,
__ISwprint = 6,
__ISwgraph = 7,
__ISwblank = 8,
__ISwcntrl = 9,
__ISwpunct = 10,
__ISwalnum = 11,
_ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))),
_ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))),
_ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))),
_ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))),
_ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))),
_ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))),
_ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))),
_ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))),
_ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))),
_ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))),
_ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))),
_ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24))))
};
extern "C" {
extern int iswalnum (wint_t __wc) throw ();
extern int iswalpha (wint_t __wc) throw ();
extern int iswcntrl (wint_t __wc) throw ();
extern int iswdigit (wint_t __wc) throw ();
extern int iswgraph (wint_t __wc) throw ();
extern int iswlower (wint_t __wc) throw ();
extern int iswprint (wint_t __wc) throw ();
extern int iswpunct (wint_t __wc) throw ();
extern int iswspace (wint_t __wc) throw ();
extern int iswupper (wint_t __wc) throw ();
extern int iswxdigit (wint_t __wc) throw ();
extern int iswblank (wint_t __wc) throw ();
extern wctype_t wctype (const char *__property) throw ();
extern int iswctype (wint_t __wc, wctype_t __desc) throw ();
typedef const __int32_t *wctrans_t;
extern wint_t towlower (wint_t __wc) throw ();
extern wint_t towupper (wint_t __wc) throw ();
}
extern "C" {
extern wctrans_t wctrans (const char *__property) throw ();
extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();
extern int iswalnum_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswalpha_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswcntrl_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswdigit_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswgraph_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswlower_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswprint_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswpunct_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswspace_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswupper_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswxdigit_l (wint_t __wc, __locale_t __locale) throw ();
extern int iswblank_l (wint_t __wc, __locale_t __locale) throw ();
extern wctype_t wctype_l (const char *__property, __locale_t __locale)
throw ();
extern int iswctype_l (wint_t __wc, wctype_t __desc, __locale_t __locale)
throw ();
extern wint_t towlower_l (wint_t __wc, __locale_t __locale) throw ();
extern wint_t towupper_l (wint_t __wc, __locale_t __locale) throw ();
extern wctrans_t wctrans_l (const char *__property, __locale_t __locale)
throw ();
extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
__locale_t __locale) throw ();
}
#define _GLIBCXX_CWCTYPE 1
#undef iswalnum
#undef iswalpha
#undef iswblank
#undef iswcntrl
#undef iswctype
#undef iswdigit
#undef iswgraph
#undef iswlower
#undef iswprint
#undef iswpunct
#undef iswspace
#undef iswupper
#undef iswxdigit
#undef towctrans
#undef towlower
#undef towupper
#undef wctrans
#undef wctype
namespace std
{
using ::wctrans_t;
using ::wctype_t;
using ::wint_t;
using ::iswalnum;
using ::iswalpha;
using ::iswblank;
using ::iswcntrl;
using ::iswctype;
using ::iswdigit;
using ::iswgraph;
using ::iswlower;
using ::iswprint;
using ::iswpunct;
using ::iswspace;
using ::iswupper;
using ::iswxdigit;
using ::towctrans;
using ::towlower;
using ::towupper;
using ::wctrans;
using ::wctype;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
struct ctype_base
{
typedef const int* __to_type;
typedef unsigned short mask;
static const mask upper = _ISupper;
static const mask lower = _ISlower;
static const mask alpha = _ISalpha;
static const mask digit = _ISdigit;
static const mask xdigit = _ISxdigit;
static const mask space = _ISspace;
static const mask print = _ISprint;
static const mask graph = _ISalpha | _ISdigit | _ISpunct;
static const mask cntrl = _IScntrl;
static const mask punct = _ISpunct;
static const mask alnum = _ISalpha | _ISdigit;
};
}
#define _STREAMBUF_ITERATOR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
class istreambuf_iterator
: public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
_CharT*,
_CharT>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef typename _Traits::int_type int_type;
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
typedef basic_istream<_CharT, _Traits> istream_type;
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
ostreambuf_iterator<_CharT2> >::__type
copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
ostreambuf_iterator<_CharT2>);
template<bool _IsMove, typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
_CharT2*>::__type
__copy_move_a2(istreambuf_iterator<_CharT2>,
istreambuf_iterator<_CharT2>, _CharT2*);
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
istreambuf_iterator<_CharT2> >::__type
find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
const _CharT2&);
private:
mutable streambuf_type* _M_sbuf;
mutable int_type _M_c;
public:
constexpr istreambuf_iterator() noexcept
: _M_sbuf(0), _M_c(traits_type::eof()) { }
istreambuf_iterator(const istreambuf_iterator&) noexcept = default;
~istreambuf_iterator() = default;
istreambuf_iterator(istream_type& __s) noexcept
: _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
istreambuf_iterator(streambuf_type* __s) noexcept
: _M_sbuf(__s), _M_c(traits_type::eof()) { }
char_type
operator*() const
{
return traits_type::to_char_type(_M_get());
}
istreambuf_iterator&
operator++()
{
;
if (_M_sbuf)
{
_M_sbuf->sbumpc();
_M_c = traits_type::eof();
}
return *this;
}
istreambuf_iterator
operator++(int)
{
;
istreambuf_iterator __old = *this;
if (_M_sbuf)
{
__old._M_c = _M_sbuf->sbumpc();
_M_c = traits_type::eof();
}
return __old;
}
bool
equal(const istreambuf_iterator& __b) const
{ return _M_at_eof() == __b._M_at_eof(); }
private:
int_type
_M_get() const
{
const int_type __eof = traits_type::eof();
int_type __ret = __eof;
if (_M_sbuf)
{
if (!traits_type::eq_int_type(_M_c, __eof))
__ret = _M_c;
else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()),
__eof))
_M_c = __ret;
else
_M_sbuf = 0;
}
return __ret;
}
bool
_M_at_eof() const
{
const int_type __eof = traits_type::eof();
return traits_type::eq_int_type(_M_get(), __eof);
}
};
template<typename _CharT, typename _Traits>
bool
operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
const istreambuf_iterator<_CharT, _Traits>& __b)
;
template<typename _CharT, typename _Traits>
bool
operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
const istreambuf_iterator<_CharT, _Traits>& __b)
;
template<typename _CharT, typename _Traits>
class ostreambuf_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
typedef basic_ostream<_CharT, _Traits> ostream_type;
template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
ostreambuf_iterator<_CharT2> >::__type
copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
ostreambuf_iterator<_CharT2>);
private:
streambuf_type* _M_sbuf;
bool _M_failed;
public:
ostreambuf_iterator(ostream_type& __s) noexcept
: _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
ostreambuf_iterator(streambuf_type* __s) noexcept
: _M_sbuf(__s), _M_failed(!_M_sbuf) { }
ostreambuf_iterator&
operator=(_CharT __c)
{
if (!_M_failed &&
_Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
_M_failed = true;
return *this;
}
ostreambuf_iterator&
operator*()
{ return *this; }
ostreambuf_iterator&
operator++(int)
{ return *this; }
ostreambuf_iterator&
operator++()
{ return *this; }
bool
failed() const noexcept
{ return _M_failed; }
ostreambuf_iterator&
_M_put(const _CharT* __ws, streamsize __len)
{
if (__builtin_expect(!_M_failed, true)
&& __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
false))
_M_failed = true;
return *this;
}
};
template<typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
copy(istreambuf_iterator<_CharT> __first,
istreambuf_iterator<_CharT> __last,
ostreambuf_iterator<_CharT> __result)
;
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
__copy_move_a2(_CharT* __first, _CharT* __last,
ostreambuf_iterator<_CharT> __result)
;
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
__copy_move_a2(const _CharT* __first, const _CharT* __last,
ostreambuf_iterator<_CharT> __result)
;
template<bool _IsMove, typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
_CharT*>::__type
__copy_move_a2(istreambuf_iterator<_CharT> __first,
istreambuf_iterator<_CharT> __last, _CharT* __result)
;
template<typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
istreambuf_iterator<_CharT> >::__type
find(istreambuf_iterator<_CharT> __first,
istreambuf_iterator<_CharT> __last, const _CharT& __val)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
#define _GLIBCXX_NUM_FACETS 28
template<typename _Tp>
void
__convert_to_v(const char*, _Tp&, ios_base::iostate&,
const __c_locale&) throw();
template<>
void
__convert_to_v(const char*, float&, ios_base::iostate&,
const __c_locale&) throw();
template<>
void
__convert_to_v(const char*, double&, ios_base::iostate&,
const __c_locale&) throw();
template<>
void
__convert_to_v(const char*, long double&, ios_base::iostate&,
const __c_locale&) throw();
template<typename _CharT, typename _Traits>
struct __pad
{
static void
_S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
};
template<typename _CharT>
_CharT*
__add_grouping(_CharT* __s, _CharT __sep,
const char* __gbeg, size_t __gsize,
const _CharT* __first, const _CharT* __last);
template<typename _CharT>
ostreambuf_iterator<_CharT>
__write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
;
template<typename _CharT, typename _OutIter>
_OutIter
__write(_OutIter __s, const _CharT* __ws, int __len)
;
template<typename _CharT>
class __ctype_abstract_base : public locale::facet, public ctype_base
{
public:
typedef _CharT char_type;
bool
is(mask __m, char_type __c) const
;
const char_type*
is(const char_type *__lo, const char_type *__hi, mask *__vec) const
;
const char_type*
scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
;
const char_type*
scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
;
char_type
toupper(char_type __c) const
;
const char_type*
toupper(char_type *__lo, const char_type* __hi) const
;
char_type
tolower(char_type __c) const
;
const char_type*
tolower(char_type* __lo, const char_type* __hi) const
;
char_type
widen(char __c) const
;
const char*
widen(const char* __lo, const char* __hi, char_type* __to) const
;
char
narrow(char_type __c, char __dfault) const
;
const char_type*
narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const
;
protected:
explicit
__ctype_abstract_base(size_t __refs = 0) ;
virtual
~__ctype_abstract_base() ;
virtual bool
do_is(mask __m, char_type __c) const = 0;
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi,
mask* __vec) const = 0;
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo,
const char_type* __hi) const = 0;
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const = 0;
virtual char_type
do_toupper(char_type __c) const = 0;
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const = 0;
virtual char_type
do_tolower(char_type __c) const = 0;
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const = 0;
virtual char_type
do_widen(char __c) const = 0;
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
virtual char
do_narrow(char_type __c, char __dfault) const = 0;
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const = 0;
};
template<typename _CharT>
class ctype : public __ctype_abstract_base<_CharT>
{
public:
typedef _CharT char_type;
typedef typename __ctype_abstract_base<_CharT>::mask mask;
static locale::id id;
explicit
ctype(size_t __refs = 0) ;
protected:
virtual
~ctype();
virtual bool
do_is(mask __m, char_type __c) const;
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const;
virtual char_type
do_toupper(char_type __c) const;
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
virtual char_type
do_tolower(char_type __c) const;
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
virtual char_type
do_widen(char __c) const;
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
virtual char
do_narrow(char_type, char __dfault) const;
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const;
};
template<typename _CharT>
locale::id ctype<_CharT>::id;
template<>
class ctype<char> : public locale::facet, public ctype_base
{
public:
typedef char char_type;
protected:
__c_locale _M_c_locale_ctype;
bool _M_del;
__to_type _M_toupper;
__to_type _M_tolower;
const mask* _M_table;
mutable char _M_widen_ok;
mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
mutable char _M_narrow_ok;
public:
static locale::id id;
static const size_t table_size = 1 + static_cast<unsigned char>(-1);
explicit
ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
explicit
ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
size_t __refs = 0);
inline bool
is(mask __m, char __c) const;
inline const char*
is(const char* __lo, const char* __hi, mask* __vec) const;
inline const char*
scan_is(mask __m, const char* __lo, const char* __hi) const;
inline const char*
scan_not(mask __m, const char* __lo, const char* __hi) const;
char_type
toupper(char_type __c) const
;
const char_type*
toupper(char_type *__lo, const char_type* __hi) const
;
char_type
tolower(char_type __c) const
;
const char_type*
tolower(char_type* __lo, const char_type* __hi) const
;
char_type
widen(char __c) const
;
const char*
widen(const char* __lo, const char* __hi, char_type* __to) const
;
char
narrow(char_type __c, char __dfault) const
;
const char_type*
narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const
;
const mask*
table() const throw()
;
static const mask*
classic_table() throw();
protected:
virtual
~ctype();
virtual char_type
do_toupper(char_type __c) const;
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
virtual char_type
do_tolower(char_type __c) const;
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
virtual char_type
do_widen(char __c) const
;
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __to) const
;
virtual char
do_narrow(char_type __c, char __dfault) const
;
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const
;
private:
void _M_narrow_init() const;
void _M_widen_init() const;
};
template<>
class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
{
public:
typedef wchar_t char_type;
typedef wctype_t __wmask_type;
protected:
__c_locale _M_c_locale_ctype;
bool _M_narrow_ok;
char _M_narrow[128];
wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
mask _M_bit[16];
__wmask_type _M_wmask[16];
public:
static locale::id id;
explicit
ctype(size_t __refs = 0);
explicit
ctype(__c_locale __cloc, size_t __refs = 0);
protected:
__wmask_type
_M_convert_to_wmask(const mask __m) const throw();
virtual
~ctype();
virtual bool
do_is(mask __m, char_type __c) const;
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const;
virtual char_type
do_toupper(char_type __c) const;
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
virtual char_type
do_tolower(char_type __c) const;
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
virtual char_type
do_widen(char __c) const;
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __to) const;
virtual char
do_narrow(char_type __c, char __dfault) const;
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const;
void
_M_initialize_ctype() throw();
};
template<typename _CharT>
class ctype_byname : public ctype<_CharT>
{
public:
typedef typename ctype<_CharT>::mask mask;
explicit
ctype_byname(const char* __s, size_t __refs = 0);
protected:
virtual
~ctype_byname() ;;
};
template<>
class ctype_byname<char> : public ctype<char>
{
public:
explicit
ctype_byname(const char* __s, size_t __refs = 0);
protected:
virtual
~ctype_byname();
};
template<>
class ctype_byname<wchar_t> : public ctype<wchar_t>
{
public:
explicit
ctype_byname(const char* __s, size_t __refs = 0);
protected:
virtual
~ctype_byname();
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
}
namespace std __attribute__ ((__visibility__ ("default")))
{
class __num_base
{
public:
enum
{
_S_ominus,
_S_oplus,
_S_ox,
_S_oX,
_S_odigits,
_S_odigits_end = _S_odigits + 16,
_S_oudigits = _S_odigits_end,
_S_oudigits_end = _S_oudigits + 16,
_S_oe = _S_odigits + 14,
_S_oE = _S_oudigits + 14,
_S_oend = _S_oudigits_end
};
static const char* _S_atoms_out;
static const char* _S_atoms_in;
enum
{
_S_iminus,
_S_iplus,
_S_ix,
_S_iX,
_S_izero,
_S_ie = _S_izero + 14,
_S_iE = _S_izero + 20,
_S_iend = 26
};
static void
_S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
};
template<typename _CharT>
struct __numpunct_cache : public locale::facet
{
const char* _M_grouping;
size_t _M_grouping_size;
bool _M_use_grouping;
const _CharT* _M_truename;
size_t _M_truename_size;
const _CharT* _M_falsename;
size_t _M_falsename_size;
_CharT _M_decimal_point;
_CharT _M_thousands_sep;
_CharT _M_atoms_out[__num_base::_S_oend];
_CharT _M_atoms_in[__num_base::_S_iend];
bool _M_allocated;
__numpunct_cache(size_t __refs = 0)
;
~__numpunct_cache();
void
_M_cache(const locale& __loc);
private:
__numpunct_cache&
operator=(const __numpunct_cache&);
explicit
__numpunct_cache(const __numpunct_cache&);
};
template<typename _CharT>
class numpunct : public locale::facet
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
typedef __numpunct_cache<_CharT> __cache_type;
protected:
__cache_type* _M_data;
public:
static locale::id id;
explicit
numpunct(size_t __refs = 0)
;
explicit
numpunct(__cache_type* __cache, size_t __refs = 0)
;
explicit
numpunct(__c_locale __cloc, size_t __refs = 0)
;
char_type
decimal_point() const
;
char_type
thousands_sep() const
;
string
grouping() const
;
string_type
truename() const
;
string_type
falsename() const
;
protected:
virtual
~numpunct();
virtual char_type
do_decimal_point() const
;
virtual char_type
do_thousands_sep() const
;
virtual string
do_grouping() const
;
virtual string_type
do_truename() const
;
virtual string_type
do_falsename() const
;
void
_M_initialize_numpunct(__c_locale __cloc = 0);
};
template<typename _CharT>
locale::id numpunct<_CharT>::id;
template<>
numpunct<char>::~numpunct();
template<>
void
numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
template<>
numpunct<wchar_t>::~numpunct();
template<>
void
numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
template<typename _CharT>
class numpunct_byname : public numpunct<_CharT>
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;
explicit
numpunct_byname(const char* __s, size_t __refs = 0)
;
protected:
virtual
~numpunct_byname() ;
};
template<typename _CharT, typename _InIter>
class num_get : public locale::facet
{
public:
typedef _CharT char_type;
typedef _InIter iter_type;
static locale::id id;
explicit
num_get(size_t __refs = 0) ;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, bool& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned short& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned int& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long long& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long long& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, float& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, double& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long double& __v) const
;
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, void*& __v) const
;
protected:
virtual ~num_get() ;
iter_type
_M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
string&) const;
template<typename _ValueT>
iter_type
_M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
_ValueT&) const;
template<typename _CharT2>
typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
_M_find(const _CharT2*, size_t __len, _CharT2 __c) const
;
template<typename _CharT2>
typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
int>::__type
_M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
;
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long& __v) const
;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned short& __v) const
;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned int& __v) const
;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long& __v) const
;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long long& __v) const
;
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long long& __v) const
;
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
double&) const;
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
long double&) const;
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
};
template<typename _CharT, typename _InIter>
locale::id num_get<_CharT, _InIter>::id;
template<typename _CharT, typename _OutIter>
class num_put : public locale::facet
{
public:
typedef _CharT char_type;
typedef _OutIter iter_type;
static locale::id id;
explicit
num_put(size_t __refs = 0) ;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long long __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
long double __v) const
;
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
const void* __v) const
;
protected:
template<typename _ValueT>
iter_type
_M_insert_float(iter_type, ios_base& __io, char_type __fill,
char __mod, _ValueT __v) const;
void
_M_group_float(const char* __grouping, size_t __grouping_size,
char_type __sep, const char_type* __p, char_type* __new,
char_type* __cs, int& __len) const;
template<typename _ValueT>
iter_type
_M_insert_int(iter_type, ios_base& __io, char_type __fill,
_ValueT __v) const;
void
_M_group_int(const char* __grouping, size_t __grouping_size,
char_type __sep, ios_base& __io, char_type* __new,
char_type* __cs, int& __len) const;
void
_M_pad(char_type __fill, streamsize __w, ios_base& __io,
char_type* __new, const char_type* __cs, int& __len) const;
virtual
~num_put() ;;
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const;
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
;
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long __v) const
;
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
long long __v) const
;
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long long __v) const
;
virtual iter_type
do_put(iter_type, ios_base&, char_type, double) const;
virtual iter_type
do_put(iter_type, ios_base&, char_type, long double) const;
virtual iter_type
do_put(iter_type, ios_base&, char_type, const void*) const;
};
template <typename _CharT, typename _OutIter>
locale::id num_put<_CharT, _OutIter>::id;
template<typename _CharT>
bool
isspace(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isprint(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
iscntrl(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isupper(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
islower(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isalpha(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isdigit(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
ispunct(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isxdigit(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isalnum(_CharT __c, const locale& __loc)
;
template<typename _CharT>
bool
isgraph(_CharT __c, const locale& __loc)
;
template<typename _CharT>
_CharT
toupper(_CharT __c, const locale& __loc)
;
template<typename _CharT>
_CharT
tolower(_CharT __c, const locale& __loc)
;
}
#define _LOCALE_FACETS_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Facet>
struct __use_cache
{
const _Facet*
operator() (const locale& __loc) const;
};
template<typename _CharT>
struct __use_cache<__numpunct_cache<_CharT> >
{
const __numpunct_cache<_CharT>*
operator() (const locale& __loc) const
;
};
__attribute__ ((__pure__)) bool
__verify_grouping(const char* __grouping, size_t __grouping_size,
const string& __grouping_tmp) throw ();
template<typename _CharT, typename _ValueT>
int
__int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
ios_base::fmtflags __flags, bool __dec)
;
template<typename _CharT>
_CharT*
__add_grouping(_CharT* __s, _CharT __sep,
const char* __gbeg, size_t __gsize,
const _CharT* __first, const _CharT* __last)
;
extern template class numpunct<char>;
extern template class numpunct_byname<char>;
extern template class num_get<char>;
extern template class num_put<char>;
extern template class ctype_byname<char>;
extern template
const ctype<char>&
use_facet<ctype<char> >(const locale&);
extern template
const numpunct<char>&
use_facet<numpunct<char> >(const locale&);
extern template
const num_put<char>&
use_facet<num_put<char> >(const locale&);
extern template
const num_get<char>&
use_facet<num_get<char> >(const locale&);
extern template
bool
has_facet<ctype<char> >(const locale&);
extern template
bool
has_facet<numpunct<char> >(const locale&);
extern template
bool
has_facet<num_put<char> >(const locale&);
extern template
bool
has_facet<num_get<char> >(const locale&);
extern template class numpunct<wchar_t>;
extern template class numpunct_byname<wchar_t>;
extern template class num_get<wchar_t>;
extern template class num_put<wchar_t>;
extern template class ctype_byname<wchar_t>;
extern template
const ctype<wchar_t>&
use_facet<ctype<wchar_t> >(const locale&);
extern template
const numpunct<wchar_t>&
use_facet<numpunct<wchar_t> >(const locale&);
extern template
const num_put<wchar_t>&
use_facet<num_put<wchar_t> >(const locale&);
extern template
const num_get<wchar_t>&
use_facet<num_get<wchar_t> >(const locale&);
extern template
bool
has_facet<ctype<wchar_t> >(const locale&);
extern template
bool
has_facet<numpunct<wchar_t> >(const locale&);
extern template
bool
has_facet<num_put<wchar_t> >(const locale&);
extern template
bool
has_facet<num_get<wchar_t> >(const locale&);
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Facet>
const _Facet&
__check_facet(const _Facet* __f)
;
template<typename _CharT, typename _Traits>
class basic_ios : public ios_base
{
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef ctype<_CharT> __ctype_type;
typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
__num_put_type;
typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
__num_get_type;
protected:
basic_ostream<_CharT, _Traits>* _M_tie;
mutable char_type _M_fill;
mutable bool _M_fill_init;
basic_streambuf<_CharT, _Traits>* _M_streambuf;
const __ctype_type* _M_ctype;
const __num_put_type* _M_num_put;
const __num_get_type* _M_num_get;
public:
explicit operator bool() const
;
bool
operator!() const
;
iostate
rdstate() const
;
void
clear(iostate __state = goodbit);
void
setstate(iostate __state)
;
void
_M_setstate(iostate __state)
;
bool
good() const
;
bool
eof() const
;
bool
fail() const
;
bool
bad() const
;
iostate
exceptions() const
;
void
exceptions(iostate __except)
;
explicit
basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
;
virtual
~basic_ios() ;
basic_ostream<_CharT, _Traits>*
tie() const
;
basic_ostream<_CharT, _Traits>*
tie(basic_ostream<_CharT, _Traits>* __tiestr)
;
basic_streambuf<_CharT, _Traits>*
rdbuf() const
;
basic_streambuf<_CharT, _Traits>*
rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
basic_ios&
copyfmt(const basic_ios& __rhs);
char_type
fill() const
;
char_type
fill(char_type __ch)
;
locale
imbue(const locale& __loc);
char
narrow(char_type __c, char __dfault) const
;
char_type
widen(char __c) const
;
protected:
basic_ios()
;
void
init(basic_streambuf<_CharT, _Traits>* __sb);
basic_ios(const basic_ios&) = delete;
basic_ios& operator=(const basic_ios&) = delete;
void
move(basic_ios& __rhs)
;
void
move(basic_ios&& __rhs)
;
void
swap(basic_ios& __rhs) noexcept
{
ios_base::_M_swap(__rhs);
_M_cache_locale(_M_ios_locale);
__rhs._M_cache_locale(__rhs._M_ios_locale);
std::swap(_M_tie, __rhs._M_tie);
std::swap(_M_fill, __rhs._M_fill);
std::swap(_M_fill_init, __rhs._M_fill_init);
}
void
set_rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
{ _M_streambuf = __sb; }
void
_M_cache_locale(const locale& __loc);
};
}
#define _BASIC_IOS_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
extern template class basic_ios<char>;
extern template class basic_ios<wchar_t>;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
class basic_ostream : virtual public basic_ios<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_ios<_CharT, _Traits> __ios_type;
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
__num_put_type;
typedef ctype<_CharT> __ctype_type;
explicit
basic_ostream(__streambuf_type* __sb)
;
virtual
~basic_ostream() ;
class sentry;
friend class sentry;
__ostream_type&
operator<<(__ostream_type& (*__pf)(__ostream_type&))
;
__ostream_type&
operator<<(__ios_type& (*__pf)(__ios_type&))
;
__ostream_type&
operator<<(ios_base& (*__pf) (ios_base&))
;
__ostream_type&
operator<<(long __n)
;
__ostream_type&
operator<<(unsigned long __n)
;
__ostream_type&
operator<<(bool __n)
;
__ostream_type&
operator<<(short __n);
__ostream_type&
operator<<(unsigned short __n)
;
__ostream_type&
operator<<(int __n);
__ostream_type&
operator<<(unsigned int __n)
;
__ostream_type&
operator<<(long long __n)
;
__ostream_type&
operator<<(unsigned long long __n)
;
__ostream_type&
operator<<(double __f)
;
__ostream_type&
operator<<(float __f)
;
__ostream_type&
operator<<(long double __f)
;
__ostream_type&
operator<<(const void* __p)
;
__ostream_type&
operator<<(__streambuf_type* __sb);
__ostream_type&
put(char_type __c);
void
_M_write(const char_type* __s, streamsize __n)
;
__ostream_type&
write(const char_type* __s, streamsize __n);
__ostream_type&
flush();
pos_type
tellp();
__ostream_type&
seekp(pos_type);
__ostream_type&
seekp(off_type, ios_base::seekdir);
protected:
basic_ostream()
;
basic_ostream(basic_iostream<_CharT, _Traits>&) ;
basic_ostream(const basic_ostream&) = delete;
basic_ostream(basic_ostream&& __rhs)
;
basic_ostream& operator=(const basic_ostream&) = delete;
basic_ostream&
operator=(basic_ostream&& __rhs)
;
void
swap(basic_ostream& __rhs)
;
template<typename _ValueT>
__ostream_type&
_M_insert(_ValueT __v);
};
template <typename _CharT, typename _Traits>
class basic_ostream<_CharT, _Traits>::sentry
{
bool _M_ok;
basic_ostream<_CharT, _Traits>& _M_os;
public:
explicit
sentry(basic_ostream<_CharT, _Traits>& __os);
~sentry()
;
explicit
operator bool() const
;
};
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
;
template <class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, char __c)
;
template<class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
;
template<class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits> &
operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
template<class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
;
template<class _Traits>
basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
;
template<class _Traits>
basic_ostream<char, _Traits> &
operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
endl(basic_ostream<_CharT, _Traits>& __os)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
ends(basic_ostream<_CharT, _Traits>& __os)
;
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
flush(basic_ostream<_CharT, _Traits>& __os)
;
template<typename _CharT, typename _Traits, typename _Tp>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp& __x)
;
}
#define _OSTREAM_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
;
extern template class basic_ostream<char>;
extern template ostream& endl(ostream&);
extern template ostream& ends(ostream&);
extern template ostream& flush(ostream&);
extern template ostream& operator<<(ostream&, char);
extern template ostream& operator<<(ostream&, unsigned char);
extern template ostream& operator<<(ostream&, signed char);
extern template ostream& operator<<(ostream&, const char*);
extern template ostream& operator<<(ostream&, const unsigned char*);
extern template ostream& operator<<(ostream&, const signed char*);
extern template ostream& ostream::_M_insert(long);
extern template ostream& ostream::_M_insert(unsigned long);
extern template ostream& ostream::_M_insert(bool);
extern template ostream& ostream::_M_insert(long long);
extern template ostream& ostream::_M_insert(unsigned long long);
extern template ostream& ostream::_M_insert(double);
extern template ostream& ostream::_M_insert(long double);
extern template ostream& ostream::_M_insert(const void*);
extern template class basic_ostream<wchar_t>;
extern template wostream& endl(wostream&);
extern template wostream& ends(wostream&);
extern template wostream& flush(wostream&);
extern template wostream& operator<<(wostream&, wchar_t);
extern template wostream& operator<<(wostream&, char);
extern template wostream& operator<<(wostream&, const wchar_t*);
extern template wostream& operator<<(wostream&, const char*);
extern template wostream& wostream::_M_insert(long);
extern template wostream& wostream::_M_insert(unsigned long);
extern template wostream& wostream::_M_insert(bool);
extern template wostream& wostream::_M_insert(long long);
extern template wostream& wostream::_M_insert(unsigned long long);
extern template wostream& wostream::_M_insert(double);
extern template wostream& wostream::_M_insert(long double);
extern template wostream& wostream::_M_insert(const void*);
}
#define _GLIBCXX_ISTREAM 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
class basic_istream : virtual public basic_ios<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_ios<_CharT, _Traits> __ios_type;
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
__num_get_type;
typedef ctype<_CharT> __ctype_type;
protected:
streamsize _M_gcount;
public:
explicit
basic_istream(__streambuf_type* __sb)
;
virtual
~basic_istream()
;
class sentry;
friend class sentry;
__istream_type&
operator>>(__istream_type& (*__pf)(__istream_type&))
;
__istream_type&
operator>>(__ios_type& (*__pf)(__ios_type&))
;
__istream_type&
operator>>(ios_base& (*__pf)(ios_base&))
;
__istream_type&
operator>>(bool& __n)
;
__istream_type&
operator>>(short& __n);
__istream_type&
operator>>(unsigned short& __n)
;
__istream_type&
operator>>(int& __n);
__istream_type&
operator>>(unsigned int& __n)
;
__istream_type&
operator>>(long& __n)
;
__istream_type&
operator>>(unsigned long& __n)
;
__istream_type&
operator>>(long long& __n)
;
__istream_type&
operator>>(unsigned long long& __n)
;
__istream_type&
operator>>(float& __f)
;
__istream_type&
operator>>(double& __f)
;
__istream_type&
operator>>(long double& __f)
;
__istream_type&
operator>>(void*& __p)
;
__istream_type&
operator>>(__streambuf_type* __sb);
streamsize
gcount() const
;
int_type
get();
__istream_type&
get(char_type& __c);
__istream_type&
get(char_type* __s, streamsize __n, char_type __delim);
__istream_type&
get(char_type* __s, streamsize __n)
;
__istream_type&
get(__streambuf_type& __sb, char_type __delim);
__istream_type&
get(__streambuf_type& __sb)
;
__istream_type&
getline(char_type* __s, streamsize __n, char_type __delim);
__istream_type&
getline(char_type* __s, streamsize __n)
;
__istream_type&
ignore(streamsize __n, int_type __delim);
__istream_type&
ignore(streamsize __n);
__istream_type&
ignore();
int_type
peek();
__istream_type&
read(char_type* __s, streamsize __n);
streamsize
readsome(char_type* __s, streamsize __n);
__istream_type&
putback(char_type __c);
__istream_type&
unget();
int
sync();
pos_type
tellg();
__istream_type&
seekg(pos_type);
__istream_type&
seekg(off_type, ios_base::seekdir);
protected:
basic_istream()
;
basic_istream(const basic_istream&) = delete;
basic_istream(basic_istream&& __rhs)
;
basic_istream& operator=(const basic_istream&) = delete;
basic_istream&
operator=(basic_istream&& __rhs)
;
void
swap(basic_istream& __rhs)
;
template<typename _ValueT>
__istream_type&
_M_extract(_ValueT& __v);
};
template<>
basic_istream<char>&
basic_istream<char>::
getline(char_type* __s, streamsize __n, char_type __delim);
template<>
basic_istream<char>&
basic_istream<char>::
ignore(streamsize __n);
template<>
basic_istream<char>&
basic_istream<char>::
ignore(streamsize __n, int_type __delim);
template<>
basic_istream<wchar_t>&
basic_istream<wchar_t>::
getline(char_type* __s, streamsize __n, char_type __delim);
template<>
basic_istream<wchar_t>&
basic_istream<wchar_t>::
ignore(streamsize __n);
template<>
basic_istream<wchar_t>&
basic_istream<wchar_t>::
ignore(streamsize __n, int_type __delim);
template<typename _CharT, typename _Traits>
class basic_istream<_CharT, _Traits>::sentry
{
bool _M_ok;
public:
typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef typename __istream_type::__ctype_type __ctype_type;
typedef typename _Traits::int_type __int_type;
explicit
sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
explicit
operator bool() const
;
};
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
template<class _Traits>
basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
;
template<class _Traits>
basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
;
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
template<>
basic_istream<char>&
operator>>(basic_istream<char>& __in, char* __s);
template<class _Traits>
basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
;
template<class _Traits>
basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
;
template<typename _CharT, typename _Traits>
class basic_iostream
: public basic_istream<_CharT, _Traits>,
public basic_ostream<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_ostream<_CharT, _Traits> __ostream_type;
explicit
basic_iostream(basic_streambuf<_CharT, _Traits>* __sb) ;
virtual
~basic_iostream() ;
protected:
basic_iostream() ;
basic_iostream(const basic_iostream&) = delete;
basic_iostream(basic_iostream&& __rhs)
;
basic_iostream& operator=(const basic_iostream&) = delete;
basic_iostream&
operator=(basic_iostream&& __rhs)
;
void
swap(basic_iostream& __rhs)
;
};
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
ws(basic_istream<_CharT, _Traits>& __is);
template<typename _CharT, typename _Traits, typename _Tp>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x)
;
}
#define _ISTREAM_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
;
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
;
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
ws(basic_istream<_CharT, _Traits>& __in)
;
extern template class basic_istream<char>;
extern template istream& ws(istream&);
extern template istream& operator>>(istream&, char&);
extern template istream& operator>>(istream&, char*);
extern template istream& operator>>(istream&, unsigned char&);
extern template istream& operator>>(istream&, signed char&);
extern template istream& operator>>(istream&, unsigned char*);
extern template istream& operator>>(istream&, signed char*);
extern template istream& istream::_M_extract(unsigned short&);
extern template istream& istream::_M_extract(unsigned int&);
extern template istream& istream::_M_extract(long&);
extern template istream& istream::_M_extract(unsigned long&);
extern template istream& istream::_M_extract(bool&);
extern template istream& istream::_M_extract(long long&);
extern template istream& istream::_M_extract(unsigned long long&);
extern template istream& istream::_M_extract(float&);
extern template istream& istream::_M_extract(double&);
extern template istream& istream::_M_extract(long double&);
extern template istream& istream::_M_extract(void*&);
extern template class basic_iostream<char>;
extern template class basic_istream<wchar_t>;
extern template wistream& ws(wistream&);
extern template wistream& operator>>(wistream&, wchar_t&);
extern template wistream& operator>>(wistream&, wchar_t*);
extern template wistream& wistream::_M_extract(unsigned short&);
extern template wistream& wistream::_M_extract(unsigned int&);
extern template wistream& wistream::_M_extract(long&);
extern template wistream& wistream::_M_extract(unsigned long&);
extern template wistream& wistream::_M_extract(bool&);
extern template wistream& wistream::_M_extract(long long&);
extern template wistream& wistream::_M_extract(unsigned long long&);
extern template wistream& wistream::_M_extract(float&);
extern template wistream& wistream::_M_extract(double&);
extern template wistream& wistream::_M_extract(long double&);
extern template wistream& wistream::_M_extract(void*&);
extern template class basic_iostream<wchar_t>;
}
#define _STREAM_ITERATOR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp, typename _CharT = char,
typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
class istream_iterator
: public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef basic_istream<_CharT, _Traits> istream_type;
private:
istream_type* _M_stream;
_Tp _M_value;
bool _M_ok;
public:
constexpr istream_iterator()
: _M_stream(0), _M_value(), _M_ok(false) {}
istream_iterator(istream_type& __s)
;
istream_iterator(const istream_iterator& __obj)
;
const _Tp&
operator*() const
;
const _Tp*
operator->() const ;
istream_iterator&
operator++()
;
istream_iterator
operator++(int)
;
bool
_M_equal(const istream_iterator& __x) const
;
private:
void
_M_read()
;
};
template<typename _Tp, typename _CharT, typename _Traits, typename _Dist>
bool
operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
;
template <class _Tp, class _CharT, class _Traits, class _Dist>
bool
operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
;
template<typename _Tp, typename _CharT = char,
typename _Traits = char_traits<_CharT> >
class ostream_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef basic_ostream<_CharT, _Traits> ostream_type;
private:
ostream_type* _M_stream;
const _CharT* _M_string;
public:
ostream_iterator(ostream_type& __s) ;
ostream_iterator(ostream_type& __s, const _CharT* __c) ;
ostream_iterator(const ostream_iterator& __obj) ;
ostream_iterator&
operator=(const _Tp& __value)
;
ostream_iterator&
operator*()
;
ostream_iterator&
operator++()
;
ostream_iterator&
operator++(int)
;
};
}
namespace boost
{
namespace detail {
template <class Category, class T, class Distance, class Pointer, class Reference>
struct iterator_base : std::iterator<Category, T, Distance, Pointer, Reference> {};
}
template <class Category, class T, class Distance = std::ptrdiff_t,
class Pointer = T*, class Reference = T&>
struct iterator : boost::detail::iterator_base<Category, T, Distance, Pointer, Reference> {};
}
#define WORKAROUND_DWA2002126_HPP
#define __BORLANDC___WORKAROUND_GUARD 1
#define __CODEGEARC___WORKAROUND_GUARD 1
#define _MSC_VER_WORKAROUND_GUARD 1
#define _MSC_FULL_VER_WORKAROUND_GUARD 1
#define BOOST_MSVC_WORKAROUND_GUARD 1
#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 1
#define __GNUC___WORKAROUND_GUARD 0
#define __GNUC_MINOR___WORKAROUND_GUARD 0
#define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 0
#define __IBMCPP___WORKAROUND_GUARD 1
#define __SUNPRO_CC_WORKAROUND_GUARD 1
#define __DECCXX_VER_WORKAROUND_GUARD 1
#define __MWERKS___WORKAROUND_GUARD 1
#define __EDG___WORKAROUND_GUARD 1
#define __EDG_VERSION___WORKAROUND_GUARD 1
#define __HP_aCC_WORKAROUND_GUARD 1
#define __hpxstd98_WORKAROUND_GUARD 1
#define _CRAYC_WORKAROUND_GUARD 1
#define __DMC___WORKAROUND_GUARD 1
#define MPW_CPLUS_WORKAROUND_GUARD 1
#define __COMO___WORKAROUND_GUARD 1
#define __COMO_VERSION___WORKAROUND_GUARD 1
#define __INTEL_COMPILER_WORKAROUND_GUARD 1
#define __ICL_WORKAROUND_GUARD 1
#define _COMPILER_VERSION_WORKAROUND_GUARD 1
#define _RWSTD_VER_WORKAROUND_GUARD 1
#define BOOST_RWSTD_VER_WORKAROUND_GUARD 1
#define __GLIBCPP___WORKAROUND_GUARD 1
#define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 1
#define __SGI_STL_PORT_WORKAROUND_GUARD 1
#define _STLPORT_VERSION_WORKAROUND_GUARD 1
#define __LIBCOMO_VERSION___WORKAROUND_GUARD 1
#define _CPPLIB_VER_WORKAROUND_GUARD 1
#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 1
#define BOOST_INTEL_WIN_WORKAROUND_GUARD 1
#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 1
#define BOOST_INTEL_WORKAROUND_GUARD 1
#define BOOST_MPL_CFG_GCC_WORKAROUND_GUARD 0
#define BOOST_WORKAROUND(symbol,test) ((symbol ## _WORKAROUND_GUARD + 0 == 0) && (symbol != 0) && (1 % (( (symbol test) ) + 1)))
#define BOOST_TESTED_AT(value) != ((value)-(value))
namespace boost {
namespace detail {
template <typename T> class empty_base {
};
}
}
namespace boost
{
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct less_than_comparable2 : B
{
friend bool operator<=(const T& x, const U& y) ;
friend bool operator>=(const T& x, const U& y) ;
friend bool operator>(const U& x, const T& y) ;
friend bool operator<(const U& x, const T& y) ;
friend bool operator<=(const U& x, const T& y) ;
friend bool operator>=(const U& x, const T& y) ;
};
template <class T, class B = ::boost::detail::empty_base<T> >
struct less_than_comparable1 : B
{
friend bool operator>(const T& x, const T& y) ;
friend bool operator<=(const T& x, const T& y) ;
friend bool operator>=(const T& x, const T& y) ;
};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct equality_comparable2 : B
{
friend bool operator==(const U& y, const T& x) ;
friend bool operator!=(const U& y, const T& x) ;
friend bool operator!=(const T& y, const U& x) ;
};
template <class T, class B = ::boost::detail::empty_base<T> >
struct equality_comparable1 : B
{
friend bool operator!=(const T& x, const T& y) ;
};
#define BOOST_OPERATOR2_LEFT(name) name ##2 ##_ ##left
#define BOOST_BINARY_OPERATOR_COMMUTATIVE(NAME,OP) template <class T, class U, class B = ::boost::detail::empty_base<T> > struct NAME ##2 : B { friend T operator OP( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } friend T operator OP( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv OP ##= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct NAME ##1 : B { friend T operator OP( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } };
#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE(NAME,OP) template <class T, class U, class B = ::boost::detail::empty_base<T> > struct NAME ##2 : B { friend T operator OP( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct BOOST_OPERATOR2_LEFT(NAME) : B { friend T operator OP( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct NAME ##1 : B { friend T operator OP( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct multipliable2 : B { friend T operator *( const T& lhs, const U& rhs ) ; friend T operator *( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct multipliable1 : B { friend T operator *( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct addable2 : B { friend T operator +( const T& lhs, const U& rhs ) ; friend T operator +( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct addable1 : B { friend T operator +( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct subtractable2 : B { friend T operator -( const T& lhs, const U& rhs ) ; }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct subtractable2_left : B { friend T operator -( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct subtractable1 : B { friend T operator -( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct dividable2 : B { friend T operator /( const T& lhs, const U& rhs ) ; }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct dividable2_left : B { friend T operator /( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct dividable1 : B { friend T operator /( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct modable2 : B { friend T operator %( const T& lhs, const U& rhs ) ; }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct modable2_left : B { friend T operator %( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct modable1 : B { friend T operator %( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct xorable2 : B { friend T operator ^( const T& lhs, const U& rhs ) ; friend T operator ^( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct xorable1 : B { friend T operator ^( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct andable2 : B { friend T operator &( const T& lhs, const U& rhs ) ; friend T operator &( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct andable1 : B { friend T operator &( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct orable2 : B { friend T operator |( const T& lhs, const U& rhs ) ; friend T operator |( const U& lhs, const T& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct orable1 : B { friend T operator |( const T& lhs, const T& rhs ) ; };
#undef BOOST_BINARY_OPERATOR_COMMUTATIVE
#undef BOOST_BINARY_OPERATOR_NON_COMMUTATIVE
#undef BOOST_OPERATOR2_LEFT
template <class T, class B = ::boost::detail::empty_base<T> >
struct incrementable : B
{
friend T operator++(T& x, int)
;
private:
typedef T incrementable_type;
};
template <class T, class B = ::boost::detail::empty_base<T> >
struct decrementable : B
{
friend T operator--(T& x, int)
;
private:
typedef T decrementable_type;
};
template <class T, class P, class B = ::boost::detail::empty_base<T> >
struct dereferenceable : B
{
P operator->() const
;
};
template <class T, class I, class R, class B = ::boost::detail::empty_base<T> >
struct indexable : B
{
R operator[](I n) const
;
};
#define BOOST_BINARY_OPERATOR(NAME,OP) template <class T, class U, class B = ::boost::detail::empty_base<T> > struct NAME ##2 : B { friend T operator OP( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct NAME ##1 : B { friend T operator OP( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv OP ##= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct left_shiftable2 : B { friend T operator <<( const T& lhs, const U& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct left_shiftable1 : B { friend T operator <<( const T& lhs, const T& rhs ) ; };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct right_shiftable2 : B { friend T operator >>( const T& lhs, const U& rhs ) ; }; template <class T, class B = ::boost::detail::empty_base<T> > struct right_shiftable1 : B { friend T operator >>( const T& lhs, const T& rhs ) ; };
#undef BOOST_BINARY_OPERATOR
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct equivalent2 : B
{
friend bool operator==(const T& x, const U& y)
;
};
template <class T, class B = ::boost::detail::empty_base<T> >
struct equivalent1 : B
{
friend bool operator==(const T&x, const T&y)
;
};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct partially_ordered2 : B
{
friend bool operator<=(const T& x, const U& y)
;
friend bool operator>=(const T& x, const U& y)
;
friend bool operator>(const U& x, const T& y)
;
friend bool operator<(const U& x, const T& y)
;
friend bool operator<=(const U& x, const T& y)
;
friend bool operator>=(const U& x, const T& y)
;
};
template <class T, class B = ::boost::detail::empty_base<T> >
struct partially_ordered1 : B
{
friend bool operator>(const T& x, const T& y)
;
friend bool operator<=(const T& x, const T& y)
;
friend bool operator>=(const T& x, const T& y)
;
};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct totally_ordered2
: less_than_comparable2<T, U
, equality_comparable2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct totally_ordered1
: less_than_comparable1<T
, equality_comparable1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct additive2
: addable2<T, U
, subtractable2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct additive1
: addable1<T
, subtractable1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct multiplicative2
: multipliable2<T, U
, dividable2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct multiplicative1
: multipliable1<T
, dividable1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct integer_multiplicative2
: multiplicative2<T, U
, modable2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct integer_multiplicative1
: multiplicative1<T
, modable1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct arithmetic2
: additive2<T, U
, multiplicative2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct arithmetic1
: additive1<T
, multiplicative1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct integer_arithmetic2
: additive2<T, U
, integer_multiplicative2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct integer_arithmetic1
: additive1<T
, integer_multiplicative1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct bitwise2
: xorable2<T, U
, andable2<T, U
, orable2<T, U, B
> > > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct bitwise1
: xorable1<T
, andable1<T
, orable1<T, B
> > > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct unit_steppable
: incrementable<T
, decrementable<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct shiftable2
: left_shiftable2<T, U
, right_shiftable2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct shiftable1
: left_shiftable1<T
, right_shiftable1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ring_operators2
: additive2<T, U
, subtractable2_left<T, U
, multipliable2<T, U, B
> > > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct ring_operators1
: additive1<T
, multipliable1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ordered_ring_operators2
: ring_operators2<T, U
, totally_ordered2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct ordered_ring_operators1
: ring_operators1<T
, totally_ordered1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct field_operators2
: ring_operators2<T, U
, dividable2<T, U
, dividable2_left<T, U, B
> > > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct field_operators1
: ring_operators1<T
, dividable1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ordered_field_operators2
: field_operators2<T, U
, totally_ordered2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct ordered_field_operators1
: field_operators1<T
, totally_ordered1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct euclidian_ring_operators2
: ring_operators2<T, U
, dividable2<T, U
, dividable2_left<T, U
, modable2<T, U
, modable2_left<T, U, B
> > > > > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct euclidian_ring_operators1
: ring_operators1<T
, dividable1<T
, modable1<T, B
> > > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ordered_euclidian_ring_operators2
: totally_ordered2<T, U
, euclidian_ring_operators2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct ordered_euclidian_ring_operators1
: totally_ordered1<T
, euclidian_ring_operators1<T, B
> > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct euclidean_ring_operators2
: ring_operators2<T, U
, dividable2<T, U
, dividable2_left<T, U
, modable2<T, U
, modable2_left<T, U, B
> > > > > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct euclidean_ring_operators1
: ring_operators1<T
, dividable1<T
, modable1<T, B
> > > {};
template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ordered_euclidean_ring_operators2
: totally_ordered2<T, U
, euclidean_ring_operators2<T, U, B
> > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct ordered_euclidean_ring_operators1
: totally_ordered1<T
, euclidean_ring_operators1<T, B
> > {};
template <class T, class P, class B = ::boost::detail::empty_base<T> >
struct input_iteratable
: equality_comparable1<T
, incrementable<T
, dereferenceable<T, P, B
> > > {};
template <class T, class B = ::boost::detail::empty_base<T> >
struct output_iteratable
: incrementable<T, B
> {};
template <class T, class P, class B = ::boost::detail::empty_base<T> >
struct forward_iteratable
: input_iteratable<T, P, B
> {};
template <class T, class P, class B = ::boost::detail::empty_base<T> >
struct bidirectional_iteratable
: forward_iteratable<T, P
, decrementable<T, B
> > {};
template <class T, class P, class D, class R, class B = ::boost::detail::empty_base<T> >
struct random_access_iteratable
: bidirectional_iteratable<T, P
, less_than_comparable1<T
, additive2<T, D
, indexable<T, D, R, B
> > > > {};
}
#define BOOST_IMPORT_TEMPLATE4(template_name)
#define BOOST_IMPORT_TEMPLATE3(template_name)
#define BOOST_IMPORT_TEMPLATE2(template_name)
#define BOOST_IMPORT_TEMPLATE1(template_name)
namespace boost {
namespace detail {
struct true_t {};
struct false_t {};
}
template<class T> struct is_chained_base {
typedef ::boost::detail::false_t value;
};
}
#define BOOST_OPERATOR_TEMPLATE4(template_name4) BOOST_IMPORT_TEMPLATE4(template_name4) template<class T, class U, class V, class W, class B> struct is_chained_base< ::boost::template_name4<T, U, V, W, B> > { typedef ::boost::detail::true_t value; };
#define BOOST_OPERATOR_TEMPLATE3(template_name3) BOOST_IMPORT_TEMPLATE3(template_name3) template<class T, class U, class V, class B> struct is_chained_base< ::boost::template_name3<T, U, V, B> > { typedef ::boost::detail::true_t value; };
#define BOOST_OPERATOR_TEMPLATE2(template_name2) BOOST_IMPORT_TEMPLATE2(template_name2) template<class T, class U, class B> struct is_chained_base< ::boost::template_name2<T, U, B> > { typedef ::boost::detail::true_t value; };
#define BOOST_OPERATOR_TEMPLATE1(template_name1) BOOST_IMPORT_TEMPLATE1(template_name1) template<class T, class B> struct is_chained_base< ::boost::template_name1<T, B> > { typedef ::boost::detail::true_t value; };
#define BOOST_OPERATOR_TEMPLATE(template_name) template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct template_name : template_name ##2<T, U, B> {}; template<class T, class U, class B> struct template_name<T, U, B, ::boost::detail::true_t> : template_name ##1<T, U> {}; template <class T, class B> struct template_name<T, T, B, ::boost::detail::false_t> : template_name ##1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::template_name<T, U, B, O> > { typedef ::boost::detail::true_t value; }; BOOST_OPERATOR_TEMPLATE2(template_name ##2) BOOST_OPERATOR_TEMPLATE1(template_name ##1)
namespace boost {
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct less_than_comparable : less_than_comparable2<T, U, B> {}; template<class T, class U, class B> struct less_than_comparable<T, U, B, ::boost::detail::true_t> : less_than_comparable1<T, U> {}; template <class T, class B> struct less_than_comparable<T, T, B, ::boost::detail::false_t> : less_than_comparable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::less_than_comparable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::less_than_comparable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::less_than_comparable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct equality_comparable : equality_comparable2<T, U, B> {}; template<class T, class U, class B> struct equality_comparable<T, U, B, ::boost::detail::true_t> : equality_comparable1<T, U> {}; template <class T, class B> struct equality_comparable<T, T, B, ::boost::detail::false_t> : equality_comparable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::equality_comparable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::equality_comparable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::equality_comparable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct multipliable : multipliable2<T, U, B> {}; template<class T, class U, class B> struct multipliable<T, U, B, ::boost::detail::true_t> : multipliable1<T, U> {}; template <class T, class B> struct multipliable<T, T, B, ::boost::detail::false_t> : multipliable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::multipliable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::multipliable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::multipliable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct addable : addable2<T, U, B> {}; template<class T, class U, class B> struct addable<T, U, B, ::boost::detail::true_t> : addable1<T, U> {}; template <class T, class B> struct addable<T, T, B, ::boost::detail::false_t> : addable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::addable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::addable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::addable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct subtractable : subtractable2<T, U, B> {}; template<class T, class U, class B> struct subtractable<T, U, B, ::boost::detail::true_t> : subtractable1<T, U> {}; template <class T, class B> struct subtractable<T, T, B, ::boost::detail::false_t> : subtractable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::subtractable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::subtractable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::subtractable1<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< ::boost::subtractable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct dividable : dividable2<T, U, B> {}; template<class T, class U, class B> struct dividable<T, U, B, ::boost::detail::true_t> : dividable1<T, U> {}; template <class T, class B> struct dividable<T, T, B, ::boost::detail::false_t> : dividable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::dividable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::dividable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::dividable1<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< ::boost::dividable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct modable : modable2<T, U, B> {}; template<class T, class U, class B> struct modable<T, U, B, ::boost::detail::true_t> : modable1<T, U> {}; template <class T, class B> struct modable<T, T, B, ::boost::detail::false_t> : modable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::modable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::modable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::modable1<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< ::boost::modable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct xorable : xorable2<T, U, B> {}; template<class T, class U, class B> struct xorable<T, U, B, ::boost::detail::true_t> : xorable1<T, U> {}; template <class T, class B> struct xorable<T, T, B, ::boost::detail::false_t> : xorable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::xorable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::xorable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::xorable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct andable : andable2<T, U, B> {}; template<class T, class U, class B> struct andable<T, U, B, ::boost::detail::true_t> : andable1<T, U> {}; template <class T, class B> struct andable<T, T, B, ::boost::detail::false_t> : andable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::andable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::andable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::andable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct orable : orable2<T, U, B> {}; template<class T, class U, class B> struct orable<T, U, B, ::boost::detail::true_t> : orable1<T, U> {}; template <class T, class B> struct orable<T, T, B, ::boost::detail::false_t> : orable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::orable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::orable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::orable1<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class B> struct is_chained_base< ::boost::incrementable<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class B> struct is_chained_base< ::boost::decrementable<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< ::boost::dereferenceable<T, U, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class V, class B> struct is_chained_base< ::boost::indexable<T, U, V, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct left_shiftable : left_shiftable2<T, U, B> {}; template<class T, class U, class B> struct left_shiftable<T, U, B, ::boost::detail::true_t> : left_shiftable1<T, U> {}; template <class T, class B> struct left_shiftable<T, T, B, ::boost::detail::false_t> : left_shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::left_shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::left_shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::left_shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct right_shiftable : right_shiftable2<T, U, B> {}; template<class T, class U, class B> struct right_shiftable<T, U, B, ::boost::detail::true_t> : right_shiftable1<T, U> {}; template <class T, class B> struct right_shiftable<T, T, B, ::boost::detail::false_t> : right_shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::right_shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::right_shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::right_shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct equivalent : equivalent2<T, U, B> {}; template<class T, class U, class B> struct equivalent<T, U, B, ::boost::detail::true_t> : equivalent1<T, U> {}; template <class T, class B> struct equivalent<T, T, B, ::boost::detail::false_t> : equivalent1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::equivalent<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::equivalent2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::equivalent1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct partially_ordered : partially_ordered2<T, U, B> {}; template<class T, class U, class B> struct partially_ordered<T, U, B, ::boost::detail::true_t> : partially_ordered1<T, U> {}; template <class T, class B> struct partially_ordered<T, T, B, ::boost::detail::false_t> : partially_ordered1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::partially_ordered<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::partially_ordered2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::partially_ordered1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct totally_ordered : totally_ordered2<T, U, B> {}; template<class T, class U, class B> struct totally_ordered<T, U, B, ::boost::detail::true_t> : totally_ordered1<T, U> {}; template <class T, class B> struct totally_ordered<T, T, B, ::boost::detail::false_t> : totally_ordered1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::totally_ordered<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::totally_ordered2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::totally_ordered1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct additive : additive2<T, U, B> {}; template<class T, class U, class B> struct additive<T, U, B, ::boost::detail::true_t> : additive1<T, U> {}; template <class T, class B> struct additive<T, T, B, ::boost::detail::false_t> : additive1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::additive<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::additive2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::additive1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct multiplicative : multiplicative2<T, U, B> {}; template<class T, class U, class B> struct multiplicative<T, U, B, ::boost::detail::true_t> : multiplicative1<T, U> {}; template <class T, class B> struct multiplicative<T, T, B, ::boost::detail::false_t> : multiplicative1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::multiplicative<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::multiplicative2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::multiplicative1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct integer_multiplicative : integer_multiplicative2<T, U, B> {}; template<class T, class U, class B> struct integer_multiplicative<T, U, B, ::boost::detail::true_t> : integer_multiplicative1<T, U> {}; template <class T, class B> struct integer_multiplicative<T, T, B, ::boost::detail::false_t> : integer_multiplicative1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::integer_multiplicative<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::integer_multiplicative2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::integer_multiplicative1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct arithmetic : arithmetic2<T, U, B> {}; template<class T, class U, class B> struct arithmetic<T, U, B, ::boost::detail::true_t> : arithmetic1<T, U> {}; template <class T, class B> struct arithmetic<T, T, B, ::boost::detail::false_t> : arithmetic1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::arithmetic<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::arithmetic2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::arithmetic1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct integer_arithmetic : integer_arithmetic2<T, U, B> {}; template<class T, class U, class B> struct integer_arithmetic<T, U, B, ::boost::detail::true_t> : integer_arithmetic1<T, U> {}; template <class T, class B> struct integer_arithmetic<T, T, B, ::boost::detail::false_t> : integer_arithmetic1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::integer_arithmetic<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::integer_arithmetic2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::integer_arithmetic1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct bitwise : bitwise2<T, U, B> {}; template<class T, class U, class B> struct bitwise<T, U, B, ::boost::detail::true_t> : bitwise1<T, U> {}; template <class T, class B> struct bitwise<T, T, B, ::boost::detail::false_t> : bitwise1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::bitwise<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::bitwise2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::bitwise1<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class B> struct is_chained_base< ::boost::unit_steppable<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct shiftable : shiftable2<T, U, B> {}; template<class T, class U, class B> struct shiftable<T, U, B, ::boost::detail::true_t> : shiftable1<T, U> {}; template <class T, class B> struct shiftable<T, T, B, ::boost::detail::false_t> : shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ring_operators : ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ring_operators<T, U, B, ::boost::detail::true_t> : ring_operators1<T, U> {}; template <class T, class B> struct ring_operators<T, T, B, ::boost::detail::false_t> : ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_ring_operators : ordered_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_ring_operators1<T, U> {}; template <class T, class B> struct ordered_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct field_operators : field_operators2<T, U, B> {}; template<class T, class U, class B> struct field_operators<T, U, B, ::boost::detail::true_t> : field_operators1<T, U> {}; template <class T, class B> struct field_operators<T, T, B, ::boost::detail::false_t> : field_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::field_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::field_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::field_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_field_operators : ordered_field_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_field_operators<T, U, B, ::boost::detail::true_t> : ordered_field_operators1<T, U> {}; template <class T, class B> struct ordered_field_operators<T, T, B, ::boost::detail::false_t> : ordered_field_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_field_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_field_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_field_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct euclidian_ring_operators : euclidian_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct euclidian_ring_operators<T, U, B, ::boost::detail::true_t> : euclidian_ring_operators1<T, U> {}; template <class T, class B> struct euclidian_ring_operators<T, T, B, ::boost::detail::false_t> : euclidian_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::euclidian_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::euclidian_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::euclidian_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_euclidian_ring_operators : ordered_euclidian_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_euclidian_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_euclidian_ring_operators1<T, U> {}; template <class T, class B> struct ordered_euclidian_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_euclidian_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_euclidian_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_euclidian_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_euclidian_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct euclidean_ring_operators : euclidean_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct euclidean_ring_operators<T, U, B, ::boost::detail::true_t> : euclidean_ring_operators1<T, U> {}; template <class T, class B> struct euclidean_ring_operators<T, T, B, ::boost::detail::false_t> : euclidean_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::euclidean_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::euclidean_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::euclidean_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_euclidean_ring_operators : ordered_euclidean_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_euclidean_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_euclidean_ring_operators1<T, U> {}; template <class T, class B> struct ordered_euclidean_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_euclidean_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_euclidean_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_euclidean_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_euclidean_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< ::boost::input_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
template<class T, class B> struct is_chained_base< ::boost::output_iteratable<T, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< ::boost::forward_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< ::boost::bidirectional_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
template<class T, class U, class V, class W, class B> struct is_chained_base< ::boost::random_access_iteratable<T, U, V, W, B> > { typedef ::boost::detail::true_t value; };
#undef BOOST_OPERATOR_TEMPLATE
#undef BOOST_OPERATOR_TEMPLATE4
#undef BOOST_OPERATOR_TEMPLATE3
#undef BOOST_OPERATOR_TEMPLATE2
#undef BOOST_OPERATOR_TEMPLATE1
#undef BOOST_IMPORT_TEMPLATE1
#undef BOOST_IMPORT_TEMPLATE2
#undef BOOST_IMPORT_TEMPLATE3
#undef BOOST_IMPORT_TEMPLATE4
template <class T, class U>
struct operators2
: totally_ordered2<T,U
, integer_arithmetic2<T,U
, bitwise2<T,U
> > > {};
template <class T, class U = T>
struct operators : operators2<T, U> {};
template <class T> struct operators<T, T>
: totally_ordered<T
, integer_arithmetic<T
, bitwise<T
, unit_steppable<T
> > > > {};
template <class T,
class V,
class D = std::ptrdiff_t,
class P = V const *,
class R = V const &>
struct input_iterator_helper
: input_iteratable<T, P
, boost::iterator<std::input_iterator_tag, V, D, P, R
> > {};
template<class T>
struct output_iterator_helper
: output_iteratable<T
, boost::iterator<std::output_iterator_tag, void, void, void, void
> >
{
T& operator*() ;
T& operator++() ;
};
template <class T,
class V,
class D = std::ptrdiff_t,
class P = V*,
class R = V&>
struct forward_iterator_helper
: forward_iteratable<T, P
, boost::iterator<std::forward_iterator_tag, V, D, P, R
> > {};
template <class T,
class V,
class D = std::ptrdiff_t,
class P = V*,
class R = V&>
struct bidirectional_iterator_helper
: bidirectional_iteratable<T, P
, boost::iterator<std::bidirectional_iterator_tag, V, D, P, R
> > {};
template <class T,
class V,
class D = std::ptrdiff_t,
class P = V*,
class R = V&>
struct random_access_iterator_helper
: random_access_iteratable<T, P, D, R
, boost::iterator<std::random_access_iterator_tag, V, D, P, R
> >
{
friend D requires_difference_operator(const T& x, const T& y) ;
};
}
#define BOOST_NONCOPYABLE_HPP_INCLUDED
namespace boost {
namespace noncopyable_
{
class noncopyable
{
protected:
constexpr noncopyable() = default;
~noncopyable() = default;
noncopyable( const noncopyable& ) = delete;
noncopyable& operator=( const noncopyable& ) = delete;
};
}
typedef noncopyable_::noncopyable noncopyable;
}
#define BOOST_UTILITY_ENABLE_IF_HPP
namespace boost
{
template <bool B, class T = void>
struct enable_if_c {
typedef T type;
};
template <class T>
struct enable_if_c<false, T> {};
template <class Cond, class T = void>
struct enable_if : public enable_if_c<Cond::value, T> {};
template <bool B, class T>
struct lazy_enable_if_c {
typedef typename T::type type;
};
template <class T>
struct lazy_enable_if_c<false, T> {};
template <class Cond, class T>
struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
template <bool B, class T = void>
struct disable_if_c {
typedef T type;
};
template <class T>
struct disable_if_c<true, T> {};
template <class Cond, class T = void>
struct disable_if : public disable_if_c<Cond::value, T> {};
template <bool B, class T>
struct lazy_disable_if_c {
typedef typename T::type type;
};
template <class T>
struct lazy_disable_if_c<true, T> {};
template <class Cond, class T>
struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
}
#define BOOST_CERRNO_HPP
#undef __need_error_t
#define BOOST_CONFIG_ABI_PREFIX_HPP
#define BOOST_SYSTEM_NOEXCEPT BOOST_NOEXCEPT
namespace boost
{
namespace system
{
class error_code;
class error_condition;
template< class T >
struct is_error_code_enum { static const bool value = false; };
template< class T >
struct is_error_condition_enum { static const bool value = false; };
namespace errc
{
enum errc_t
{
success = 0,
address_family_not_supported = 97,
address_in_use = 98,
address_not_available = 99,
already_connected = 106,
argument_list_too_long = 7,
argument_out_of_domain = 33,
bad_address = 14,
bad_file_descriptor = 9,
bad_message = 74,
broken_pipe = 32,
connection_aborted = 103,
connection_already_in_progress = 114,
connection_refused = 111,
connection_reset = 104,
cross_device_link = 18,
destination_address_required = 89,
device_or_resource_busy = 16,
directory_not_empty = 39,
executable_format_error = 8,
file_exists = 17,
file_too_large = 27,
filename_too_long = 36,
function_not_supported = 38,
host_unreachable = 113,
identifier_removed = 43,
illegal_byte_sequence = 84,
inappropriate_io_control_operation = 25,
interrupted = 4,
invalid_argument = 22,
invalid_seek = 29,
io_error = 5,
is_a_directory = 21,
message_size = 90,
network_down = 100,
network_reset = 102,
network_unreachable = 101,
no_buffer_space = 105,
no_child_process = 10,
no_link = 67,
no_lock_available = 37,
no_message_available = 61,
no_message = 42,
no_protocol_option = 92,
no_space_on_device = 28,
no_stream_resources = 63,
no_such_device_or_address = 6,
no_such_device = 19,
no_such_file_or_directory = 2,
no_such_process = 3,
not_a_directory = 20,
not_a_socket = 88,
not_a_stream = 60,
not_connected = 107,
not_enough_memory = 12,
not_supported = 95,
operation_canceled = 125,
operation_in_progress = 115,
operation_not_permitted = 1,
operation_not_supported = 95,
operation_would_block = 11,
owner_dead = 130,
permission_denied = 13,
protocol_error = 71,
protocol_not_supported = 93,
read_only_file_system = 30,
resource_deadlock_would_occur = 35,
resource_unavailable_try_again = 11,
result_out_of_range = 34,
state_not_recoverable = 131,
stream_timeout = 62,
text_file_busy = 26,
timed_out = 110,
too_many_files_open_in_system = 23,
too_many_files_open = 24,
too_many_links = 31,
too_many_symbolic_link_levels = 40,
value_too_large = 75,
wrong_protocol_type = 91
};
}
namespace posix = errc;
namespace posix_error = errc;
template<> struct is_error_condition_enum<errc::errc_t>
{ static const bool value = true; };
class error_category : public noncopyable
{
public:
virtual ~error_category();
virtual const char * name() const noexcept = 0;
virtual std::string message( int ev ) const = 0;
inline virtual error_condition default_error_condition( int ev ) const noexcept;
inline virtual bool equivalent( int code,
const error_condition & condition ) const noexcept;
inline virtual bool equivalent( const error_code & code,
int condition ) const noexcept;
bool operator==(const error_category & rhs) const noexcept { return this == &rhs; }
bool operator!=(const error_category & rhs) const noexcept { return this != &rhs; }
bool operator<( const error_category & rhs ) const noexcept
{
return std::less<const error_category*>()( this, &rhs );
}
};
const error_category & system_category() noexcept;
const error_category & generic_category() noexcept;
const error_category & get_system_category() ;
const error_category & get_generic_category() ;
const error_category & get_posix_category() ;
static const error_category & posix_category = generic_category();
static const error_category & errno_ecat = generic_category();
static const error_category & native_ecat = system_category();
class error_condition
{
public:
error_condition() noexcept : m_val(0), m_cat(&generic_category()) {}
error_condition( int val, const error_category & cat ) noexcept : m_val(val), m_cat(&cat) {}
template <class ErrorConditionEnum>
error_condition(ErrorConditionEnum e,
typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum> >::type* = 0) noexcept
{
*this = make_error_condition(e);
}
void assign( int val, const error_category & cat ) noexcept
{
m_val = val;
m_cat = &cat;
}
template<typename ErrorConditionEnum>
typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum>, error_condition>::type &
operator=( ErrorConditionEnum val ) noexcept
{
*this = make_error_condition(val);
return *this;
}
void clear() noexcept
{
m_val = 0;
m_cat = &generic_category();
}
int value() const noexcept { return m_val; }
const error_category & category() const noexcept { return *m_cat; }
std::string message() const { return m_cat->message(value()); }
typedef void (*unspecified_bool_type)();
static void unspecified_bool_true() ;
operator unspecified_bool_type() const noexcept
{
return m_val == 0 ? 0 : unspecified_bool_true;
}
bool operator!() const noexcept
{
return m_val == 0;
}
inline friend bool operator==( const error_condition & lhs,
const error_condition & rhs ) noexcept
{
return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
}
inline friend bool operator<( const error_condition & lhs,
const error_condition & rhs ) noexcept
{
return lhs.m_cat < rhs.m_cat
|| (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
}
private:
int m_val;
const error_category * m_cat;
};
class error_code
{
public:
error_code() noexcept : m_val(0), m_cat(&system_category()) {}
error_code( int val, const error_category & cat ) noexcept : m_val(val), m_cat(&cat) {}
template <class ErrorCodeEnum>
error_code(ErrorCodeEnum e,
typename boost::enable_if<is_error_code_enum<ErrorCodeEnum> >::type* = 0) noexcept
{
*this = make_error_code(e);
}
void assign( int val, const error_category & cat ) noexcept
{
m_val = val;
m_cat = &cat;
}
template<typename ErrorCodeEnum>
typename boost::enable_if<is_error_code_enum<ErrorCodeEnum>, error_code>::type &
operator=( ErrorCodeEnum val ) noexcept
{
*this = make_error_code(val);
return *this;
}
void clear() noexcept
{
m_val = 0;
m_cat = &system_category();
}
int value() const noexcept { return m_val; }
const error_category & category() const noexcept { return *m_cat; }
error_condition default_error_condition() const noexcept { return m_cat->default_error_condition(value()); }
std::string message() const { return m_cat->message(value()); }
typedef void (*unspecified_bool_type)();
static void unspecified_bool_true() ;
operator unspecified_bool_type() const noexcept
{
return m_val == 0 ? 0 : unspecified_bool_true;
}
bool operator!() const noexcept
{
return m_val == 0;
}
inline friend bool operator==( const error_code & lhs,
const error_code & rhs ) noexcept
{
return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
}
inline friend bool operator<( const error_code & lhs,
const error_code & rhs ) noexcept
{
return lhs.m_cat < rhs.m_cat
|| (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
}
private:
int m_val;
const error_category * m_cat;
};
extern error_code throws;
}
namespace detail { system::error_code * throws() ; }
system::error_code & throws()
;
namespace system
{
inline bool operator!=( const error_code & lhs,
const error_code & rhs ) noexcept
{
return !(lhs == rhs);
}
inline bool operator!=( const error_condition & lhs,
const error_condition & rhs ) noexcept
{
return !(lhs == rhs);
}
inline bool operator==( const error_code & code,
const error_condition & condition ) noexcept
{
return code.category().equivalent( code.value(), condition )
|| condition.category().equivalent( code, condition.value() );
}
inline bool operator!=( const error_code & lhs,
const error_condition & rhs ) noexcept
{
return !(lhs == rhs);
}
inline bool operator==( const error_condition & condition,
const error_code & code ) noexcept
{
return condition.category().equivalent( code, condition.value() )
|| code.category().equivalent( code.value(), condition );
}
inline bool operator!=( const error_condition & lhs,
const error_code & rhs ) noexcept
{
return !(lhs == rhs);
}
template <class charT, class traits>
inline std::basic_ostream<charT,traits>&
operator<< (std::basic_ostream<charT,traits>& os, error_code ec)
{
os << ec.category().name() << ':' << ec.value();
return os;
}
inline std::size_t hash_value( const error_code & ec )
{
return static_cast<std::size_t>(ec.value())
+ reinterpret_cast<std::size_t>(&ec.category());
}
namespace errc
{
inline error_code make_error_code( errc_t e ) noexcept
{ return error_code( e, generic_category() ); }
inline error_condition make_error_condition( errc_t e ) noexcept
{ return error_condition( e, generic_category() ); }
}
error_condition error_category::default_error_condition( int ev ) const noexcept
{
return error_condition( ev, *this );
}
bool error_category::equivalent( int code,
const error_condition & condition ) const noexcept
{
return default_error_condition( code ) == condition;
}
bool error_category::equivalent( const error_code & code,
int condition ) const noexcept
{
return *this == code.category() && code.value() == condition;
}
}
}
#undef BOOST_CONFIG_ABI_PREFIX_HPP
namespace boost {
namespace asio {
namespace detail {
inline void do_throw_error(const boost::system::error_code& err);
inline void do_throw_error(const boost::system::error_code& err,
const char* location);
void throw_error(const boost::system::error_code& err)
;
void throw_error(const boost::system::error_code& err,
const char* location)
;
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_THROW_ERROR_IPP
#define BOOST_ASIO_DETAIL_THROW_EXCEPTION_HPP
#define UUID_AA15E74A856F11E08B8D93F24824019B
#define UUID_61531AB0680611DEADD5846855D89593
#define BOOST_ATTRIBUTE_NORETURN __attribute__((__noreturn__))
#define UUID_274DA366004E11DCB1DDFE2E56D89593
namespace
boost
{
namespace
exception_detail
{
template <class T>
class
refcount_ptr
{
public:
refcount_ptr()
;
~refcount_ptr()
;
refcount_ptr( refcount_ptr const & x )
;
refcount_ptr &
operator=( refcount_ptr const & x )
;
void
adopt( T * px )
;
T *
get() const
;
private:
T * px_;
void
add_ref()
;
void
release()
;
};
}
template <class Tag,class T>
class error_info;
typedef error_info<struct throw_function_,char const *> throw_function;
typedef error_info<struct throw_file_,char const *> throw_file;
typedef error_info<struct throw_line_,int> throw_line;
template <>
class
error_info<throw_function_,char const *>
{
public:
typedef char const * value_type;
value_type v_;
explicit
error_info( value_type v )
;
};
template <>
class
error_info<throw_file_,char const *>
{
public:
typedef char const * value_type;
value_type v_;
explicit
error_info( value_type v )
;
};
template <>
class
error_info<throw_line_,int>
{
public:
typedef int value_type;
value_type v_;
explicit
error_info( value_type v )
;
};
#pragma GCC visibility push (default)
class exception;
#pragma GCC visibility pop
template <class T>
class shared_ptr;
namespace
exception_detail
{
class error_info_base;
struct type_info_;
struct
error_info_container
{
virtual char const * diagnostic_information( char const * ) const = 0;
virtual shared_ptr<error_info_base> get( type_info_ const & ) const = 0;
virtual void set( shared_ptr<error_info_base> const &, type_info_ const & ) = 0;
virtual void add_ref() const = 0;
virtual bool release() const = 0;
virtual refcount_ptr<exception_detail::error_info_container> clone() const = 0;
protected:
~error_info_container() throw()
;
};
template <class>
struct get_info;
template <>
struct get_info<throw_function>;
template <>
struct get_info<throw_file>;
template <>
struct get_info<throw_line>;
char const * get_diagnostic_information( exception const &, char const * );
void copy_boost_exception( exception *, exception const * );
template <class E,class Tag,class T>
E const & set_info( E const &, error_info<Tag,T> const & );
template <class E>
E const & set_info( E const &, throw_function const & );
template <class E>
E const & set_info( E const &, throw_file const & );
template <class E>
E const & set_info( E const &, throw_line const & );
}
#pragma GCC visibility push (default)
class
exception
{
protected:
exception()
;
virtual ~exception() throw()
= 0
;
private:
template <class E>
friend E const & exception_detail::set_info( E const &, throw_function const & );
template <class E>
friend E const & exception_detail::set_info( E const &, throw_file const & );
template <class E>
friend E const & exception_detail::set_info( E const &, throw_line const & );
template <class E,class Tag,class T>
friend E const & exception_detail::set_info( E const &, error_info<Tag,T> const & );
friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );
template <class>
friend struct exception_detail::get_info;
friend struct exception_detail::get_info<throw_function>;
friend struct exception_detail::get_info<throw_file>;
friend struct exception_detail::get_info<throw_line>;
friend void exception_detail::copy_boost_exception( exception *, exception const * );
mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
mutable char const * throw_function_;
mutable char const * throw_file_;
mutable int throw_line_;
};
#pragma GCC visibility pop
namespace
exception_detail
{
template <class E>
E const &
set_info( E const & x, throw_function const & y )
;
template <class E>
E const &
set_info( E const & x, throw_file const & y )
;
template <class E>
E const &
set_info( E const & x, throw_line const & y )
;
}
namespace
exception_detail
{
#pragma GCC visibility push (default)
template <class T>
struct
error_info_injector:
public T,
public exception
{
explicit
error_info_injector( T const & x )
;
~error_info_injector() throw()
;
};
#pragma GCC visibility pop
struct large_size { char c[256]; };
large_size dispatch_boost_exception( exception const * );
struct small_size { };
small_size dispatch_boost_exception( void const * );
template <class,int>
struct enable_error_info_helper;
template <class T>
struct
enable_error_info_helper<T,sizeof(large_size)>
{
typedef T type;
};
template <class T>
struct
enable_error_info_helper<T,sizeof(small_size)>
{
typedef error_info_injector<T> type;
};
template <class T>
struct
enable_error_info_return_type
{
typedef typename enable_error_info_helper<T,sizeof(exception_detail::dispatch_boost_exception(static_cast<T *>(0)))>::type type;
};
}
template <class T>
typename
exception_detail::enable_error_info_return_type<T>::type
enable_error_info( T const & x )
;
namespace
exception_detail
{
#pragma GCC visibility push (default)
class
clone_base
{
public:
virtual clone_base const * clone() const = 0;
virtual void rethrow() const = 0;
virtual
~clone_base() throw()
;
};
#pragma GCC visibility pop
void
copy_boost_exception( exception * a, exception const * b )
;
void
copy_boost_exception( void *, void const * )
;
template <class T>
class
clone_impl:
public T,
public virtual clone_base
{
struct clone_tag { };
clone_impl( clone_impl const & x, clone_tag )
;
public:
explicit
clone_impl( T const & x )
;
~clone_impl() throw()
;
private:
clone_base const *
clone() const
;
void
rethrow() const
;
};
}
template <class T>
exception_detail::clone_impl<T>
enable_current_exception( T const & x )
;
}
#define BOOST_CURRENT_FUNCTION_HPP_INCLUDED
namespace boost
{
namespace detail
{
void current_function_helper()
;
}
}
#define BOOST_THROW_EXCEPTION_CURRENT_FUNCTION BOOST_CURRENT_FUNCTION
#define BOOST_THROW_EXCEPTION(x) ::boost::exception_detail::throw_exception_(x,BOOST_THROW_EXCEPTION_CURRENT_FUNCTION,__FILE__,__LINE__)
namespace boost
{
void throw_exception_assert_compatibility( std::exception const & ) ;
template<class E> __attribute__((__noreturn__)) void throw_exception( E const & e )
;
namespace
exception_detail
{
template <class E>
__attribute__((__noreturn__))
void
throw_exception_( E const & x, char const * current_function, char const * file, int line )
;
}
}
namespace boost {
namespace asio {
namespace detail {
using boost::throw_exception;
}
}
}
#define BOOST_SYSTEM_ERROR_HPP
#undef _ASSERT_H
#undef assert
#undef __ASSERT_VOID_CAST
#undef assert_perror
#define _ASSERT_H 1
#define __ASSERT_VOID_CAST static_cast<void>
#define assert(expr) (__ASSERT_VOID_CAST (0))
#define assert_perror(errnum) (__ASSERT_VOID_CAST (0))
namespace boost
{
namespace system
{
class __attribute__((__visibility__("default"))) system_error : public std::runtime_error
{
public:
system_error( error_code ec ) ;
system_error( error_code ec, const std::string & what_arg ) ;
system_error( error_code ec, const char* what_arg ) ;
system_error( int ev, const error_category & ecat )
: std::runtime_error(""), m_error_code(ev,ecat) {}
system_error( int ev, const error_category & ecat,
const std::string & what_arg )
: std::runtime_error(what_arg), m_error_code(ev,ecat) {}
system_error( int ev, const error_category & ecat,
const char * what_arg )
: std::runtime_error(what_arg), m_error_code(ev,ecat) {}
virtual ~system_error() throw() ;
const error_code & code() const throw() ;
const char * what() const throw();
private:
error_code m_error_code;
mutable std::string m_what;
};
}
}
namespace boost {
namespace asio {
namespace detail {
void do_throw_error(const boost::system::error_code& err)
;
void do_throw_error(const boost::system::error_code& err, const char* location)
;
}
}
}
#define BOOST_ASIO_ERROR_HPP
#undef __need_error_t
#define _NETDB_H 1
#define _NETINET_IN_H 1
#define _SYS_SOCKET_H 1
extern "C" {
#define _SYS_UIO_H 1
extern "C" {
#define _BITS_UIO_H 1
#define UIO_MAXIOV 1024
struct iovec
{
void *iov_base;
size_t iov_len;
};
#define _BITS_UIO_H_FOR_SYS_UIO_H 1
extern "C" {
extern ssize_t process_vm_readv (pid_t __pid, const struct iovec *__lvec,
unsigned long int __liovcnt,
const struct iovec *__rvec,
unsigned long int __riovcnt,
unsigned long int __flags)
throw ();
extern ssize_t process_vm_writev (pid_t __pid, const struct iovec *__lvec,
unsigned long int __liovcnt,
const struct iovec *__rvec,
unsigned long int __riovcnt,
unsigned long int __flags)
throw ();
}
extern ssize_t readv (int __fd, const struct iovec *__iovec, int __count)
;
extern ssize_t writev (int __fd, const struct iovec *__iovec, int __count)
;
extern ssize_t preadv (int __fd, const struct iovec *__iovec, int __count,
__off_t __offset) ;
extern ssize_t pwritev (int __fd, const struct iovec *__iovec, int __count,
__off_t __offset) ;
extern ssize_t preadv64 (int __fd, const struct iovec *__iovec, int __count,
__off64_t __offset) ;
extern ssize_t pwritev64 (int __fd, const struct iovec *__iovec, int __count,
__off64_t __offset) ;
}
#define __need_size_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define __BITS_SOCKET_H
#define __need_size_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
enum __socket_type
{
SOCK_STREAM = 1,
#define SOCK_STREAM SOCK_STREAM
SOCK_DGRAM = 2,
#define SOCK_DGRAM SOCK_DGRAM
SOCK_RAW = 3,
#define SOCK_RAW SOCK_RAW
SOCK_RDM = 4,
#define SOCK_RDM SOCK_RDM
SOCK_SEQPACKET = 5,
#define SOCK_SEQPACKET SOCK_SEQPACKET
SOCK_DCCP = 6,
#define SOCK_DCCP SOCK_DCCP
SOCK_PACKET = 10,
#define SOCK_PACKET SOCK_PACKET
SOCK_CLOEXEC = 02000000,
#define SOCK_CLOEXEC SOCK_CLOEXEC
SOCK_NONBLOCK = 00004000
#define SOCK_NONBLOCK SOCK_NONBLOCK
};
#define PF_UNSPEC 0
#define PF_LOCAL 1
#define PF_UNIX PF_LOCAL
#define PF_FILE PF_LOCAL
#define PF_INET 2
#define PF_AX25 3
#define PF_IPX 4
#define PF_APPLETALK 5
#define PF_NETROM 6
#define PF_BRIDGE 7
#define PF_ATMPVC 8
#define PF_X25 9
#define PF_INET6 10
#define PF_ROSE 11
#define PF_DECnet 12
#define PF_NETBEUI 13
#define PF_SECURITY 14
#define PF_KEY 15
#define PF_NETLINK 16
#define PF_ROUTE PF_NETLINK
#define PF_PACKET 17
#define PF_ASH 18
#define PF_ECONET 19
#define PF_ATMSVC 20
#define PF_RDS 21
#define PF_SNA 22
#define PF_IRDA 23
#define PF_PPPOX 24
#define PF_WANPIPE 25
#define PF_LLC 26
#define PF_CAN 29
#define PF_TIPC 30
#define PF_BLUETOOTH 31
#define PF_IUCV 32
#define PF_RXRPC 33
#define PF_ISDN 34
#define PF_PHONET 35
#define PF_IEEE802154 36
#define PF_CAIF 37
#define PF_ALG 38
#define PF_NFC 39
#define PF_VSOCK 40
#define PF_MAX 41
#define AF_UNSPEC PF_UNSPEC
#define AF_LOCAL PF_LOCAL
#define AF_UNIX PF_UNIX
#define AF_FILE PF_FILE
#define AF_INET PF_INET
#define AF_AX25 PF_AX25
#define AF_IPX PF_IPX
#define AF_APPLETALK PF_APPLETALK
#define AF_NETROM PF_NETROM
#define AF_BRIDGE PF_BRIDGE
#define AF_ATMPVC PF_ATMPVC
#define AF_X25 PF_X25
#define AF_INET6 PF_INET6
#define AF_ROSE PF_ROSE
#define AF_DECnet PF_DECnet
#define AF_NETBEUI PF_NETBEUI
#define AF_SECURITY PF_SECURITY
#define AF_KEY PF_KEY
#define AF_NETLINK PF_NETLINK
#define AF_ROUTE PF_ROUTE
#define AF_PACKET PF_PACKET
#define AF_ASH PF_ASH
#define AF_ECONET PF_ECONET
#define AF_ATMSVC PF_ATMSVC
#define AF_RDS PF_RDS
#define AF_SNA PF_SNA
#define AF_IRDA PF_IRDA
#define AF_PPPOX PF_PPPOX
#define AF_WANPIPE PF_WANPIPE
#define AF_LLC PF_LLC
#define AF_CAN PF_CAN
#define AF_TIPC PF_TIPC
#define AF_BLUETOOTH PF_BLUETOOTH
#define AF_IUCV PF_IUCV
#define AF_RXRPC PF_RXRPC
#define AF_ISDN PF_ISDN
#define AF_PHONET PF_PHONET
#define AF_IEEE802154 PF_IEEE802154
#define AF_CAIF PF_CAIF
#define AF_ALG PF_ALG
#define AF_NFC PF_NFC
#define AF_VSOCK PF_VSOCK
#define AF_MAX PF_MAX
#define SOL_RAW 255
#define SOL_DECNET 261
#define SOL_X25 262
#define SOL_PACKET 263
#define SOL_ATM 264
#define SOL_AAL 265
#define SOL_IRDA 266
#define SOMAXCONN 128
#define _BITS_SOCKADDR_H 1
typedef unsigned short int sa_family_t;
#define __SOCKADDR_COMMON(sa_prefix) sa_family_t sa_prefix ##family
#define __SOCKADDR_COMMON_SIZE (sizeof (unsigned short int))
struct sockaddr
{
sa_family_t sa_family;
char sa_data[14];
};
#define __ss_aligntype unsigned long int
#define _SS_SIZE 128
#define _SS_PADSIZE (_SS_SIZE - (2 * sizeof (__ss_aligntype)))
struct sockaddr_storage
{
sa_family_t ss_family;
unsigned long int __ss_align;
char __ss_padding[(128 - (2 * sizeof (unsigned long int)))];
};
enum
{
MSG_OOB = 0x01,
#define MSG_OOB MSG_OOB
MSG_PEEK = 0x02,
#define MSG_PEEK MSG_PEEK
MSG_DONTROUTE = 0x04,
#define MSG_DONTROUTE MSG_DONTROUTE
MSG_TRYHARD = MSG_DONTROUTE,
#define MSG_TRYHARD MSG_DONTROUTE
MSG_CTRUNC = 0x08,
#define MSG_CTRUNC MSG_CTRUNC
MSG_PROXY = 0x10,
#define MSG_PROXY MSG_PROXY
MSG_TRUNC = 0x20,
#define MSG_TRUNC MSG_TRUNC
MSG_DONTWAIT = 0x40,
#define MSG_DONTWAIT MSG_DONTWAIT
MSG_EOR = 0x80,
#define MSG_EOR MSG_EOR
MSG_WAITALL = 0x100,
#define MSG_WAITALL MSG_WAITALL
MSG_FIN = 0x200,
#define MSG_FIN MSG_FIN
MSG_SYN = 0x400,
#define MSG_SYN MSG_SYN
MSG_CONFIRM = 0x800,
#define MSG_CONFIRM MSG_CONFIRM
MSG_RST = 0x1000,
#define MSG_RST MSG_RST
MSG_ERRQUEUE = 0x2000,
#define MSG_ERRQUEUE MSG_ERRQUEUE
MSG_NOSIGNAL = 0x4000,
#define MSG_NOSIGNAL MSG_NOSIGNAL
MSG_MORE = 0x8000,
#define MSG_MORE MSG_MORE
MSG_WAITFORONE = 0x10000,
#define MSG_WAITFORONE MSG_WAITFORONE
MSG_FASTOPEN = 0x20000000,
#define MSG_FASTOPEN MSG_FASTOPEN
MSG_CMSG_CLOEXEC = 0x40000000
#define MSG_CMSG_CLOEXEC MSG_CMSG_CLOEXEC
};
struct msghdr
{
void *msg_name;
socklen_t msg_namelen;
struct iovec *msg_iov;
size_t msg_iovlen;
void *msg_control;
size_t msg_controllen;
int msg_flags;
};
struct cmsghdr
{
size_t cmsg_len;
int cmsg_level;
int cmsg_type;
};
#define CMSG_DATA(cmsg) ((unsigned char *) ((struct cmsghdr *) (cmsg) + 1))
#define CMSG_NXTHDR(mhdr,cmsg) __cmsg_nxthdr (mhdr, cmsg)
#define CMSG_FIRSTHDR(mhdr) ((size_t) (mhdr)->msg_controllen >= sizeof (struct cmsghdr) ? (struct cmsghdr *) (mhdr)->msg_control : (struct cmsghdr *) 0)
#define CMSG_ALIGN(len) (((len) + sizeof (size_t) - 1) & (size_t) ~(sizeof (size_t) - 1))
#define CMSG_SPACE(len) (CMSG_ALIGN (len) + CMSG_ALIGN (sizeof (struct cmsghdr)))
#define CMSG_LEN(len) (CMSG_ALIGN (sizeof (struct cmsghdr)) + (len))
extern struct cmsghdr *__cmsg_nxthdr (struct msghdr *__mhdr,
struct cmsghdr *__cmsg) throw ();
enum
{
SCM_RIGHTS = 0x01
#define SCM_RIGHTS SCM_RIGHTS
, SCM_CREDENTIALS = 0x02
#define SCM_CREDENTIALS SCM_CREDENTIALS
};
struct ucred
{
pid_t pid;
uid_t uid;
gid_t gid;
};
#define __ASM_GENERIC_SOCKET_H
#define __ASM_GENERIC_SOCKIOS_H
#define FIOSETOWN 0x8901
#define SIOCSPGRP 0x8902
#define FIOGETOWN 0x8903
#define SIOCGPGRP 0x8904
#define SIOCATMARK 0x8905
#define SIOCGSTAMP 0x8906
#define SIOCGSTAMPNS 0x8907
#define SOL_SOCKET 1
#define SO_DEBUG 1
#define SO_REUSEADDR 2
#define SO_TYPE 3
#define SO_ERROR 4
#define SO_DONTROUTE 5
#define SO_BROADCAST 6
#define SO_SNDBUF 7
#define SO_RCVBUF 8
#define SO_SNDBUFFORCE 32
#define SO_RCVBUFFORCE 33
#define SO_KEEPALIVE 9
#define SO_OOBINLINE 10
#define SO_NO_CHECK 11
#define SO_PRIORITY 12
#define SO_LINGER 13
#define SO_BSDCOMPAT 14
#define SO_REUSEPORT 15
#define SO_PASSCRED 16
#define SO_PEERCRED 17
#define SO_RCVLOWAT 18
#define SO_SNDLOWAT 19
#define SO_RCVTIMEO 20
#define SO_SNDTIMEO 21
#define SO_SECURITY_AUTHENTICATION 22
#define SO_SECURITY_ENCRYPTION_TRANSPORT 23
#define SO_SECURITY_ENCRYPTION_NETWORK 24
#define SO_BINDTODEVICE 25
#define SO_ATTACH_FILTER 26
#define SO_DETACH_FILTER 27
#define SO_GET_FILTER SO_ATTACH_FILTER
#define SO_PEERNAME 28
#define SO_TIMESTAMP 29
#define SCM_TIMESTAMP SO_TIMESTAMP
#define SO_ACCEPTCONN 30
#define SO_PEERSEC 31
#define SO_PASSSEC 34
#define SO_TIMESTAMPNS 35
#define SCM_TIMESTAMPNS SO_TIMESTAMPNS
#define SO_MARK 36
#define SO_TIMESTAMPING 37
#define SCM_TIMESTAMPING SO_TIMESTAMPING
#define SO_PROTOCOL 38
#define SO_DOMAIN 39
#define SO_RXQ_OVFL 40
#define SO_WIFI_STATUS 41
#define SCM_WIFI_STATUS SO_WIFI_STATUS
#define SO_PEEK_OFF 42
#define SO_NOFCS 43
#define SO_LOCK_FILTER 44
#define SO_SELECT_ERR_QUEUE 45
#define SO_BUSY_POLL 46
#define SO_MAX_PACING_RATE 47
#define SO_BPF_EXTENSIONS 48
struct linger
{
int l_onoff;
int l_linger;
};
struct osockaddr
{
unsigned short int sa_family;
unsigned char sa_data[14];
};
enum
{
SHUT_RD = 0,
#define SHUT_RD SHUT_RD
SHUT_WR,
#define SHUT_WR SHUT_WR
SHUT_RDWR
#define SHUT_RDWR SHUT_RDWR
};
#define __SOCKADDR_ARG struct sockaddr *__restrict
#define __CONST_SOCKADDR_ARG const struct sockaddr *
struct mmsghdr
{
struct msghdr msg_hdr;
unsigned int msg_len;
};
extern int socket (int __domain, int __type, int __protocol) throw ();
extern int socketpair (int __domain, int __type, int __protocol,
int __fds[2]) throw ();
extern int bind (int __fd, const struct sockaddr * __addr, socklen_t __len)
throw ();
extern int getsockname (int __fd, struct sockaddr *__restrict __addr,
socklen_t *__restrict __len) throw ();
extern int connect (int __fd, const struct sockaddr * __addr, socklen_t __len);
extern int getpeername (int __fd, struct sockaddr *__restrict __addr,
socklen_t *__restrict __len) throw ();
extern ssize_t send (int __fd, const void *__buf, size_t __n, int __flags);
extern ssize_t recv (int __fd, void *__buf, size_t __n, int __flags);
extern ssize_t sendto (int __fd, const void *__buf, size_t __n,
int __flags, const struct sockaddr * __addr,
socklen_t __addr_len);
extern ssize_t recvfrom (int __fd, void *__restrict __buf, size_t __n,
int __flags, struct sockaddr *__restrict __addr,
socklen_t *__restrict __addr_len);
extern ssize_t sendmsg (int __fd, const struct msghdr *__message,
int __flags);
extern int sendmmsg (int __fd, struct mmsghdr *__vmessages,
unsigned int __vlen, int __flags);
extern ssize_t recvmsg (int __fd, struct msghdr *__message, int __flags);
extern int recvmmsg (int __fd, struct mmsghdr *__vmessages,
unsigned int __vlen, int __flags,
const struct timespec *__tmo);
extern int getsockopt (int __fd, int __level, int __optname,
void *__restrict __optval,
socklen_t *__restrict __optlen) throw ();
extern int setsockopt (int __fd, int __level, int __optname,
const void *__optval, socklen_t __optlen) throw ();
extern int listen (int __fd, int __n) throw ();
extern int accept (int __fd, struct sockaddr *__restrict __addr,
socklen_t *__restrict __addr_len);
extern int accept4 (int __fd, struct sockaddr *__restrict __addr,
socklen_t *__restrict __addr_len, int __flags);
extern int shutdown (int __fd, int __how) throw ();
extern int sockatmark (int __fd) throw ();
extern int isfdtype (int __fd, int __fdtype) throw ();
}
extern "C" {
typedef uint32_t in_addr_t;
struct in_addr
{
in_addr_t s_addr;
};
#define IP_OPTIONS 4
#define IP_HDRINCL 3
#define IP_TOS 1
#define IP_TTL 2
#define IP_RECVOPTS 6
#define IP_RECVRETOPTS IP_RETOPTS
#define IP_RETOPTS 7
#define IP_MULTICAST_IF 32
#define IP_MULTICAST_TTL 33
#define IP_MULTICAST_LOOP 34
#define IP_ADD_MEMBERSHIP 35
#define IP_DROP_MEMBERSHIP 36
#define IP_UNBLOCK_SOURCE 37
#define IP_BLOCK_SOURCE 38
#define IP_ADD_SOURCE_MEMBERSHIP 39
#define IP_DROP_SOURCE_MEMBERSHIP 40
#define IP_MSFILTER 41
#define MCAST_JOIN_GROUP 42
#define MCAST_BLOCK_SOURCE 43
#define MCAST_UNBLOCK_SOURCE 44
#define MCAST_LEAVE_GROUP 45
#define MCAST_JOIN_SOURCE_GROUP 46
#define MCAST_LEAVE_SOURCE_GROUP 47
#define MCAST_MSFILTER 48
#define IP_MULTICAST_ALL 49
#define IP_UNICAST_IF 50
#define MCAST_EXCLUDE 0
#define MCAST_INCLUDE 1
#define IP_ROUTER_ALERT 5
#define IP_PKTINFO 8
#define IP_PKTOPTIONS 9
#define IP_PMTUDISC 10
#define IP_MTU_DISCOVER 10
#define IP_RECVERR 11
#define IP_RECVTTL 12
#define IP_RECVTOS 13
#define IP_MTU 14
#define IP_FREEBIND 15
#define IP_IPSEC_POLICY 16
#define IP_XFRM_POLICY 17
#define IP_PASSSEC 18
#define IP_TRANSPARENT 19
#define IP_MULTICAST_ALL 49
#define IP_ORIGDSTADDR 20
#define IP_RECVORIGDSTADDR IP_ORIGDSTADDR
#define IP_MINTTL 21
#define IP_PMTUDISC_DONT 0
#define IP_PMTUDISC_WANT 1
#define IP_PMTUDISC_DO 2
#define IP_PMTUDISC_PROBE 3
#define SOL_IP 0
#define IP_DEFAULT_MULTICAST_TTL 1
#define IP_DEFAULT_MULTICAST_LOOP 1
#define IP_MAX_MEMBERSHIPS 20
struct ip_opts
{
struct in_addr ip_dst;
char ip_opts[40];
};
struct ip_mreqn
{
struct in_addr imr_multiaddr;
struct in_addr imr_address;
int imr_ifindex;
};
struct in_pktinfo
{
int ipi_ifindex;
struct in_addr ipi_spec_dst;
struct in_addr ipi_addr;
};
#define IPV6_ADDRFORM 1
#define IPV6_2292PKTINFO 2
#define IPV6_2292HOPOPTS 3
#define IPV6_2292DSTOPTS 4
#define IPV6_2292RTHDR 5
#define IPV6_2292PKTOPTIONS 6
#define IPV6_CHECKSUM 7
#define IPV6_2292HOPLIMIT 8
#define SCM_SRCRT IPV6_RXSRCRT
#define IPV6_NEXTHOP 9
#define IPV6_AUTHHDR 10
#define IPV6_UNICAST_HOPS 16
#define IPV6_MULTICAST_IF 17
#define IPV6_MULTICAST_HOPS 18
#define IPV6_MULTICAST_LOOP 19
#define IPV6_JOIN_GROUP 20
#define IPV6_LEAVE_GROUP 21
#define IPV6_ROUTER_ALERT 22
#define IPV6_MTU_DISCOVER 23
#define IPV6_MTU 24
#define IPV6_RECVERR 25
#define IPV6_V6ONLY 26
#define IPV6_JOIN_ANYCAST 27
#define IPV6_LEAVE_ANYCAST 28
#define IPV6_IPSEC_POLICY 34
#define IPV6_XFRM_POLICY 35
#define IPV6_RECVPKTINFO 49
#define IPV6_PKTINFO 50
#define IPV6_RECVHOPLIMIT 51
#define IPV6_HOPLIMIT 52
#define IPV6_RECVHOPOPTS 53
#define IPV6_HOPOPTS 54
#define IPV6_RTHDRDSTOPTS 55
#define IPV6_RECVRTHDR 56
#define IPV6_RTHDR 57
#define IPV6_RECVDSTOPTS 58
#define IPV6_DSTOPTS 59
#define IPV6_RECVTCLASS 66
#define IPV6_TCLASS 67
#define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
#define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP
#define IPV6_RXHOPOPTS IPV6_HOPOPTS
#define IPV6_RXDSTOPTS IPV6_DSTOPTS
#define IPV6_PMTUDISC_DONT 0
#define IPV6_PMTUDISC_WANT 1
#define IPV6_PMTUDISC_DO 2
#define IPV6_PMTUDISC_PROBE 3
#define SOL_IPV6 41
#define SOL_ICMPV6 58
#define IPV6_RTHDR_LOOSE 0
#define IPV6_RTHDR_STRICT 1
#define IPV6_RTHDR_TYPE_0 0
enum
{
IPPROTO_IP = 0,
#define IPPROTO_IP IPPROTO_IP
IPPROTO_ICMP = 1,
#define IPPROTO_ICMP IPPROTO_ICMP
IPPROTO_IGMP = 2,
#define IPPROTO_IGMP IPPROTO_IGMP
IPPROTO_IPIP = 4,
#define IPPROTO_IPIP IPPROTO_IPIP
IPPROTO_TCP = 6,
#define IPPROTO_TCP IPPROTO_TCP
IPPROTO_EGP = 8,
#define IPPROTO_EGP IPPROTO_EGP
IPPROTO_PUP = 12,
#define IPPROTO_PUP IPPROTO_PUP
IPPROTO_UDP = 17,
#define IPPROTO_UDP IPPROTO_UDP
IPPROTO_IDP = 22,
#define IPPROTO_IDP IPPROTO_IDP
IPPROTO_TP = 29,
#define IPPROTO_TP IPPROTO_TP
IPPROTO_DCCP = 33,
#define IPPROTO_DCCP IPPROTO_DCCP
IPPROTO_IPV6 = 41,
#define IPPROTO_IPV6 IPPROTO_IPV6
IPPROTO_RSVP = 46,
#define IPPROTO_RSVP IPPROTO_RSVP
IPPROTO_GRE = 47,
#define IPPROTO_GRE IPPROTO_GRE
IPPROTO_ESP = 50,
#define IPPROTO_ESP IPPROTO_ESP
IPPROTO_AH = 51,
#define IPPROTO_AH IPPROTO_AH
IPPROTO_MTP = 92,
#define IPPROTO_MTP IPPROTO_MTP
IPPROTO_BEETPH = 94,
#define IPPROTO_BEETPH IPPROTO_BEETPH
IPPROTO_ENCAP = 98,
#define IPPROTO_ENCAP IPPROTO_ENCAP
IPPROTO_PIM = 103,
#define IPPROTO_PIM IPPROTO_PIM
IPPROTO_COMP = 108,
#define IPPROTO_COMP IPPROTO_COMP
IPPROTO_SCTP = 132,
#define IPPROTO_SCTP IPPROTO_SCTP
IPPROTO_UDPLITE = 136,
#define IPPROTO_UDPLITE IPPROTO_UDPLITE
IPPROTO_RAW = 255,
#define IPPROTO_RAW IPPROTO_RAW
IPPROTO_MAX
};
enum
{
IPPROTO_HOPOPTS = 0,
#define IPPROTO_HOPOPTS IPPROTO_HOPOPTS
IPPROTO_ROUTING = 43,
#define IPPROTO_ROUTING IPPROTO_ROUTING
IPPROTO_FRAGMENT = 44,
#define IPPROTO_FRAGMENT IPPROTO_FRAGMENT
IPPROTO_ICMPV6 = 58,
#define IPPROTO_ICMPV6 IPPROTO_ICMPV6
IPPROTO_NONE = 59,
#define IPPROTO_NONE IPPROTO_NONE
IPPROTO_DSTOPTS = 60,
#define IPPROTO_DSTOPTS IPPROTO_DSTOPTS
IPPROTO_MH = 135
#define IPPROTO_MH IPPROTO_MH
};
typedef uint16_t in_port_t;
enum
{
IPPORT_ECHO = 7,
IPPORT_DISCARD = 9,
IPPORT_SYSTAT = 11,
IPPORT_DAYTIME = 13,
IPPORT_NETSTAT = 15,
IPPORT_FTP = 21,
IPPORT_TELNET = 23,
IPPORT_SMTP = 25,
IPPORT_TIMESERVER = 37,
IPPORT_NAMESERVER = 42,
IPPORT_WHOIS = 43,
IPPORT_MTP = 57,
IPPORT_TFTP = 69,
IPPORT_RJE = 77,
IPPORT_FINGER = 79,
IPPORT_TTYLINK = 87,
IPPORT_SUPDUP = 95,
IPPORT_EXECSERVER = 512,
IPPORT_LOGINSERVER = 513,
IPPORT_CMDSERVER = 514,
IPPORT_EFSSERVER = 520,
IPPORT_BIFFUDP = 512,
IPPORT_WHOSERVER = 513,
IPPORT_ROUTESERVER = 520,
IPPORT_RESERVED = 1024,
IPPORT_USERRESERVED = 5000
};
#define IN_CLASSA(a) ((((in_addr_t)(a)) & 0x80000000) == 0)
#define IN_CLASSA_NET 0xff000000
#define IN_CLASSA_NSHIFT 24
#define IN_CLASSA_HOST (0xffffffff & ~IN_CLASSA_NET)
#define IN_CLASSA_MAX 128
#define IN_CLASSB(a) ((((in_addr_t)(a)) & 0xc0000000) == 0x80000000)
#define IN_CLASSB_NET 0xffff0000
#define IN_CLASSB_NSHIFT 16
#define IN_CLASSB_HOST (0xffffffff & ~IN_CLASSB_NET)
#define IN_CLASSB_MAX 65536
#define IN_CLASSC(a) ((((in_addr_t)(a)) & 0xe0000000) == 0xc0000000)
#define IN_CLASSC_NET 0xffffff00
#define IN_CLASSC_NSHIFT 8
#define IN_CLASSC_HOST (0xffffffff & ~IN_CLASSC_NET)
#define IN_CLASSD(a) ((((in_addr_t)(a)) & 0xf0000000) == 0xe0000000)
#define IN_MULTICAST(a) IN_CLASSD(a)
#define IN_EXPERIMENTAL(a) ((((in_addr_t)(a)) & 0xe0000000) == 0xe0000000)
#define IN_BADCLASS(a) ((((in_addr_t)(a)) & 0xf0000000) == 0xf0000000)
#define INADDR_ANY ((in_addr_t) 0x00000000)
#define INADDR_BROADCAST ((in_addr_t) 0xffffffff)
#define INADDR_NONE ((in_addr_t) 0xffffffff)
#define IN_LOOPBACKNET 127
#define INADDR_LOOPBACK ((in_addr_t) 0x7f000001)
#define INADDR_UNSPEC_GROUP ((in_addr_t) 0xe0000000)
#define INADDR_ALLHOSTS_GROUP ((in_addr_t) 0xe0000001)
#define INADDR_ALLRTRS_GROUP ((in_addr_t) 0xe0000002)
#define INADDR_MAX_LOCAL_GROUP ((in_addr_t) 0xe00000ff)
struct in6_addr
{
union
{
uint8_t __u6_addr8[16];
uint16_t __u6_addr16[8];
uint32_t __u6_addr32[4];
} __in6_u;
#define s6_addr __in6_u.__u6_addr8
#define s6_addr16 __in6_u.__u6_addr16
#define s6_addr32 __in6_u.__u6_addr32
};
extern const struct in6_addr in6addr_any;
extern const struct in6_addr in6addr_loopback;
#define IN6ADDR_ANY_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } } }
#define IN6ADDR_LOOPBACK_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 } } }
#define INET_ADDRSTRLEN 16
#define INET6_ADDRSTRLEN 46
struct sockaddr_in
{
sa_family_t sin_family;
in_port_t sin_port;
struct in_addr sin_addr;
unsigned char sin_zero[sizeof (struct sockaddr) -
(sizeof (unsigned short int)) -
sizeof (in_port_t) -
sizeof (struct in_addr)];
};
struct sockaddr_in6
{
sa_family_t sin6_family;
in_port_t sin6_port;
uint32_t sin6_flowinfo;
struct in6_addr sin6_addr;
uint32_t sin6_scope_id;
};
struct ip_mreq
{
struct in_addr imr_multiaddr;
struct in_addr imr_interface;
};
struct ip_mreq_source
{
struct in_addr imr_multiaddr;
struct in_addr imr_interface;
struct in_addr imr_sourceaddr;
};
struct ipv6_mreq
{
struct in6_addr ipv6mr_multiaddr;
unsigned int ipv6mr_interface;
};
struct group_req
{
uint32_t gr_interface;
struct sockaddr_storage gr_group;
};
struct group_source_req
{
uint32_t gsr_interface;
struct sockaddr_storage gsr_group;
struct sockaddr_storage gsr_source;
};
struct ip_msfilter
{
struct in_addr imsf_multiaddr;
struct in_addr imsf_interface;
uint32_t imsf_fmode;
uint32_t imsf_numsrc;
struct in_addr imsf_slist[1];
};
#define IP_MSFILTER_SIZE(numsrc) (sizeof (struct ip_msfilter) - sizeof (struct in_addr) + (numsrc) * sizeof (struct in_addr))
struct group_filter
{
uint32_t gf_interface;
struct sockaddr_storage gf_group;
uint32_t gf_fmode;
uint32_t gf_numsrc;
struct sockaddr_storage gf_slist[1];
};
#define GROUP_FILTER_SIZE(numsrc) (sizeof (struct group_filter) - sizeof (struct sockaddr_storage) + ((numsrc) * sizeof (struct sockaddr_storage)))
extern uint32_t ntohl (uint32_t __netlong) throw () __attribute__ ((__const__));
extern uint16_t ntohs (uint16_t __netshort)
throw () __attribute__ ((__const__));
extern uint32_t htonl (uint32_t __hostlong)
throw () __attribute__ ((__const__));
extern uint16_t htons (uint16_t __hostshort)
throw () __attribute__ ((__const__));
#define IN6_IS_ADDR_UNSPECIFIED(a) (__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); __a->s6_addr32[0] == 0 && __a->s6_addr32[1] == 0 && __a->s6_addr32[2] == 0 && __a->s6_addr32[3] == 0; }))
#define IN6_IS_ADDR_LOOPBACK(a) (__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); __a->s6_addr32[0] == 0 && __a->s6_addr32[1] == 0 && __a->s6_addr32[2] == 0 && __a->s6_addr32[3] == htonl (1); }))
#define IN6_IS_ADDR_LINKLOCAL(a) (__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); (__a->s6_addr32[0] & htonl (0xffc00000)) == htonl (0xfe800000); }))
#define IN6_IS_ADDR_SITELOCAL(a) (__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); (__a->s6_addr32[0] & htonl (0xffc00000)) == htonl (0xfec00000); }))
#define IN6_IS_ADDR_V4MAPPED(a) (__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); __a->s6_addr32[0] == 0 && __a->s6_addr32[1] == 0 && __a->s6_addr32[2] == htonl (0xffff); }))
#define IN6_IS_ADDR_V4COMPAT(a) (__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); __a->s6_addr32[0] == 0 && __a->s6_addr32[1] == 0 && __a->s6_addr32[2] == 0 && ntohl (__a->s6_addr32[3]) > 1; }))
#define IN6_ARE_ADDR_EQUAL(a,b) (__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); const struct in6_addr *__b = (const struct in6_addr *) (b); __a->s6_addr32[0] == __b->s6_addr32[0] && __a->s6_addr32[1] == __b->s6_addr32[1] && __a->s6_addr32[2] == __b->s6_addr32[2] && __a->s6_addr32[3] == __b->s6_addr32[3]; }))
#define IN6_IS_ADDR_MULTICAST(a) (((const uint8_t *) (a))[0] == 0xff)
extern int bindresvport (int __sockfd, struct sockaddr_in *__sock_in) throw ();
extern int bindresvport6 (int __sockfd, struct sockaddr_in6 *__sock_in)
throw ();
#define IN6_IS_ADDR_MC_NODELOCAL(a) (IN6_IS_ADDR_MULTICAST(a) && ((((const uint8_t *) (a))[1] & 0xf) == 0x1))
#define IN6_IS_ADDR_MC_LINKLOCAL(a) (IN6_IS_ADDR_MULTICAST(a) && ((((const uint8_t *) (a))[1] & 0xf) == 0x2))
#define IN6_IS_ADDR_MC_SITELOCAL(a) (IN6_IS_ADDR_MULTICAST(a) && ((((const uint8_t *) (a))[1] & 0xf) == 0x5))
#define IN6_IS_ADDR_MC_ORGLOCAL(a) (IN6_IS_ADDR_MULTICAST(a) && ((((const uint8_t *) (a))[1] & 0xf) == 0x8))
#define IN6_IS_ADDR_MC_GLOBAL(a) (IN6_IS_ADDR_MULTICAST(a) && ((((const uint8_t *) (a))[1] & 0xf) == 0xe))
struct cmsghdr;
struct in6_pktinfo
{
struct in6_addr ipi6_addr;
unsigned int ipi6_ifindex;
};
struct ip6_mtuinfo
{
struct sockaddr_in6 ip6m_addr;
uint32_t ip6m_mtu;
};
extern int inet6_option_space (int __nbytes)
throw () __attribute__ ((__deprecated__));
extern int inet6_option_init (void *__bp, struct cmsghdr **__cmsgp,
int __type) throw () __attribute__ ((__deprecated__));
extern int inet6_option_append (struct cmsghdr *__cmsg,
const uint8_t *__typep, int __multx,
int __plusy) throw () __attribute__ ((__deprecated__));
extern uint8_t *inet6_option_alloc (struct cmsghdr *__cmsg, int __datalen,
int __multx, int __plusy)
throw () __attribute__ ((__deprecated__));
extern int inet6_option_next (const struct cmsghdr *__cmsg,
uint8_t **__tptrp)
throw () __attribute__ ((__deprecated__));
extern int inet6_option_find (const struct cmsghdr *__cmsg,
uint8_t **__tptrp, int __type)
throw () __attribute__ ((__deprecated__));
extern int inet6_opt_init (void *__extbuf, socklen_t __extlen) throw ();
extern int inet6_opt_append (void *__extbuf, socklen_t __extlen, int __offset,
uint8_t __type, socklen_t __len, uint8_t __align,
void **__databufp) throw ();
extern int inet6_opt_finish (void *__extbuf, socklen_t __extlen, int __offset)
throw ();
extern int inet6_opt_set_val (void *__databuf, int __offset, void *__val,
socklen_t __vallen) throw ();
extern int inet6_opt_next (void *__extbuf, socklen_t __extlen, int __offset,
uint8_t *__typep, socklen_t *__lenp,
void **__databufp) throw ();
extern int inet6_opt_find (void *__extbuf, socklen_t __extlen, int __offset,
uint8_t __type, socklen_t *__lenp,
void **__databufp) throw ();
extern int inet6_opt_get_val (void *__databuf, int __offset, void *__val,
socklen_t __vallen) throw ();
extern socklen_t inet6_rth_space (int __type, int __segments) throw ();
extern void *inet6_rth_init (void *__bp, socklen_t __bp_len, int __type,
int __segments) throw ();
extern int inet6_rth_add (void *__bp, const struct in6_addr *__addr) throw ();
extern int inet6_rth_reverse (const void *__in, void *__out) throw ();
extern int inet6_rth_segments (const void *__bp) throw ();
extern struct in6_addr *inet6_rth_getaddr (const void *__bp, int __index)
throw ();
extern int getipv4sourcefilter (int __s, struct in_addr __interface_addr,
struct in_addr __group, uint32_t *__fmode,
uint32_t *__numsrc, struct in_addr *__slist)
throw ();
extern int setipv4sourcefilter (int __s, struct in_addr __interface_addr,
struct in_addr __group, uint32_t __fmode,
uint32_t __numsrc,
const struct in_addr *__slist)
throw ();
extern int getsourcefilter (int __s, uint32_t __interface_addr,
const struct sockaddr *__group,
socklen_t __grouplen, uint32_t *__fmode,
uint32_t *__numsrc,
struct sockaddr_storage *__slist) throw ();
extern int setsourcefilter (int __s, uint32_t __interface_addr,
const struct sockaddr *__group,
socklen_t __grouplen, uint32_t __fmode,
uint32_t __numsrc,
const struct sockaddr_storage *__slist) throw ();
}
#define _RPC_NETDB_H 1
#define __need_size_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
extern "C" {
struct rpcent
{
char *r_name;
char **r_aliases;
int r_number;
};
extern void setrpcent (int __stayopen) throw ();
extern void endrpcent (void) throw ();
extern struct rpcent *getrpcbyname (const char *__name) throw ();
extern struct rpcent *getrpcbynumber (int __number) throw ();
extern struct rpcent *getrpcent (void) throw ();
extern int getrpcbyname_r (const char *__name, struct rpcent *__result_buf,
char *__buffer, size_t __buflen,
struct rpcent **__result) throw ();
extern int getrpcbynumber_r (int __number, struct rpcent *__result_buf,
char *__buffer, size_t __buflen,
struct rpcent **__result) throw ();
extern int getrpcent_r (struct rpcent *__result_buf, char *__buffer,
size_t __buflen, struct rpcent **__result) throw ();
}
#define __need_sigevent_t
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
#define __have_sigval_t 1
typedef union sigval
{
int sival_int;
void *sival_ptr;
} sigval_t;
#define __have_sigevent_t 1
#define __SIGEV_MAX_SIZE 64
#define __SIGEV_PAD_SIZE ((__SIGEV_MAX_SIZE / sizeof (int)) - 4)
typedef struct sigevent
{
sigval_t sigev_value;
int sigev_signo;
int sigev_notify;
union
{
int _pad[((64 / sizeof (int)) - 4)];
__pid_t _tid;
struct
{
void (*_function) (sigval_t);
pthread_attr_t *_attribute;
} _sigev_thread;
} _sigev_un;
} sigevent_t;
#define sigev_notify_function _sigev_un._sigev_thread._function
#define sigev_notify_attributes _sigev_un._sigev_thread._attribute
enum
{
SIGEV_SIGNAL = 0,
#define SIGEV_SIGNAL SIGEV_SIGNAL
SIGEV_NONE,
#define SIGEV_NONE SIGEV_NONE
SIGEV_THREAD,
#define SIGEV_THREAD SIGEV_THREAD
SIGEV_THREAD_ID = 4
#define SIGEV_THREAD_ID SIGEV_THREAD_ID
};
#define __need_timespec
struct netent
{
char *n_name;
char **n_aliases;
int n_addrtype;
uint32_t n_net;
};
#define _PATH_HEQUIV "/etc/hosts.equiv"
#define _PATH_HOSTS "/etc/hosts"
#define _PATH_NETWORKS "/etc/networks"
#define _PATH_NSSWITCH_CONF "/etc/nsswitch.conf"
#define _PATH_PROTOCOLS "/etc/protocols"
#define _PATH_SERVICES "/etc/services"
extern "C" {
#define h_errno (*__h_errno_location ())
extern int *__h_errno_location (void) throw () __attribute__ ((__const__));
#define HOST_NOT_FOUND 1
#define TRY_AGAIN 2
#define NO_RECOVERY 3
#define NO_DATA 4
#define NETDB_INTERNAL -1
#define NETDB_SUCCESS 0
#define NO_ADDRESS NO_DATA
#define IPPORT_RESERVED 1024
#define SCOPE_DELIMITER '%'
extern void herror (const char *__str) throw ();
extern const char *hstrerror (int __err_num) throw ();
struct hostent
{
char *h_name;
char **h_aliases;
int h_addrtype;
int h_length;
char **h_addr_list;
#define h_addr h_addr_list[0]
};
extern void sethostent (int __stay_open);
extern void endhostent (void);
extern struct hostent *gethostent (void);
extern struct hostent *gethostbyaddr (const void *__addr, __socklen_t __len,
int __type);
extern struct hostent *gethostbyname (const char *__name);
extern struct hostent *gethostbyname2 (const char *__name, int __af);
extern int gethostent_r (struct hostent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct hostent **__restrict __result,
int *__restrict __h_errnop);
extern int gethostbyaddr_r (const void *__restrict __addr, __socklen_t __len,
int __type,
struct hostent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct hostent **__restrict __result,
int *__restrict __h_errnop);
extern int gethostbyname_r (const char *__restrict __name,
struct hostent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct hostent **__restrict __result,
int *__restrict __h_errnop);
extern int gethostbyname2_r (const char *__restrict __name, int __af,
struct hostent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct hostent **__restrict __result,
int *__restrict __h_errnop);
extern void setnetent (int __stay_open);
extern void endnetent (void);
extern struct netent *getnetent (void);
extern struct netent *getnetbyaddr (uint32_t __net, int __type);
extern struct netent *getnetbyname (const char *__name);
extern int getnetent_r (struct netent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct netent **__restrict __result,
int *__restrict __h_errnop);
extern int getnetbyaddr_r (uint32_t __net, int __type,
struct netent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct netent **__restrict __result,
int *__restrict __h_errnop);
extern int getnetbyname_r (const char *__restrict __name,
struct netent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct netent **__restrict __result,
int *__restrict __h_errnop);
struct servent
{
char *s_name;
char **s_aliases;
int s_port;
char *s_proto;
};
extern void setservent (int __stay_open);
extern void endservent (void);
extern struct servent *getservent (void);
extern struct servent *getservbyname (const char *__name, const char *__proto);
extern struct servent *getservbyport (int __port, const char *__proto);
extern int getservent_r (struct servent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct servent **__restrict __result);
extern int getservbyname_r (const char *__restrict __name,
const char *__restrict __proto,
struct servent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct servent **__restrict __result);
extern int getservbyport_r (int __port, const char *__restrict __proto,
struct servent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct servent **__restrict __result);
struct protoent
{
char *p_name;
char **p_aliases;
int p_proto;
};
extern void setprotoent (int __stay_open);
extern void endprotoent (void);
extern struct protoent *getprotoent (void);
extern struct protoent *getprotobyname (const char *__name);
extern struct protoent *getprotobynumber (int __proto);
extern int getprotoent_r (struct protoent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct protoent **__restrict __result);
extern int getprotobyname_r (const char *__restrict __name,
struct protoent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct protoent **__restrict __result);
extern int getprotobynumber_r (int __proto,
struct protoent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct protoent **__restrict __result);
extern int setnetgrent (const char *__netgroup);
extern void endnetgrent (void);
extern int getnetgrent (char **__restrict __hostp,
char **__restrict __userp,
char **__restrict __domainp);
extern int innetgr (const char *__netgroup, const char *__host,
const char *__user, const char *__domain);
extern int getnetgrent_r (char **__restrict __hostp,
char **__restrict __userp,
char **__restrict __domainp,
char *__restrict __buffer, size_t __buflen);
extern int rcmd (char **__restrict __ahost, unsigned short int __rport,
const char *__restrict __locuser,
const char *__restrict __remuser,
const char *__restrict __cmd, int *__restrict __fd2p);
extern int rcmd_af (char **__restrict __ahost, unsigned short int __rport,
const char *__restrict __locuser,
const char *__restrict __remuser,
const char *__restrict __cmd, int *__restrict __fd2p,
sa_family_t __af);
extern int rexec (char **__restrict __ahost, int __rport,
const char *__restrict __name,
const char *__restrict __pass,
const char *__restrict __cmd, int *__restrict __fd2p);
extern int rexec_af (char **__restrict __ahost, int __rport,
const char *__restrict __name,
const char *__restrict __pass,
const char *__restrict __cmd, int *__restrict __fd2p,
sa_family_t __af);
extern int ruserok (const char *__rhost, int __suser,
const char *__remuser, const char *__locuser);
extern int ruserok_af (const char *__rhost, int __suser,
const char *__remuser, const char *__locuser,
sa_family_t __af);
extern int iruserok (uint32_t __raddr, int __suser,
const char *__remuser, const char *__locuser);
extern int iruserok_af (const void *__raddr, int __suser,
const char *__remuser, const char *__locuser,
sa_family_t __af);
extern int rresvport (int *__alport);
extern int rresvport_af (int *__alport, sa_family_t __af);
struct addrinfo
{
int ai_flags;
int ai_family;
int ai_socktype;
int ai_protocol;
socklen_t ai_addrlen;
struct sockaddr *ai_addr;
char *ai_canonname;
struct addrinfo *ai_next;
};
struct gaicb
{
const char *ar_name;
const char *ar_service;
const struct addrinfo *ar_request;
struct addrinfo *ar_result;
int __return;
int __glibc_reserved[5];
};
#define GAI_WAIT 0
#define GAI_NOWAIT 1
#define AI_PASSIVE 0x0001
#define AI_CANONNAME 0x0002
#define AI_NUMERICHOST 0x0004
#define AI_V4MAPPED 0x0008
#define AI_ALL 0x0010
#define AI_ADDRCONFIG 0x0020
#define AI_IDN 0x0040
#define AI_CANONIDN 0x0080
#define AI_IDN_ALLOW_UNASSIGNED 0x0100
#define AI_IDN_USE_STD3_ASCII_RULES 0x0200
#define AI_NUMERICSERV 0x0400
#define EAI_BADFLAGS -1
#define EAI_NONAME -2
#define EAI_AGAIN -3
#define EAI_FAIL -4
#define EAI_FAMILY -6
#define EAI_SOCKTYPE -7
#define EAI_SERVICE -8
#define EAI_MEMORY -10
#define EAI_SYSTEM -11
#define EAI_OVERFLOW -12
#define EAI_NODATA -5
#define EAI_ADDRFAMILY -9
#define EAI_INPROGRESS -100
#define EAI_CANCELED -101
#define EAI_NOTCANCELED -102
#define EAI_ALLDONE -103
#define EAI_INTR -104
#define EAI_IDN_ENCODE -105
#define NI_MAXHOST 1025
#define NI_MAXSERV 32
#define NI_NUMERICHOST 1
#define NI_NUMERICSERV 2
#define NI_NOFQDN 4
#define NI_NAMEREQD 8
#define NI_DGRAM 16
#define NI_IDN 32
#define NI_IDN_ALLOW_UNASSIGNED 64
#define NI_IDN_USE_STD3_ASCII_RULES 128
extern int getaddrinfo (const char *__restrict __name,
const char *__restrict __service,
const struct addrinfo *__restrict __req,
struct addrinfo **__restrict __pai);
extern void freeaddrinfo (struct addrinfo *__ai) throw ();
extern const char *gai_strerror (int __ecode) throw ();
extern int getnameinfo (const struct sockaddr *__restrict __sa,
socklen_t __salen, char *__restrict __host,
socklen_t __hostlen, char *__restrict __serv,
socklen_t __servlen, int __flags);
extern int getaddrinfo_a (int __mode, struct gaicb *__list[],
int __ent, struct sigevent *__restrict __sig);
extern int gai_suspend (const struct gaicb *const __list[], int __ent,
const struct timespec *__timeout);
extern int gai_error (struct gaicb *__req) throw ();
extern int gai_cancel (struct gaicb *__gaicbp) throw ();
}
#define BOOST_ASIO_NATIVE_ERROR(e) e
#define BOOST_ASIO_SOCKET_ERROR(e) e
#define BOOST_ASIO_NETDB_ERROR(e) e
#define BOOST_ASIO_GETADDRINFO_ERROR(e) e
#define BOOST_ASIO_WIN_OR_POSIX(e_win,e_posix) e_posix
namespace boost {
namespace asio {
namespace error {
enum basic_errors
{
access_denied = 13,
address_family_not_supported = 97,
address_in_use = 98,
already_connected = 106,
already_started = 114,
broken_pipe = 32,
connection_aborted = 103,
connection_refused = 111,
connection_reset = 104,
bad_descriptor = 9,
fault = 14,
host_unreachable = 113,
in_progress = 115,
interrupted = 4,
invalid_argument = 22,
message_size = 90,
name_too_long = 36,
network_down = 100,
network_reset = 102,
network_unreachable = 101,
no_descriptors = 24,
no_buffer_space = 105,
no_memory = 12,
no_permission = 1,
no_protocol_option = 92,
not_connected = 107,
not_socket = 88,
operation_aborted = 125,
operation_not_supported = 95,
shut_down = 108,
timed_out = 110,
try_again = 11,
would_block = 11
};
enum netdb_errors
{
host_not_found = 1,
host_not_found_try_again = 2,
no_data = 4,
no_recovery = 3
};
enum addrinfo_errors
{
service_not_found = -8,
socket_type_not_supported = -7
};
enum misc_errors
{
already_open = 1,
eof,
not_found,
fd_set_failure
};
const boost::system::error_category& get_system_category()
;
extern inline
const boost::system::error_category& get_netdb_category();
extern inline
const boost::system::error_category& get_addrinfo_category();
extern inline
const boost::system::error_category& get_misc_category();
static const boost::system::error_category& system_category
= boost::asio::error::get_system_category();
static const boost::system::error_category& netdb_category
= boost::asio::error::get_netdb_category();
static const boost::system::error_category& addrinfo_category
= boost::asio::error::get_addrinfo_category();
static const boost::system::error_category& misc_category
= boost::asio::error::get_misc_category();
}
}
}
namespace boost {
namespace system {
template<> struct is_error_code_enum<boost::asio::error::basic_errors>
{
static const bool value = true;
};
template<> struct is_error_code_enum<boost::asio::error::netdb_errors>
{
static const bool value = true;
};
template<> struct is_error_code_enum<boost::asio::error::addrinfo_errors>
{
static const bool value = true;
};
template<> struct is_error_code_enum<boost::asio::error::misc_errors>
{
static const bool value = true;
};
}
}
namespace boost {
namespace asio {
namespace error {
boost::system::error_code make_error_code(basic_errors e)
;
boost::system::error_code make_error_code(netdb_errors e)
;
boost::system::error_code make_error_code(addrinfo_errors e)
;
boost::system::error_code make_error_code(misc_errors e)
;
}
}
}
#undef BOOST_ASIO_NATIVE_ERROR
#undef BOOST_ASIO_SOCKET_ERROR
#undef BOOST_ASIO_NETDB_ERROR
#undef BOOST_ASIO_GETADDRINFO_ERROR
#undef BOOST_ASIO_WIN_OR_POSIX
#define BOOST_ASIO_IMPL_ERROR_IPP
namespace boost {
namespace asio {
namespace error {
namespace detail {
class netdb_category : public boost::system::error_category
{
public:
const char* name() const noexcept
{
return "asio.netdb";
}
std::string message(int value) const
{
if (value == error::host_not_found)
return "Host not found (authoritative)";
if (value == error::host_not_found_try_again)
return "Host not found (non-authoritative), try again later";
if (value == error::no_data)
return "The query is valid, but it does not have associated data";
if (value == error::no_recovery)
return "A non-recoverable error occurred during database lookup";
return "asio.netdb error";
}
};
}
const boost::system::error_category& get_netdb_category()
;
namespace detail {
class addrinfo_category : public boost::system::error_category
{
public:
const char* name() const noexcept
{
return "asio.addrinfo";
}
std::string message(int value) const
{
if (value == error::service_not_found)
return "Service not found";
if (value == error::socket_type_not_supported)
return "Socket type not supported";
return "asio.addrinfo error";
}
};
}
const boost::system::error_category& get_addrinfo_category()
;
namespace detail {
class misc_category : public boost::system::error_category
{
public:
const char* name() const noexcept
{
return "asio.misc";
}
std::string message(int value) const
{
if (value == error::already_open)
return "Already open";
if (value == error::eof)
return "End of file";
if (value == error::not_found)
return "Element not found";
if (value == error::fd_set_failure)
return "The descriptor does not fit into the select call's fd_set";
return "asio.misc error";
}
};
}
const boost::system::error_category& get_misc_category()
;
}
}
}
namespace boost {
namespace asio {
namespace detail {
}
}
}
namespace boost {
namespace asio {
namespace detail {
typedef posix_event event;
}
}
}
#define BOOST_ASIO_DETAIL_OP_QUEUE_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Operation>
class op_queue;
class op_queue_access
{
public:
template <typename Operation>
static Operation* next(Operation* o)
;
template <typename Operation1, typename Operation2>
static void next(Operation1*& o1, Operation2* o2)
;
template <typename Operation>
static void destroy(Operation* o)
;
template <typename Operation>
static Operation*& front(op_queue<Operation>& q)
;
template <typename Operation>
static Operation*& back(op_queue<Operation>& q)
;
};
template <typename Operation>
class op_queue
: private noncopyable
{
public:
op_queue()
;
~op_queue()
;
Operation* front()
;
void pop()
;
void push(Operation* h)
;
template <typename OtherOperation>
void push(op_queue<OtherOperation>& q)
;
bool empty() const
;
private:
friend class op_queue_access;
Operation* front_;
Operation* back_;
};
}
}
}
#define BOOST_ASIO_DETAIL_THREAD_INFO_BASE_HPP
#define _GCC_LIMITS_H_
#define _GCC_NEXT_LIMITS_H
#define _LIBC_LIMITS_H_ 1
#define MB_LEN_MAX 16
#define LLONG_MIN (-LLONG_MAX-1)
#define LLONG_MAX __LONG_LONG_MAX__
#define ULLONG_MAX (LLONG_MAX * 2ULL + 1)
#define _BITS_POSIX1_LIM_H 1
#define _POSIX_AIO_LISTIO_MAX 2
#define _POSIX_AIO_MAX 1
#define _POSIX_ARG_MAX 4096
#define _POSIX_CHILD_MAX 25
#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_FD_SETSIZE _POSIX_OPEN_MAX
#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_SYMLINK_MAX 255
#define _POSIX_SYMLOOP_MAX 8
#define _POSIX_TIMER_MAX 32
#define _POSIX_TTY_NAME_MAX 9
#define _POSIX_TZNAME_MAX 6
#define _POSIX_QLIMIT 1
#define _POSIX_HIWAT _POSIX_PIPE_BUF
#define _POSIX_UIO_MAXIOV 16
#define _POSIX_CLOCKRES_MIN 20000000
#define __undef_NR_OPEN
#define __undef_LINK_MAX
#define __undef_OPEN_MAX
#define __undef_ARG_MAX
#define _LINUX_LIMITS_H
#define NR_OPEN 1024
#define NGROUPS_MAX 65536
#define ARG_MAX 131072
#define LINK_MAX 127
#define MAX_CANON 255
#define MAX_INPUT 255
#define NAME_MAX 255
#define PATH_MAX 4096
#define PIPE_BUF 4096
#define XATTR_NAME_MAX 255
#define XATTR_SIZE_MAX 65536
#define XATTR_LIST_MAX 65536
#define RTSIG_MAX 32
#undef NR_OPEN
#undef __undef_NR_OPEN
#undef LINK_MAX
#undef __undef_LINK_MAX
#undef OPEN_MAX
#undef __undef_OPEN_MAX
#undef ARG_MAX
#undef __undef_ARG_MAX
#define _POSIX_THREAD_KEYS_MAX 128
#define PTHREAD_KEYS_MAX 1024
#define _POSIX_THREAD_DESTRUCTOR_ITERATIONS 4
#define PTHREAD_DESTRUCTOR_ITERATIONS _POSIX_THREAD_DESTRUCTOR_ITERATIONS
#define _POSIX_THREAD_THREADS_MAX 64
#undef PTHREAD_THREADS_MAX
#define AIO_PRIO_DELTA_MAX 20
#define PTHREAD_STACK_MIN 16384
#define DELAYTIMER_MAX 2147483647
#define TTY_NAME_MAX 32
#define LOGIN_NAME_MAX 256
#define HOST_NAME_MAX 64
#define MQ_PRIO_MAX 32768
#define SEM_VALUE_MAX (2147483647)
#define SSIZE_MAX LONG_MAX
#define _BITS_POSIX2_LIM_H 1
#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_COLL_WEIGHTS_MAX 2
#define _POSIX2_EXPR_NEST_MAX 32
#define _POSIX2_LINE_MAX 2048
#define _POSIX2_RE_DUP_MAX 255
#define _POSIX2_CHARCLASS_NAME_MAX 14
#define BC_BASE_MAX _POSIX2_BC_BASE_MAX
#define BC_DIM_MAX _POSIX2_BC_DIM_MAX
#define BC_SCALE_MAX _POSIX2_BC_SCALE_MAX
#define BC_STRING_MAX _POSIX2_BC_STRING_MAX
#define COLL_WEIGHTS_MAX 255
#define EXPR_NEST_MAX _POSIX2_EXPR_NEST_MAX
#define LINE_MAX _POSIX2_LINE_MAX
#define CHARCLASS_NAME_MAX 2048
#define RE_DUP_MAX (0x7fff)
#define _XOPEN_LIM_H 1
#define __need_IOV_MAX
#define L_tmpnam 20
#define TMP_MAX 238328
#define FILENAME_MAX 4096
#define L_ctermid 9
#define L_cuserid 9
#undef FOPEN_MAX
#define FOPEN_MAX 16
#define IOV_MAX 1024
#define _XOPEN_IOV_MAX _POSIX_UIO_MAXIOV
#define NL_ARGMAX _POSIX_ARG_MAX
#define NL_LANGMAX _POSIX2_LINE_MAX
#define NL_MSGMAX INT_MAX
#define NL_NMAX INT_MAX
#define NL_SETMAX INT_MAX
#define NL_TEXTMAX INT_MAX
#define NZERO 20
#define WORD_BIT 32
#define LONG_BIT 64
#undef _GCC_NEXT_LIMITS_H
#define _LIMITS_H___
#undef CHAR_BIT
#define CHAR_BIT __CHAR_BIT__
#undef SCHAR_MIN
#define SCHAR_MIN (-SCHAR_MAX - 1)
#undef SCHAR_MAX
#define SCHAR_MAX __SCHAR_MAX__
#undef UCHAR_MAX
#define UCHAR_MAX (SCHAR_MAX * 2 + 1)
#undef CHAR_MIN
#define CHAR_MIN SCHAR_MIN
#undef CHAR_MAX
#define CHAR_MAX SCHAR_MAX
#undef SHRT_MIN
#define SHRT_MIN (-SHRT_MAX - 1)
#undef SHRT_MAX
#define SHRT_MAX __SHRT_MAX__
#undef USHRT_MAX
#define USHRT_MAX (SHRT_MAX * 2 + 1)
#undef INT_MIN
#define INT_MIN (-INT_MAX - 1)
#undef INT_MAX
#define INT_MAX __INT_MAX__
#undef UINT_MAX
#define UINT_MAX (INT_MAX * 2U + 1U)
#undef LONG_MIN
#define LONG_MIN (-LONG_MAX - 1L)
#undef LONG_MAX
#define LONG_MAX __LONG_MAX__
#undef ULONG_MAX
#define ULONG_MAX (LONG_MAX * 2UL + 1UL)
#undef LONG_LONG_MIN
#define LONG_LONG_MIN (-LONG_LONG_MAX - 1LL)
#undef LONG_LONG_MAX
#define LONG_LONG_MAX __LONG_LONG_MAX__
#undef ULONG_LONG_MAX
#define ULONG_LONG_MAX (LONG_LONG_MAX * 2ULL + 1ULL)
#define _GLIBCXX_CLIMITS 1
namespace boost {
namespace asio {
namespace detail {
class thread_info_base
: private noncopyable
{
public:
thread_info_base()
;
~thread_info_base()
;
static void* allocate(thread_info_base* this_thread, std::size_t size)
;
static void deallocate(thread_info_base* this_thread,
void* pointer, std::size_t size)
;
private:
void* reusable_memory_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
class task_io_service;
class task_io_service_operation;
struct task_io_service_thread_info : public thread_info_base
{
event* wakeup_event;
op_queue<task_io_service_operation> private_op_queue;
long private_outstanding_work;
task_io_service_thread_info* next;
};
}
}
}
namespace boost {
namespace asio {
void* asio_handler_allocate(std::size_t size, ...)
;
void asio_handler_deallocate(void* pointer, std::size_t size, ...)
;
}
}
namespace boost_asio_handler_alloc_helpers {
template <typename Handler>
void* allocate(std::size_t s, Handler& h)
;
template <typename Handler>
void deallocate(void* p, std::size_t s, Handler& h)
;
}
#define BOOST_ASIO_DEFINE_HANDLER_PTR(op) struct ptr { Handler* h; void* v; op* p; ~ptr() { reset(); } void reset() { if (p) { p->~op(); p = 0; } if (v) { boost_asio_handler_alloc_helpers::deallocate(v, sizeof(op), *h); v = 0; } } }
#define BOOST_ASIO_DETAIL_HANDLER_CONT_HELPERS_HPP
#define BOOST_ASIO_HANDLER_CONTINUATION_HOOK_HPP
namespace boost {
namespace asio {
bool asio_handler_is_continuation(...)
;
}
}
namespace boost_asio_handler_cont_helpers {
template <typename Context>
bool is_continuation(Context& context)
;
}
#define BOOST_ASIO_DETAIL_HANDLER_INVOKE_HELPERS_HPP
#define BOOST_ASIO_HANDLER_INVOKE_HOOK_HPP
namespace boost {
namespace asio {
template <typename Function>
void asio_handler_invoke(Function& function, ...)
;
template <typename Function>
void asio_handler_invoke(const Function& function, ...)
;
}
}
namespace boost_asio_handler_invoke_helpers {
template <typename Function, typename Context>
void invoke(Function& function, Context& context)
;
template <typename Function, typename Context>
void invoke(const Function& function, Context& context)
;
}
namespace boost {
namespace asio {
namespace detail {
template <typename Handler, typename Arg1>
class binder1
{
public:
binder1(const Handler& handler, const Arg1& arg1)
;
binder1(Handler& handler, const Arg1& arg1)
;
void operator()()
;
void operator()() const
;
Handler handler_;
Arg1 arg1_;
};
template <typename Handler, typename Arg1>
void* asio_handler_allocate(std::size_t size,
binder1<Handler, Arg1>* this_handler)
;
template <typename Handler, typename Arg1>
void asio_handler_deallocate(void* pointer, std::size_t size,
binder1<Handler, Arg1>* this_handler)
;
template <typename Handler, typename Arg1>
inline bool asio_handler_is_continuation(
binder1<Handler, Arg1>* this_handler)
{
return boost_asio_handler_cont_helpers::is_continuation(
this_handler->handler_);
}
template <typename Function, typename Handler, typename Arg1>
inline void asio_handler_invoke(Function& function,
binder1<Handler, Arg1>* this_handler)
{
boost_asio_handler_invoke_helpers::invoke(
function, this_handler->handler_);
}
template <typename Function, typename Handler, typename Arg1>
inline void asio_handler_invoke(const Function& function,
binder1<Handler, Arg1>* this_handler)
{
boost_asio_handler_invoke_helpers::invoke(
function, this_handler->handler_);
}
template <typename Handler, typename Arg1>
inline binder1<Handler, Arg1> bind_handler(Handler handler,
const Arg1& arg1)
{
return binder1<Handler, Arg1>(handler, arg1);
}
template <typename Handler, typename Arg1, typename Arg2>
class binder2
{
public:
binder2(const Handler& handler, const Arg1& arg1, const Arg2& arg2)
;
binder2(Handler& handler, const Arg1& arg1, const Arg2& arg2)
;
void operator()()
;
void operator()() const
;
Handler handler_;
Arg1 arg1_;
Arg2 arg2_;
};
template <typename Handler, typename Arg1, typename Arg2>
void* asio_handler_allocate(std::size_t size,
binder2<Handler, Arg1, Arg2>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2>
void asio_handler_deallocate(void* pointer, std::size_t size,
binder2<Handler, Arg1, Arg2>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2>
bool asio_handler_is_continuation(
binder2<Handler, Arg1, Arg2>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2>
void asio_handler_invoke(Function& function,
binder2<Handler, Arg1, Arg2>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2>
void asio_handler_invoke(const Function& function,
binder2<Handler, Arg1, Arg2>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2>
binder2<Handler, Arg1, Arg2> bind_handler(Handler handler,
const Arg1& arg1, const Arg2& arg2)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
class binder3
{
public:
binder3(const Handler& handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3)
;
binder3(Handler& handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3)
;
void operator()()
;
void operator()() const
;
Handler handler_;
Arg1 arg1_;
Arg2 arg2_;
Arg3 arg3_;
};
template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
void* asio_handler_allocate(std::size_t size,
binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
void asio_handler_deallocate(void* pointer, std::size_t size,
binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
bool asio_handler_is_continuation(
binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2,
typename Arg3>
void asio_handler_invoke(Function& function,
binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2,
typename Arg3>
void asio_handler_invoke(const Function& function,
binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
binder3<Handler, Arg1, Arg2, Arg3> bind_handler(Handler handler,
const Arg1& arg1, const Arg2& arg2, const Arg3& arg3)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4>
class binder4
{
public:
binder4(const Handler& handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3, const Arg4& arg4)
;
binder4(Handler& handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3, const Arg4& arg4)
;
void operator()()
;
void operator()() const
;
Handler handler_;
Arg1 arg1_;
Arg2 arg2_;
Arg3 arg3_;
Arg4 arg4_;
};
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4>
void* asio_handler_allocate(std::size_t size,
binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4>
void asio_handler_deallocate(void* pointer, std::size_t size,
binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4>
bool asio_handler_is_continuation(
binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2,
typename Arg3, typename Arg4>
void asio_handler_invoke(Function& function,
binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2,
typename Arg3, typename Arg4>
void asio_handler_invoke(const Function& function,
binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4>
binder4<Handler, Arg1, Arg2, Arg3, Arg4> bind_handler(
Handler handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3, const Arg4& arg4)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5>
class binder5
{
public:
binder5(const Handler& handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
;
binder5(Handler& handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
;
void operator()()
;
void operator()() const
;
Handler handler_;
Arg1 arg1_;
Arg2 arg2_;
Arg3 arg3_;
Arg4 arg4_;
Arg5 arg5_;
};
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5>
void* asio_handler_allocate(std::size_t size,
binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5>
void asio_handler_deallocate(void* pointer, std::size_t size,
binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5>
bool asio_handler_is_continuation(
binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2,
typename Arg3, typename Arg4, typename Arg5>
void asio_handler_invoke(Function& function,
binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
;
template <typename Function, typename Handler, typename Arg1, typename Arg2,
typename Arg3, typename Arg4, typename Arg5>
void asio_handler_invoke(const Function& function,
binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
;
template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
typename Arg4, typename Arg5>
binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5> bind_handler(
Handler handler, const Arg1& arg1, const Arg2& arg2,
const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
;
}
}
}
namespace boost {
namespace asio {
namespace detail {
struct is_continuation_delegated
{
template <typename Dispatcher, typename Handler>
bool operator()(Dispatcher&, Handler& handler) const
;
};
struct is_continuation_if_running
{
template <typename Dispatcher, typename Handler>
bool operator()(Dispatcher& dispatcher, Handler&) const
;
};
template <typename Dispatcher, typename Handler,
typename IsContinuation = is_continuation_delegated>
class wrapped_handler
{
public:
typedef void result_type;
wrapped_handler(Dispatcher dispatcher, Handler& handler)
;
wrapped_handler(const wrapped_handler& other)
;
wrapped_handler(wrapped_handler&& other)
;
void operator()()
;
void operator()() const
;
template <typename Arg1>
void operator()(const Arg1& arg1)
;
template <typename Arg1>
void operator()(const Arg1& arg1) const
;
template <typename Arg1, typename Arg2>
void operator()(const Arg1& arg1, const Arg2& arg2)
;
template <typename Arg1, typename Arg2>
void operator()(const Arg1& arg1, const Arg2& arg2) const
;
template <typename Arg1, typename Arg2, typename Arg3>
void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3)
;
template <typename Arg1, typename Arg2, typename Arg3>
void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3) const
;
template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
const Arg4& arg4)
;
template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
const Arg4& arg4) const
;
template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
typename Arg5>
void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
const Arg4& arg4, const Arg5& arg5)
;
template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
typename Arg5>
void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
const Arg4& arg4, const Arg5& arg5) const
;
Dispatcher dispatcher_;
Handler handler_;
};
template <typename Handler, typename Context>
class rewrapped_handler
{
public:
explicit rewrapped_handler(Handler& handler, const Context& context)
;
explicit rewrapped_handler(const Handler& handler, const Context& context)
;
rewrapped_handler(const rewrapped_handler& other)
;
rewrapped_handler(rewrapped_handler&& other)
;
void operator()()
;
void operator()() const
;
Context context_;
Handler handler_;
};
template <typename Dispatcher, typename Handler, typename IsContinuation>
void* asio_handler_allocate(std::size_t size,
wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
;
template <typename Dispatcher, typename Handler, typename IsContinuation>
void asio_handler_deallocate(void* pointer, std::size_t size,
wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
;
template <typename Dispatcher, typename Handler, typename IsContinuation>
bool asio_handler_is_continuation(
wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
;
template <typename Function, typename Dispatcher,
typename Handler, typename IsContinuation>
void asio_handler_invoke(Function& function,
wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
;
template <typename Function, typename Dispatcher,
typename Handler, typename IsContinuation>
void asio_handler_invoke(const Function& function,
wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
;
template <typename Handler, typename Context>
void* asio_handler_allocate(std::size_t size,
rewrapped_handler<Handler, Context>* this_handler)
;
template <typename Handler, typename Context>
void asio_handler_deallocate(void* pointer, std::size_t size,
rewrapped_handler<Handler, Context>* this_handler)
;
template <typename Dispatcher, typename Context>
bool asio_handler_is_continuation(
rewrapped_handler<Dispatcher, Context>* this_handler)
;
template <typename Function, typename Handler, typename Context>
void asio_handler_invoke(Function& function,
rewrapped_handler<Handler, Context>* this_handler)
;
template <typename Function, typename Handler, typename Context>
void asio_handler_invoke(const Function& function,
rewrapped_handler<Handler, Context>* this_handler)
;
}
}
}
namespace boost {
namespace asio {
class io_service;
template <typename Service> Service& use_service(io_service& ios);
template <typename Service> void add_service(io_service& ios, Service* svc);
template <typename Service> bool has_service(io_service& ios);
namespace detail {
typedef class task_io_service io_service_impl;
class service_registry;
}
class io_service
: private noncopyable
{
private:
typedef detail::io_service_impl impl_type;
public:
class work;
friend class work;
class id;
class service;
class strand;
inline io_service();
inline explicit io_service(std::size_t concurrency_hint);
inline ~io_service();
inline std::size_t run();
inline std::size_t run(boost::system::error_code& ec);
inline std::size_t run_one();
inline std::size_t run_one(boost::system::error_code& ec);
inline std::size_t poll();
inline std::size_t poll(boost::system::error_code& ec);
inline std::size_t poll_one();
inline std::size_t poll_one(boost::system::error_code& ec);
inline void stop();
inline bool stopped() const;
inline void reset();
template <typename CompletionHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<CompletionHandler, void ()>::type>::type
dispatch(CompletionHandler&& handler);
template <typename CompletionHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<CompletionHandler, void ()>::type>::type
post(CompletionHandler&& handler);
template <typename Handler>
detail::wrapped_handler<io_service&, Handler>
wrap(Handler handler);
enum fork_event
{
fork_prepare,
fork_parent,
fork_child
};
inline void notify_fork(boost::asio::io_service::fork_event event);
template <typename Service>
friend Service& use_service(io_service& ios);
template <typename Service>
friend void add_service(io_service& ios, Service* svc);
template <typename Service>
friend bool has_service(io_service& ios);
private:
boost::asio::detail::service_registry* service_registry_;
impl_type& impl_;
};
class io_service::work
{
public:
explicit work(boost::asio::io_service& io_service);
work(const work& other);
~work();
boost::asio::io_service& get_io_service();
private:
void operator=(const work& other);
detail::io_service_impl& io_service_impl_;
};
class io_service::id
: private noncopyable
{
public:
id() ;
};
class io_service::service
: private noncopyable
{
public:
boost::asio::io_service& get_io_service();
protected:
inline service(boost::asio::io_service& owner);
inline virtual ~service();
private:
virtual void shutdown_service() = 0;
inline virtual void fork_service(
boost::asio::io_service::fork_event event);
friend class boost::asio::detail::service_registry;
struct key
{
key() ;
const std::type_info* type_info_;
const boost::asio::io_service::id* id_;
} key_;
boost::asio::io_service& owner_;
service* next_;
};
class service_already_exists
: public std::logic_error
{
public:
inline service_already_exists();
};
class invalid_service_owner
: public std::logic_error
{
public:
inline invalid_service_owner();
};
namespace detail {
template <typename Type>
class service_id
: public boost::asio::io_service::id
{
};
template <typename Type>
class service_base
: public boost::asio::io_service::service
{
public:
static boost::asio::detail::service_id<Type> id;
service_base(boost::asio::io_service& io_service)
;
};
template <typename Type>
boost::asio::detail::service_id<Type> service_base<Type>::id;
}
}
}
#define BOOST_ASIO_IMPL_IO_SERVICE_HPP
#define BOOST_ASIO_DETAIL_HANDLER_TYPE_REQUIREMENTS_HPP
#define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS 1
#define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1
#define BOOST_ASIO_UNUSED_TYPEDEF __attribute__((__unused__))
namespace boost {
namespace asio {
namespace detail {
template <typename Handler>
auto zero_arg_handler_test(Handler h, void*)
-> decltype(
sizeof(Handler(static_cast<const Handler&>(h))),
((h)()),
char(0));
template <typename Handler>
char (&zero_arg_handler_test(Handler, ...))[2];
template <typename Handler, typename Arg1>
auto one_arg_handler_test(Handler h, Arg1* a1)
-> decltype(
sizeof(Handler(static_cast<const Handler&>(h))),
((h)(*a1)),
char(0));
template <typename Handler>
char (&one_arg_handler_test(Handler h, ...))[2];
template <typename Handler, typename Arg1, typename Arg2>
auto two_arg_handler_test(Handler h, Arg1* a1, Arg2* a2)
-> decltype(
sizeof(Handler(static_cast<const Handler&>(h))),
((h)(*a1, *a2)),
char(0));
template <typename Handler>
char (&two_arg_handler_test(Handler, ...))[2];
#define BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT(expr,msg) static_assert(expr, msg);
template <typename T> T& lvref();
template <typename T> T& lvref(T);
template <typename T> const T& clvref();
template <typename T> const T& clvref(T);
template <typename T> char argbyv(T);
template <int>
struct handler_type_requirements
{
};
#define BOOST_ASIO_COMPLETION_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void()) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::zero_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), 0)) == 1, "CompletionHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()(), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_READ_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code, std::size_t)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_WRITE_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code, std::size_t)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_ACCEPT_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "AcceptHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_CONNECT_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "ConnectHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK(handler_type,handler,iter_type) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code, iter_type)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const iter_type*>(0))) == 1, "ComposedConnectHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const iter_type>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_RESOLVE_HANDLER_CHECK(handler_type,handler,iter_type) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code, iter_type)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const iter_type*>(0))) == 1, "ResolveHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const iter_type>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_WAIT_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "WaitHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_SIGNAL_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code, int)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const int*>(0))) == 1, "SignalHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const int>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_HANDSHAKE_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "HandshakeHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_BUFFERED_HANDSHAKE_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code, std::size_t)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "BufferedHandshakeHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
#define BOOST_ASIO_SHUTDOWN_HANDLER_CHECK(handler_type,handler) typedef BOOST_ASIO_HANDLER_TYPE(handler_type, void(boost::system::error_code)) asio_true_handler_type; BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "ShutdownHandler type requirements not met") typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> BOOST_ASIO_UNUSED_TYPEDEF
}
}
}
#define BOOST_ASIO_DETAIL_SERVICE_REGISTRY_HPP
#define BOOST_ASIO_DETAIL_MUTEX_HPP
#define BOOST_ASIO_DETAIL_POSIX_MUTEX_HPP
#define BOOST_ASIO_DETAIL_SCOPED_LOCK_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Mutex>
class scoped_lock
: private noncopyable
{
public:
enum adopt_lock_t { adopt_lock };
scoped_lock(Mutex& m, adopt_lock_t)
;
explicit scoped_lock(Mutex& m)
;
~scoped_lock()
;
void lock()
;
void unlock()
;
bool locked() const
;
Mutex& mutex()
;
private:
Mutex& mutex_;
bool locked_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
class posix_event;
class posix_mutex
: private noncopyable
{
public:
typedef boost::asio::detail::scoped_lock<posix_mutex> scoped_lock;
inline posix_mutex();
~posix_mutex()
;
void lock()
;
void unlock()
;
private:
friend class posix_event;
::pthread_mutex_t mutex_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_POSIX_MUTEX_IPP
namespace boost {
namespace asio {
namespace detail {
}
}
}
namespace boost {
namespace asio {
namespace detail {
typedef posix_mutex mutex;
}
}
}
namespace boost {
namespace asio {
namespace detail {
#pragma GCC visibility push (default)
template <typename T>
class typeid_wrapper {};
#pragma GCC visibility pop
class service_registry
: private noncopyable
{
public:
template <typename Service, typename Arg>
service_registry(boost::asio::io_service& o,
Service* initial_service, Arg arg);
inline ~service_registry();
inline void notify_fork(boost::asio::io_service::fork_event fork_ev);
template <typename Service>
Service& first_service();
template <typename Service>
Service& use_service();
template <typename Service>
void add_service(Service* new_service);
template <typename Service>
bool has_service() const;
private:
inline static void init_key(
boost::asio::io_service::service::key& key,
const boost::asio::io_service::id& id);
template <typename Service>
static void init_key(boost::asio::io_service::service::key& key,
const boost::asio::detail::service_id<Service>& );
inline static bool keys_match(
const boost::asio::io_service::service::key& key1,
const boost::asio::io_service::service::key& key2);
typedef boost::asio::io_service::service*
(*factory_type)(boost::asio::io_service&);
template <typename Service>
static boost::asio::io_service::service* create(
boost::asio::io_service& owner);
inline static void destroy(
boost::asio::io_service::service* service);
struct auto_service_ptr;
friend struct auto_service_ptr;
struct auto_service_ptr
{
boost::asio::io_service::service* ptr_;
~auto_service_ptr() ;
};
inline boost::asio::io_service::service* do_use_service(
const boost::asio::io_service::service::key& key,
factory_type factory);
inline void do_add_service(
const boost::asio::io_service::service::key& key,
boost::asio::io_service::service* new_service);
inline bool do_has_service(
const boost::asio::io_service::service::key& key) const;
mutable boost::asio::detail::mutex mutex_;
boost::asio::io_service& owner_;
boost::asio::io_service::service* first_service_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_SERVICE_REGISTRY_HPP
namespace boost {
namespace asio {
namespace detail {
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_SERVICE_REGISTRY_IPP
#define _GLIBCXX_VECTOR 1
#define _STL_VECTOR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Tp, typename _Alloc>
struct _Vector_base
{
typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
rebind<_Tp>::other _Tp_alloc_type;
typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer
pointer;
struct _Vector_impl
: public _Tp_alloc_type
{
pointer _M_start;
pointer _M_finish;
pointer _M_end_of_storage;
_Vector_impl()
;
_Vector_impl(_Tp_alloc_type const& __a) noexcept
: _Tp_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage()
{ }
_Vector_impl(_Tp_alloc_type&& __a) noexcept
: _Tp_alloc_type(std::move(__a)),
_M_start(), _M_finish(), _M_end_of_storage()
{ }
void _M_swap_data(_Vector_impl& __x) noexcept
{
std::swap(_M_start, __x._M_start);
std::swap(_M_finish, __x._M_finish);
std::swap(_M_end_of_storage, __x._M_end_of_storage);
}
};
public:
typedef _Alloc allocator_type;
_Tp_alloc_type&
_M_get_Tp_allocator() noexcept
{ return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
const _Tp_alloc_type&
_M_get_Tp_allocator() const noexcept
{ return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
allocator_type
get_allocator() const noexcept
{ return allocator_type(_M_get_Tp_allocator()); }
_Vector_base()
: _M_impl() { }
_Vector_base(const allocator_type& __a) noexcept
: _M_impl(__a) { }
_Vector_base(size_t __n)
: _M_impl()
{ _M_create_storage(__n); }
_Vector_base(size_t __n, const allocator_type& __a)
: _M_impl(__a)
{ _M_create_storage(__n); }
_Vector_base(_Tp_alloc_type&& __a) noexcept
: _M_impl(std::move(__a)) { }
_Vector_base(_Vector_base&& __x) noexcept
: _M_impl(std::move(__x._M_get_Tp_allocator()))
{ this->_M_impl._M_swap_data(__x._M_impl); }
_Vector_base(_Vector_base&& __x, const allocator_type& __a)
: _M_impl(__a)
{
if (__x.get_allocator() == __a)
this->_M_impl._M_swap_data(__x._M_impl);
else
{
size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start;
_M_create_storage(__n);
}
}
~_Vector_base() noexcept
{ _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage
- this->_M_impl._M_start); }
public:
_Vector_impl _M_impl;
pointer
_M_allocate(size_t __n)
;
void
_M_deallocate(pointer __p, size_t __n)
;
private:
void
_M_create_storage(size_t __n)
;
};
template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
class vector : protected _Vector_base<_Tp, _Alloc>
{
typedef typename _Alloc::value_type _Alloc_value_type;
typedef _Vector_base<_Tp, _Alloc> _Base;
typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;
public:
typedef _Tp value_type;
typedef typename _Base::pointer pointer;
typedef typename _Alloc_traits::const_pointer const_pointer;
typedef typename _Alloc_traits::reference reference;
typedef typename _Alloc_traits::const_reference const_reference;
typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
const_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef _Alloc allocator_type;
protected:
using _Base::_M_allocate;
using _Base::_M_deallocate;
using _Base::_M_impl;
using _Base::_M_get_Tp_allocator;
public:
vector()
noexcept(is_nothrow_default_constructible<_Alloc>::value)
: _Base() { }
explicit
vector(const allocator_type& __a) noexcept
: _Base(__a) { }
explicit
vector(size_type __n, const allocator_type& __a = allocator_type())
: _Base(__n, __a)
{ _M_default_initialize(__n); }
vector(size_type __n, const value_type& __value,
const allocator_type& __a = allocator_type())
: _Base(__n, __a)
{ _M_fill_initialize(__n, __value); }
vector(const vector& __x)
: _Base(__x.size(),
_Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
{ this->_M_impl._M_finish =
std::__uninitialized_copy_a(__x.begin(), __x.end(),
this->_M_impl._M_start,
_M_get_Tp_allocator());
}
vector(vector&& __x) noexcept
: _Base(std::move(__x)) { }
vector(const vector& __x, const allocator_type& __a)
: _Base(__x.size(), __a)
{ this->_M_impl._M_finish =
std::__uninitialized_copy_a(__x.begin(), __x.end(),
this->_M_impl._M_start,
_M_get_Tp_allocator());
}
vector(vector&& __rv, const allocator_type& __m)
noexcept(_Alloc_traits::_S_always_equal())
: _Base(std::move(__rv), __m)
{
if (__rv.get_allocator() != __m)
{
this->_M_impl._M_finish =
std::__uninitialized_move_a(__rv.begin(), __rv.end(),
this->_M_impl._M_start,
_M_get_Tp_allocator());
__rv.clear();
}
}
vector(initializer_list<value_type> __l,
const allocator_type& __a = allocator_type())
: _Base(__a)
{
_M_range_initialize(__l.begin(), __l.end(),
random_access_iterator_tag());
}
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
vector(_InputIterator __first, _InputIterator __last,
const allocator_type& __a = allocator_type())
: _Base(__a)
{ _M_initialize_dispatch(__first, __last, __false_type()); }
~vector() noexcept
{ std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator()); }
vector&
operator=(const vector& __x);
vector&
operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
{
constexpr bool __move_storage =
_Alloc_traits::_S_propagate_on_move_assign()
|| _Alloc_traits::_S_always_equal();
_M_move_assign(std::move(__x),
integral_constant<bool, __move_storage>());
return *this;
}
vector&
operator=(initializer_list<value_type> __l)
{
this->assign(__l.begin(), __l.end());
return *this;
}
void
assign(size_type __n, const value_type& __val)
{ _M_fill_assign(__n, __val); }
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
void
assign(_InputIterator __first, _InputIterator __last)
{ _M_assign_dispatch(__first, __last, __false_type()); }
void
assign(initializer_list<value_type> __l)
{ this->assign(__l.begin(), __l.end()); }
using _Base::get_allocator;
iterator
begin() noexcept
{ return iterator(this->_M_impl._M_start); }
const_iterator
begin() const noexcept
{ return const_iterator(this->_M_impl._M_start); }
iterator
end() noexcept
{ return iterator(this->_M_impl._M_finish); }
const_iterator
end() const noexcept
{ return const_iterator(this->_M_impl._M_finish); }
reverse_iterator
rbegin() noexcept
{ return reverse_iterator(end()); }
const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(end()); }
reverse_iterator
rend() noexcept
{ return reverse_iterator(begin()); }
const_reverse_iterator
rend() const noexcept
{ return const_reverse_iterator(begin()); }
const_iterator
cbegin() const noexcept
{ return const_iterator(this->_M_impl._M_start); }
const_iterator
cend() const noexcept
{ return const_iterator(this->_M_impl._M_finish); }
const_reverse_iterator
crbegin() const noexcept
{ return const_reverse_iterator(end()); }
const_reverse_iterator
crend() const noexcept
{ return const_reverse_iterator(begin()); }
size_type
size() const noexcept
{ return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
size_type
max_size() const noexcept
{ return _Alloc_traits::max_size(_M_get_Tp_allocator()); }
void
resize(size_type __new_size)
{
if (__new_size > size())
_M_default_append(__new_size - size());
else if (__new_size < size())
_M_erase_at_end(this->_M_impl._M_start + __new_size);
}
void
resize(size_type __new_size, const value_type& __x)
{
if (__new_size > size())
insert(end(), __new_size - size(), __x);
else if (__new_size < size())
_M_erase_at_end(this->_M_impl._M_start + __new_size);
}
void
shrink_to_fit()
{ _M_shrink_to_fit(); }
size_type
capacity() const noexcept
{ return size_type(this->_M_impl._M_end_of_storage
- this->_M_impl._M_start); }
bool
empty() const noexcept
{ return begin() == end(); }
void
reserve(size_type __n);
reference
operator[](size_type __n) noexcept
{ return *(this->_M_impl._M_start + __n); }
const_reference
operator[](size_type __n) const noexcept
{ return *(this->_M_impl._M_start + __n); }
protected:
void
_M_range_check(size_type __n) const
{
if (__n >= this->size())
__throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"),
__n, this->size());
}
public:
reference
at(size_type __n)
{
_M_range_check(__n);
return (*this)[__n];
}
const_reference
at(size_type __n) const
{
_M_range_check(__n);
return (*this)[__n];
}
reference
front() noexcept
{ return *begin(); }
const_reference
front() const noexcept
{ return *begin(); }
reference
back() noexcept
{ return *(end() - 1); }
const_reference
back() const noexcept
{ return *(end() - 1); }
_Tp*
data() noexcept
{ return _M_data_ptr(this->_M_impl._M_start); }
const _Tp*
data() const noexcept
{ return _M_data_ptr(this->_M_impl._M_start); }
void
push_back(const value_type& __x)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
__x);
++this->_M_impl._M_finish;
}
else
_M_emplace_back_aux(__x);
}
void
push_back(value_type&& __x)
{ emplace_back(std::move(__x)); }
template<typename... _Args>
void
emplace_back(_Args&&... __args);
void
pop_back() noexcept
{
--this->_M_impl._M_finish;
_Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
}
template<typename... _Args>
iterator
emplace(const_iterator __position, _Args&&... __args);
iterator
insert(const_iterator __position, const value_type& __x);
iterator
insert(const_iterator __position, value_type&& __x)
;
iterator
insert(const_iterator __position, initializer_list<value_type> __l)
;
iterator
insert(const_iterator __position, size_type __n, const value_type& __x)
;
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
iterator
insert(const_iterator __position, _InputIterator __first,
_InputIterator __last)
;
iterator
erase(const_iterator __position)
;
iterator
erase(const_iterator __first, const_iterator __last)
;
void
swap(vector& __x)
noexcept(_Alloc_traits::_S_nothrow_swap())
{
this->_M_impl._M_swap_data(__x._M_impl);
_Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
__x._M_get_Tp_allocator());
}
void
clear() noexcept
{ _M_erase_at_end(this->_M_impl._M_start); }
protected:
template<typename _ForwardIterator>
pointer
_M_allocate_and_copy(size_type __n,
_ForwardIterator __first, _ForwardIterator __last)
{
pointer __result = this->_M_allocate(__n);
try
{
std::__uninitialized_copy_a(__first, __last, __result,
_M_get_Tp_allocator());
return __result;
}
catch(...)
{
_M_deallocate(__result, __n);
throw;
}
}
template<typename _Integer>
void
_M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
{
this->_M_impl._M_start = _M_allocate(static_cast<size_type>(__n));
this->_M_impl._M_end_of_storage =
this->_M_impl._M_start + static_cast<size_type>(__n);
_M_fill_initialize(static_cast<size_type>(__n), __value);
}
template<typename _InputIterator>
void
_M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
{
typedef typename std::iterator_traits<_InputIterator>::
iterator_category _IterCategory;
_M_range_initialize(__first, __last, _IterCategory());
}
template<typename _InputIterator>
void
_M_range_initialize(_InputIterator __first,
_InputIterator __last, std::input_iterator_tag)
{
for (; __first != __last; ++__first)
emplace_back(*__first);
}
template<typename _ForwardIterator>
void
_M_range_initialize(_ForwardIterator __first,
_ForwardIterator __last, std::forward_iterator_tag)
{
const size_type __n = std::distance(__first, __last);
this->_M_impl._M_start = this->_M_allocate(__n);
this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
this->_M_impl._M_finish =
std::__uninitialized_copy_a(__first, __last,
this->_M_impl._M_start,
_M_get_Tp_allocator());
}
void
_M_fill_initialize(size_type __n, const value_type& __value)
{
this->_M_impl._M_finish =
std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
_M_get_Tp_allocator());
}
void
_M_default_initialize(size_type __n)
{
this->_M_impl._M_finish =
std::__uninitialized_default_n_a(this->_M_impl._M_start, __n,
_M_get_Tp_allocator());
}
template<typename _Integer>
void
_M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
{ _M_fill_assign(__n, __val); }
template<typename _InputIterator>
void
_M_assign_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
{
typedef typename std::iterator_traits<_InputIterator>::
iterator_category _IterCategory;
_M_assign_aux(__first, __last, _IterCategory());
}
template<typename _InputIterator>
void
_M_assign_aux(_InputIterator __first, _InputIterator __last,
std::input_iterator_tag);
template<typename _ForwardIterator>
void
_M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
std::forward_iterator_tag);
void
_M_fill_assign(size_type __n, const value_type& __val);
template<typename _Integer>
void
_M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
__true_type)
;
template<typename _InputIterator>
void
_M_insert_dispatch(iterator __pos, _InputIterator __first,
_InputIterator __last, __false_type)
;
template<typename _InputIterator>
void
_M_range_insert(iterator __pos, _InputIterator __first,
_InputIterator __last, std::input_iterator_tag);
template<typename _ForwardIterator>
void
_M_range_insert(iterator __pos, _ForwardIterator __first,
_ForwardIterator __last, std::forward_iterator_tag);
void
_M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
void
_M_default_append(size_type __n);
bool
_M_shrink_to_fit();
template<typename... _Args>
void
_M_insert_aux(iterator __position, _Args&&... __args);
template<typename... _Args>
void
_M_emplace_back_aux(_Args&&... __args);
size_type
_M_check_len(size_type __n, const char* __s) const
;
void
_M_erase_at_end(pointer __pos) noexcept
{
std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator());
this->_M_impl._M_finish = __pos;
}
iterator
_M_erase(iterator __position);
iterator
_M_erase(iterator __first, iterator __last);
private:
void
_M_move_assign(vector&& __x, std::true_type) noexcept
{
vector __tmp(get_allocator());
this->_M_impl._M_swap_data(__tmp._M_impl);
this->_M_impl._M_swap_data(__x._M_impl);
std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
}
void
_M_move_assign(vector&& __x, std::false_type)
{
if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
_M_move_assign(std::move(__x), std::true_type());
else
{
this->assign(std::__make_move_if_noexcept_iterator(__x.begin()),
std::__make_move_if_noexcept_iterator(__x.end()));
__x.clear();
}
}
template<typename _Up>
_Up*
_M_data_ptr(_Up* __ptr) const
{ return __ptr; }
template<typename _Ptr>
typename std::pointer_traits<_Ptr>::element_type*
_M_data_ptr(_Ptr __ptr) const
{ return empty() ? nullptr : std::__addressof(*__ptr); }
};
template<typename _Tp, typename _Alloc>
bool
operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
;
template<typename _Tp, typename _Alloc>
bool
operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
;
template<typename _Tp, typename _Alloc>
bool
operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
;
template<typename _Tp, typename _Alloc>
bool
operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
;
template<typename _Tp, typename _Alloc>
bool
operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
;
template<typename _Tp, typename _Alloc>
bool
operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
;
template<typename _Tp, typename _Alloc>
inline void
swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
{ __x.swap(__y); }
}
#define _STL_BVECTOR_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
typedef unsigned long _Bit_type;
enum { _S_word_bit = int(8 * sizeof(_Bit_type)) };
struct _Bit_reference
{
_Bit_type * _M_p;
_Bit_type _M_mask;
_Bit_reference(_Bit_type * __x, _Bit_type __y)
: _M_p(__x), _M_mask(__y) { }
_Bit_reference() noexcept : _M_p(0), _M_mask(0) { }
operator bool() const noexcept
{ return !!(*_M_p & _M_mask); }
_Bit_reference&
operator=(bool __x) noexcept
{
if (__x)
*_M_p |= _M_mask;
else
*_M_p &= ~_M_mask;
return *this;
}
_Bit_reference&
operator=(const _Bit_reference& __x) noexcept
{ return *this = bool(__x); }
bool
operator==(const _Bit_reference& __x) const
{ return bool(*this) == bool(__x); }
bool
operator<(const _Bit_reference& __x) const
{ return !bool(*this) && bool(__x); }
void
flip() noexcept
{ *_M_p ^= _M_mask; }
};
inline void
swap(_Bit_reference __x, _Bit_reference __y) noexcept
{
bool __tmp = __x;
__x = __y;
__y = __tmp;
}
inline void
swap(_Bit_reference __x, bool& __y) noexcept
{
bool __tmp = __x;
__x = __y;
__y = __tmp;
}
inline void
swap(bool& __x, _Bit_reference __y) noexcept
{
bool __tmp = __x;
__x = __y;
__y = __tmp;
}
struct _Bit_iterator_base
: public std::iterator<std::random_access_iterator_tag, bool>
{
_Bit_type * _M_p;
unsigned int _M_offset;
_Bit_iterator_base(_Bit_type * __x, unsigned int __y)
: _M_p(__x), _M_offset(__y) { }
void
_M_bump_up()
{
if (_M_offset++ == int(_S_word_bit) - 1)
{
_M_offset = 0;
++_M_p;
}
}
void
_M_bump_down()
{
if (_M_offset-- == 0)
{
_M_offset = int(_S_word_bit) - 1;
--_M_p;
}
}
void
_M_incr(ptrdiff_t __i)
{
difference_type __n = __i + _M_offset;
_M_p += __n / int(_S_word_bit);
__n = __n % int(_S_word_bit);
if (__n < 0)
{
__n += int(_S_word_bit);
--_M_p;
}
_M_offset = static_cast<unsigned int>(__n);
}
bool
operator==(const _Bit_iterator_base& __i) const
{ return _M_p == __i._M_p && _M_offset == __i._M_offset; }
bool
operator<(const _Bit_iterator_base& __i) const
{
return _M_p < __i._M_p
|| (_M_p == __i._M_p && _M_offset < __i._M_offset);
}
bool
operator!=(const _Bit_iterator_base& __i) const
{ return !(*this == __i); }
bool
operator>(const _Bit_iterator_base& __i) const
{ return __i < *this; }
bool
operator<=(const _Bit_iterator_base& __i) const
{ return !(__i < *this); }
bool
operator>=(const _Bit_iterator_base& __i) const
{ return !(*this < __i); }
};
inline ptrdiff_t
operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
{
return (int(_S_word_bit) * (__x._M_p - __y._M_p)
+ __x._M_offset - __y._M_offset);
}
struct _Bit_iterator : public _Bit_iterator_base
{
typedef _Bit_reference reference;
typedef _Bit_reference* pointer;
typedef _Bit_iterator iterator;
_Bit_iterator() : _Bit_iterator_base(0, 0) { }
_Bit_iterator(_Bit_type * __x, unsigned int __y)
: _Bit_iterator_base(__x, __y) { }
iterator
_M_const_cast() const
{ return *this; }
reference
operator*() const
{ return reference(_M_p, 1UL << _M_offset); }
iterator&
operator++()
{
_M_bump_up();
return *this;
}
iterator
operator++(int)
{
iterator __tmp = *this;
_M_bump_up();
return __tmp;
}
iterator&
operator--()
{
_M_bump_down();
return *this;
}
iterator
operator--(int)
{
iterator __tmp = *this;
_M_bump_down();
return __tmp;
}
iterator&
operator+=(difference_type __i)
{
_M_incr(__i);
return *this;
}
iterator&
operator-=(difference_type __i)
{
*this += -__i;
return *this;
}
iterator
operator+(difference_type __i) const
{
iterator __tmp = *this;
return __tmp += __i;
}
iterator
operator-(difference_type __i) const
{
iterator __tmp = *this;
return __tmp -= __i;
}
reference
operator[](difference_type __i) const
{ return *(*this + __i); }
};
inline _Bit_iterator
operator+(ptrdiff_t __n, const _Bit_iterator& __x)
{ return __x + __n; }
struct _Bit_const_iterator : public _Bit_iterator_base
{
typedef bool reference;
typedef bool const_reference;
typedef const bool* pointer;
typedef _Bit_const_iterator const_iterator;
_Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
_Bit_const_iterator(_Bit_type * __x, unsigned int __y)
: _Bit_iterator_base(__x, __y) { }
_Bit_const_iterator(const _Bit_iterator& __x)
: _Bit_iterator_base(__x._M_p, __x._M_offset) { }
_Bit_iterator
_M_const_cast() const
{ return _Bit_iterator(_M_p, _M_offset); }
const_reference
operator*() const
;
const_iterator&
operator++()
;
const_iterator
operator++(int)
;
const_iterator&
operator--()
;
const_iterator
operator--(int)
;
const_iterator&
operator+=(difference_type __i)
;
const_iterator&
operator-=(difference_type __i)
;
const_iterator
operator+(difference_type __i) const
;
const_iterator
operator-(difference_type __i) const
;
const_reference
operator[](difference_type __i) const
;
};
_Bit_const_iterator
operator+(ptrdiff_t __n, const _Bit_const_iterator& __x)
;
void
__fill_bvector(_Bit_iterator __first, _Bit_iterator __last, bool __x)
;
void
fill(_Bit_iterator __first, _Bit_iterator __last, const bool& __x)
;
template<typename _Alloc>
struct _Bvector_base
{
typedef typename _Alloc::template rebind<_Bit_type>::other
_Bit_alloc_type;
struct _Bvector_impl
: public _Bit_alloc_type
{
_Bit_iterator _M_start;
_Bit_iterator _M_finish;
_Bit_type* _M_end_of_storage;
_Bvector_impl()
;
_Bvector_impl(const _Bit_alloc_type& __a)
;
_Bvector_impl(_Bit_alloc_type&& __a)
;
};
public:
typedef _Alloc allocator_type;
_Bit_alloc_type&
_M_get_Bit_allocator() noexcept
{ return *static_cast<_Bit_alloc_type*>(&this->_M_impl); }
const _Bit_alloc_type&
_M_get_Bit_allocator() const noexcept
{ return *static_cast<const _Bit_alloc_type*>(&this->_M_impl); }
allocator_type
get_allocator() const noexcept
{ return allocator_type(_M_get_Bit_allocator()); }
_Bvector_base()
: _M_impl() { }
_Bvector_base(const allocator_type& __a)
: _M_impl(__a) { }
_Bvector_base(_Bvector_base&& __x) noexcept
: _M_impl(std::move(__x._M_get_Bit_allocator()))
{
this->_M_impl._M_start = __x._M_impl._M_start;
this->_M_impl._M_finish = __x._M_impl._M_finish;
this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage;
__x._M_impl._M_start = _Bit_iterator();
__x._M_impl._M_finish = _Bit_iterator();
__x._M_impl._M_end_of_storage = 0;
}
~_Bvector_base()
{ this->_M_deallocate(); }
protected:
_Bvector_impl _M_impl;
_Bit_type*
_M_allocate(size_t __n)
;
void
_M_deallocate()
;
static size_t
_S_nword(size_t __n)
;
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc>
class vector<bool, _Alloc> : protected _Bvector_base<_Alloc>
{
typedef _Bvector_base<_Alloc> _Base;
template<typename> friend struct hash;
public:
typedef bool value_type;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef _Bit_reference reference;
typedef bool const_reference;
typedef _Bit_reference* pointer;
typedef const bool* const_pointer;
typedef _Bit_iterator iterator;
typedef _Bit_const_iterator const_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef _Alloc allocator_type;
allocator_type get_allocator() const
;
protected:
using _Base::_M_allocate;
using _Base::_M_deallocate;
using _Base::_S_nword;
using _Base::_M_get_Bit_allocator;
public:
vector() ;
explicit
vector(const allocator_type& __a) ;
explicit
vector(size_type __n, const allocator_type& __a = allocator_type())
;
vector(size_type __n, const bool& __value,
const allocator_type& __a = allocator_type())
;
vector(const vector& __x)
;
vector(vector&& __x) noexcept
: _Base(std::move(__x)) { }
vector(initializer_list<bool> __l,
const allocator_type& __a = allocator_type())
: _Base(__a)
{
_M_initialize_range(__l.begin(), __l.end(),
random_access_iterator_tag());
}
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
vector(_InputIterator __first, _InputIterator __last,
const allocator_type& __a = allocator_type())
: _Base(__a)
{ _M_initialize_dispatch(__first, __last, __false_type()); }
~vector() noexcept { }
vector&
operator=(const vector& __x)
{
if (&__x == this)
return *this;
if (__x.size() > capacity())
{
this->_M_deallocate();
_M_initialize(__x.size());
}
this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
begin());
return *this;
}
vector&
operator=(vector&& __x)
{
this->clear();
this->swap(__x);
return *this;
}
vector&
operator=(initializer_list<bool> __l)
{
this->assign (__l.begin(), __l.end());
return *this;
}
void
assign(size_type __n, const bool& __x)
{ _M_fill_assign(__n, __x); }
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
void
assign(_InputIterator __first, _InputIterator __last)
{ _M_assign_dispatch(__first, __last, __false_type()); }
void
assign(initializer_list<bool> __l)
{ this->assign(__l.begin(), __l.end()); }
iterator
begin() noexcept
{ return this->_M_impl._M_start; }
const_iterator
begin() const noexcept
{ return this->_M_impl._M_start; }
iterator
end() noexcept
{ return this->_M_impl._M_finish; }
const_iterator
end() const noexcept
{ return this->_M_impl._M_finish; }
reverse_iterator
rbegin() noexcept
{ return reverse_iterator(end()); }
const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(end()); }
reverse_iterator
rend() noexcept
{ return reverse_iterator(begin()); }
const_reverse_iterator
rend() const noexcept
{ return const_reverse_iterator(begin()); }
const_iterator
cbegin() const noexcept
{ return this->_M_impl._M_start; }
const_iterator
cend() const noexcept
{ return this->_M_impl._M_finish; }
const_reverse_iterator
crbegin() const noexcept
{ return const_reverse_iterator(end()); }
const_reverse_iterator
crend() const noexcept
{ return const_reverse_iterator(begin()); }
size_type
size() const noexcept
{ return size_type(end() - begin()); }
size_type
max_size() const noexcept
{
const size_type __isize =
__gnu_cxx::__numeric_traits<difference_type>::__max
- int(_S_word_bit) + 1;
const size_type __asize = _M_get_Bit_allocator().max_size();
return (__asize <= __isize / int(_S_word_bit)
? __asize * int(_S_word_bit) : __isize);
}
size_type
capacity() const noexcept
{ return size_type(const_iterator(this->_M_impl._M_end_of_storage, 0)
- begin()); }
bool
empty() const noexcept
{ return begin() == end(); }
reference
operator[](size_type __n)
{
return *iterator(this->_M_impl._M_start._M_p
+ __n / int(_S_word_bit), __n % int(_S_word_bit));
}
const_reference
operator[](size_type __n) const
{
return *const_iterator(this->_M_impl._M_start._M_p
+ __n / int(_S_word_bit), __n % int(_S_word_bit));
}
protected:
void
_M_range_check(size_type __n) const
{
if (__n >= this->size())
__throw_out_of_range_fmt(("vector<bool>::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"),
__n, this->size());
}
public:
reference
at(size_type __n)
{ _M_range_check(__n); return (*this)[__n]; }
const_reference
at(size_type __n) const
{ _M_range_check(__n); return (*this)[__n]; }
void
reserve(size_type __n)
{
if (__n > max_size())
__throw_length_error(("vector::reserve"));
if (capacity() < __n)
_M_reallocate(__n);
}
reference
front()
{ return *begin(); }
const_reference
front() const
{ return *begin(); }
reference
back()
{ return *(end() - 1); }
const_reference
back() const
{ return *(end() - 1); }
void
data() noexcept { }
void
push_back(bool __x)
{
if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
*this->_M_impl._M_finish++ = __x;
else
_M_insert_aux(end(), __x);
}
void
swap(vector& __x)
{
std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
std::swap(this->_M_impl._M_end_of_storage,
__x._M_impl._M_end_of_storage);
std::__alloc_swap<typename _Base::_Bit_alloc_type>::
_S_do_it(_M_get_Bit_allocator(), __x._M_get_Bit_allocator());
}
static void
swap(reference __x, reference __y) noexcept
{
bool __tmp = __x;
__x = __y;
__y = __tmp;
}
iterator
insert(const_iterator __position, const bool& __x = bool())
{
const difference_type __n = __position - begin();
if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage
&& __position == end())
*this->_M_impl._M_finish++ = __x;
else
_M_insert_aux(__position._M_const_cast(), __x);
return begin() + __n;
}
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
iterator
insert(const_iterator __position,
_InputIterator __first, _InputIterator __last)
{
difference_type __offset = __position - cbegin();
_M_insert_dispatch(__position._M_const_cast(),
__first, __last, __false_type());
return begin() + __offset;
}
iterator
insert(const_iterator __position, size_type __n, const bool& __x)
{
difference_type __offset = __position - cbegin();
_M_fill_insert(__position._M_const_cast(), __n, __x);
return begin() + __offset;
}
iterator
insert(const_iterator __p, initializer_list<bool> __l)
{ return this->insert(__p, __l.begin(), __l.end()); }
void
pop_back()
{ --this->_M_impl._M_finish; }
iterator
erase(const_iterator __position)
{ return _M_erase(__position._M_const_cast()); }
iterator
erase(const_iterator __first, const_iterator __last)
{ return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
void
resize(size_type __new_size, bool __x = bool())
{
if (__new_size < size())
_M_erase_at_end(begin() + difference_type(__new_size));
else
insert(end(), __new_size - size(), __x);
}
void
shrink_to_fit()
{ _M_shrink_to_fit(); }
void
flip() noexcept
{
for (_Bit_type * __p = this->_M_impl._M_start._M_p;
__p != this->_M_impl._M_end_of_storage; ++__p)
*__p = ~*__p;
}
void
clear() noexcept
{ _M_erase_at_end(begin()); }
template<typename... _Args>
void
emplace_back(_Args&&... __args)
{ push_back(bool(__args...)); }
template<typename... _Args>
iterator
emplace(const_iterator __pos, _Args&&... __args)
{ return insert(__pos, bool(__args...)); }
protected:
iterator
_M_copy_aligned(const_iterator __first, const_iterator __last,
iterator __result)
{
_Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
return std::copy(const_iterator(__last._M_p, 0), __last,
iterator(__q, 0));
}
void
_M_initialize(size_type __n)
{
_Bit_type* __q = this->_M_allocate(__n);
this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
this->_M_impl._M_start = iterator(__q, 0);
this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
}
void
_M_reallocate(size_type __n);
bool
_M_shrink_to_fit();
template<typename _Integer>
void
_M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
;
template<typename _InputIterator>
void
_M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
;
template<typename _InputIterator>
void
_M_initialize_range(_InputIterator __first, _InputIterator __last,
std::input_iterator_tag)
;
template<typename _ForwardIterator>
void
_M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
std::forward_iterator_tag)
;
template<typename _Integer>
void
_M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
;
template<class _InputIterator>
void
_M_assign_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
;
void
_M_fill_assign(size_t __n, bool __x)
;
template<typename _InputIterator>
void
_M_assign_aux(_InputIterator __first, _InputIterator __last,
std::input_iterator_tag)
;
template<typename _ForwardIterator>
void
_M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
std::forward_iterator_tag)
;
template<typename _Integer>
void
_M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
__true_type)
;
template<typename _InputIterator>
void
_M_insert_dispatch(iterator __pos,
_InputIterator __first, _InputIterator __last,
__false_type)
;
void
_M_fill_insert(iterator __position, size_type __n, bool __x);
template<typename _InputIterator>
void
_M_insert_range(iterator __pos, _InputIterator __first,
_InputIterator __last, std::input_iterator_tag)
;
template<typename _ForwardIterator>
void
_M_insert_range(iterator __position, _ForwardIterator __first,
_ForwardIterator __last, std::forward_iterator_tag);
void
_M_insert_aux(iterator __position, bool __x);
size_type
_M_check_len(size_type __n, const char* __s) const
;
void
_M_erase_at_end(iterator __pos)
;
iterator
_M_erase(iterator __pos);
iterator
_M_erase(iterator __first, iterator __last);
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc>
struct hash<std::vector<bool, _Alloc>>
: public __hash_base<size_t, std::vector<bool, _Alloc>>
{
size_t
operator()(const std::vector<bool, _Alloc>&) const noexcept;
};
}
#define _VECTOR_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc>
size_t
hash<std::vector<bool, _Alloc>>::
operator()(const std::vector<bool, _Alloc>& __b) const noexcept
{
size_t __hash = 0;
using std::_S_word_bit;
using std::_Bit_type;
const size_t __words = __b.size() / _S_word_bit;
if (__words)
{
const size_t __clength = __words * sizeof(_Bit_type);
__hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength);
}
const size_t __extrabits = __b.size() % _S_word_bit;
if (__extrabits)
{
_Bit_type __hiword = *__b._M_impl._M_finish._M_p;
__hiword &= ~((~static_cast<_Bit_type>(0)) << __extrabits);
const size_t __clength
= (__extrabits + 8 - 1) / 8;
if (__words)
__hash = std::_Hash_impl::hash(&__hiword, __clength, __hash);
else
__hash = std::_Hash_impl::hash(&__hiword, __clength);
}
return __hash;
}
}
namespace boost {
namespace asio {
namespace detail {
}
}
}
namespace boost {
namespace asio {
template <typename Service>
Service& use_service(io_service& ios)
;
template <> detail::io_service_impl& use_service<detail::io_service_impl>(
io_service& ios)
;
template <typename Service>
void add_service(io_service& ios, Service* svc)
;
template <typename Service>
bool has_service(io_service& ios)
;
}
}
#define BOOST_ASIO_DETAIL_TASK_IO_SERVICE_HPP
#define BOOST_ASIO_DETAIL_ATOMIC_COUNT_HPP
#define _GLIBCXX_ATOMIC 1
#define _GLIBCXX_ATOMIC_BASE_H 1
#define _STDBOOL_H
#define _Bool bool
#define bool bool
#define false false
#define true true
#define __bool_true_false_are_defined 1
#define _GLIBCXX_ALWAYS_INLINE inline __attribute__((always_inline))
namespace std __attribute__ ((__visibility__ ("default")))
{
typedef enum memory_order
{
memory_order_relaxed,
memory_order_consume,
memory_order_acquire,
memory_order_release,
memory_order_acq_rel,
memory_order_seq_cst
} memory_order;
enum __memory_order_modifier
{
__memory_order_mask = 0x0ffff,
__memory_order_modifier_mask = 0xffff0000,
__memory_order_hle_acquire = 0x10000,
__memory_order_hle_release = 0x20000
};
constexpr memory_order
operator|(memory_order __m, __memory_order_modifier __mod)
{
return memory_order(__m | int(__mod));
}
constexpr memory_order
operator&(memory_order __m, __memory_order_modifier __mod)
{
return memory_order(__m & int(__mod));
}
constexpr memory_order
__cmpexch_failure_order2(memory_order __m) noexcept
{
return __m == memory_order_acq_rel ? memory_order_acquire
: __m == memory_order_release ? memory_order_relaxed : __m;
}
constexpr memory_order
__cmpexch_failure_order(memory_order __m) noexcept
{
return memory_order(__cmpexch_failure_order2(__m & __memory_order_mask)
| (__m & __memory_order_modifier_mask));
}
inline __attribute__((always_inline)) void
atomic_thread_fence(memory_order __m) noexcept
{ __atomic_thread_fence(__m); }
inline __attribute__((always_inline)) void
atomic_signal_fence(memory_order __m) noexcept
{ __atomic_signal_fence(__m); }
template<typename _Tp>
inline _Tp
kill_dependency(_Tp __y) noexcept
{
_Tp __ret(__y);
return __ret;
}
template<typename _IntTp>
struct __atomic_base;
typedef __atomic_base<char> atomic_char;
typedef __atomic_base<signed char> atomic_schar;
typedef __atomic_base<unsigned char> atomic_uchar;
typedef __atomic_base<short> atomic_short;
typedef __atomic_base<unsigned short> atomic_ushort;
typedef __atomic_base<int> atomic_int;
typedef __atomic_base<unsigned int> atomic_uint;
typedef __atomic_base<long> atomic_long;
typedef __atomic_base<unsigned long> atomic_ulong;
typedef __atomic_base<long long> atomic_llong;
typedef __atomic_base<unsigned long long> atomic_ullong;
typedef __atomic_base<wchar_t> atomic_wchar_t;
typedef __atomic_base<char16_t> atomic_char16_t;
typedef __atomic_base<char32_t> atomic_char32_t;
typedef __atomic_base<char32_t> atomic_char32_t;
typedef __atomic_base<int_least8_t> atomic_int_least8_t;
typedef __atomic_base<uint_least8_t> atomic_uint_least8_t;
typedef __atomic_base<int_least16_t> atomic_int_least16_t;
typedef __atomic_base<uint_least16_t> atomic_uint_least16_t;
typedef __atomic_base<int_least32_t> atomic_int_least32_t;
typedef __atomic_base<uint_least32_t> atomic_uint_least32_t;
typedef __atomic_base<int_least64_t> atomic_int_least64_t;
typedef __atomic_base<uint_least64_t> atomic_uint_least64_t;
typedef __atomic_base<int_fast8_t> atomic_int_fast8_t;
typedef __atomic_base<uint_fast8_t> atomic_uint_fast8_t;
typedef __atomic_base<int_fast16_t> atomic_int_fast16_t;
typedef __atomic_base<uint_fast16_t> atomic_uint_fast16_t;
typedef __atomic_base<int_fast32_t> atomic_int_fast32_t;
typedef __atomic_base<uint_fast32_t> atomic_uint_fast32_t;
typedef __atomic_base<int_fast64_t> atomic_int_fast64_t;
typedef __atomic_base<uint_fast64_t> atomic_uint_fast64_t;
typedef __atomic_base<intptr_t> atomic_intptr_t;
typedef __atomic_base<uintptr_t> atomic_uintptr_t;
typedef __atomic_base<size_t> atomic_size_t;
typedef __atomic_base<intmax_t> atomic_intmax_t;
typedef __atomic_base<uintmax_t> atomic_uintmax_t;
typedef __atomic_base<ptrdiff_t> atomic_ptrdiff_t;
#define ATOMIC_VAR_INIT(_VI) { _VI }
template<typename _Tp>
struct atomic;
template<typename _Tp>
struct atomic<_Tp*>;
typedef bool __atomic_flag_data_type;
extern "C" {
struct __atomic_flag_base
{
__atomic_flag_data_type _M_i;
};
}
#define ATOMIC_FLAG_INIT { 0 }
struct atomic_flag : public __atomic_flag_base
{
atomic_flag() noexcept = default;
~atomic_flag() noexcept = default;
atomic_flag(const atomic_flag&) = delete;
atomic_flag& operator=(const atomic_flag&) = delete;
atomic_flag& operator=(const atomic_flag&) volatile = delete;
constexpr atomic_flag(bool __i) noexcept
: __atomic_flag_base{ _S_init(__i) }
{ }
inline __attribute__((always_inline)) bool
test_and_set(memory_order __m = memory_order_seq_cst) noexcept
{
return __atomic_test_and_set (&_M_i, __m);
}
inline __attribute__((always_inline)) bool
test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept
{
return __atomic_test_and_set (&_M_i, __m);
}
inline __attribute__((always_inline)) void
clear(memory_order __m = memory_order_seq_cst) noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
;
__atomic_clear (&_M_i, __m);
}
inline __attribute__((always_inline)) void
clear(memory_order __m = memory_order_seq_cst) volatile noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
;
__atomic_clear (&_M_i, __m);
}
private:
static constexpr __atomic_flag_data_type
_S_init(bool __i)
{ return __i ? 1 : 0; }
};
template<typename _ITp>
struct __atomic_base
{
private:
typedef _ITp __int_type;
__int_type _M_i;
public:
__atomic_base() noexcept = default;
~__atomic_base() noexcept = default;
__atomic_base(const __atomic_base&) = delete;
__atomic_base& operator=(const __atomic_base&) = delete;
__atomic_base& operator=(const __atomic_base&) volatile = delete;
constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { }
operator __int_type() const noexcept
{ return load(); }
operator __int_type() const volatile noexcept
{ return load(); }
__int_type
operator=(__int_type __i) noexcept
{
store(__i);
return __i;
}
__int_type
operator=(__int_type __i) volatile noexcept
{
store(__i);
return __i;
}
__int_type
operator++(int) noexcept
{ return fetch_add(1); }
__int_type
operator++(int) volatile noexcept
{ return fetch_add(1); }
__int_type
operator--(int) noexcept
{ return fetch_sub(1); }
__int_type
operator--(int) volatile noexcept
{ return fetch_sub(1); }
__int_type
operator++() noexcept
{ return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }
__int_type
operator++() volatile noexcept
{ return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }
__int_type
operator--() noexcept
{ return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }
__int_type
operator--() volatile noexcept
{ return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }
__int_type
operator+=(__int_type __i) noexcept
{ return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator+=(__int_type __i) volatile noexcept
{ return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator-=(__int_type __i) noexcept
{ return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator-=(__int_type __i) volatile noexcept
{ return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator&=(__int_type __i) noexcept
{ return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator&=(__int_type __i) volatile noexcept
{ return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator|=(__int_type __i) noexcept
{ return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator|=(__int_type __i) volatile noexcept
{ return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator^=(__int_type __i) noexcept
{ return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }
__int_type
operator^=(__int_type __i) volatile noexcept
{ return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }
bool
is_lock_free() const noexcept
{ return __atomic_is_lock_free(sizeof(_M_i), nullptr); }
bool
is_lock_free() const volatile noexcept
{ return __atomic_is_lock_free(sizeof(_M_i), nullptr); }
inline __attribute__((always_inline)) void
store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
;
__atomic_store_n(&_M_i, __i, __m);
}
inline __attribute__((always_inline)) void
store(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
;
__atomic_store_n(&_M_i, __i, __m);
}
inline __attribute__((always_inline)) __int_type
load(memory_order __m = memory_order_seq_cst) const noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
return __atomic_load_n(&_M_i, __m);
}
inline __attribute__((always_inline)) __int_type
load(memory_order __m = memory_order_seq_cst) const volatile noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
return __atomic_load_n(&_M_i, __m);
}
inline __attribute__((always_inline)) __int_type
exchange(__int_type __i,
memory_order __m = memory_order_seq_cst) noexcept
{
return __atomic_exchange_n(&_M_i, __i, __m);
}
inline __attribute__((always_inline)) __int_type
exchange(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
return __atomic_exchange_n(&_M_i, __i, __m);
}
inline __attribute__((always_inline)) bool
compare_exchange_weak(__int_type& __i1, __int_type __i2,
memory_order __m1, memory_order __m2) noexcept
{
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;
;
;
;
return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
}
inline __attribute__((always_inline)) bool
compare_exchange_weak(__int_type& __i1, __int_type __i2,
memory_order __m1,
memory_order __m2) volatile noexcept
{
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;
;
;
;
return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
}
inline __attribute__((always_inline)) bool
compare_exchange_weak(__int_type& __i1, __int_type __i2,
memory_order __m = memory_order_seq_cst) noexcept
{
return compare_exchange_weak(__i1, __i2, __m,
__cmpexch_failure_order(__m));
}
inline __attribute__((always_inline)) bool
compare_exchange_weak(__int_type& __i1, __int_type __i2,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
return compare_exchange_weak(__i1, __i2, __m,
__cmpexch_failure_order(__m));
}
inline __attribute__((always_inline)) bool
compare_exchange_strong(__int_type& __i1, __int_type __i2,
memory_order __m1, memory_order __m2) noexcept
{
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;
;
;
;
return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
}
inline __attribute__((always_inline)) bool
compare_exchange_strong(__int_type& __i1, __int_type __i2,
memory_order __m1,
memory_order __m2) volatile noexcept
{
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;
;
;
;
return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
}
inline __attribute__((always_inline)) bool
compare_exchange_strong(__int_type& __i1, __int_type __i2,
memory_order __m = memory_order_seq_cst) noexcept
{
return compare_exchange_strong(__i1, __i2, __m,
__cmpexch_failure_order(__m));
}
inline __attribute__((always_inline)) bool
compare_exchange_strong(__int_type& __i1, __int_type __i2,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
return compare_exchange_strong(__i1, __i2, __m,
__cmpexch_failure_order(__m));
}
inline __attribute__((always_inline)) __int_type
fetch_add(__int_type __i,
memory_order __m = memory_order_seq_cst) noexcept
{ return __atomic_fetch_add(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_add(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return __atomic_fetch_add(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_sub(__int_type __i,
memory_order __m = memory_order_seq_cst) noexcept
{ return __atomic_fetch_sub(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_sub(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return __atomic_fetch_sub(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_and(__int_type __i,
memory_order __m = memory_order_seq_cst) noexcept
{ return __atomic_fetch_and(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_and(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return __atomic_fetch_and(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_or(__int_type __i,
memory_order __m = memory_order_seq_cst) noexcept
{ return __atomic_fetch_or(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_or(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return __atomic_fetch_or(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_xor(__int_type __i,
memory_order __m = memory_order_seq_cst) noexcept
{ return __atomic_fetch_xor(&_M_i, __i, __m); }
inline __attribute__((always_inline)) __int_type
fetch_xor(__int_type __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return __atomic_fetch_xor(&_M_i, __i, __m); }
};
template<typename _PTp>
struct __atomic_base<_PTp*>
{
private:
typedef _PTp* __pointer_type;
__pointer_type _M_p;
constexpr ptrdiff_t
_M_type_size(ptrdiff_t __d) const { return __d * sizeof(_PTp); }
constexpr ptrdiff_t
_M_type_size(ptrdiff_t __d) const volatile { return __d * sizeof(_PTp); }
public:
__atomic_base() noexcept = default;
~__atomic_base() noexcept = default;
__atomic_base(const __atomic_base&) = delete;
__atomic_base& operator=(const __atomic_base&) = delete;
__atomic_base& operator=(const __atomic_base&) volatile = delete;
constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { }
operator __pointer_type() const noexcept
{ return load(); }
operator __pointer_type() const volatile noexcept
{ return load(); }
__pointer_type
operator=(__pointer_type __p) noexcept
{
store(__p);
return __p;
}
__pointer_type
operator=(__pointer_type __p) volatile noexcept
{
store(__p);
return __p;
}
__pointer_type
operator++(int) noexcept
{ return fetch_add(1); }
__pointer_type
operator++(int) volatile noexcept
{ return fetch_add(1); }
__pointer_type
operator--(int) noexcept
{ return fetch_sub(1); }
__pointer_type
operator--(int) volatile noexcept
{ return fetch_sub(1); }
__pointer_type
operator++() noexcept
{ return __atomic_add_fetch(&_M_p, _M_type_size(1),
memory_order_seq_cst); }
__pointer_type
operator++() volatile noexcept
{ return __atomic_add_fetch(&_M_p, _M_type_size(1),
memory_order_seq_cst); }
__pointer_type
operator--() noexcept
{ return __atomic_sub_fetch(&_M_p, _M_type_size(1),
memory_order_seq_cst); }
__pointer_type
operator--() volatile noexcept
{ return __atomic_sub_fetch(&_M_p, _M_type_size(1),
memory_order_seq_cst); }
__pointer_type
operator+=(ptrdiff_t __d) noexcept
{ return __atomic_add_fetch(&_M_p, _M_type_size(__d),
memory_order_seq_cst); }
__pointer_type
operator+=(ptrdiff_t __d) volatile noexcept
{ return __atomic_add_fetch(&_M_p, _M_type_size(__d),
memory_order_seq_cst); }
__pointer_type
operator-=(ptrdiff_t __d) noexcept
{ return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
memory_order_seq_cst); }
__pointer_type
operator-=(ptrdiff_t __d) volatile noexcept
{ return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
memory_order_seq_cst); }
bool
is_lock_free() const noexcept
{ return __atomic_is_lock_free(sizeof(__pointer_type), nullptr); }
bool
is_lock_free() const volatile noexcept
{ return __atomic_is_lock_free(sizeof(__pointer_type), nullptr); }
inline __attribute__((always_inline)) void
store(__pointer_type __p,
memory_order __m = memory_order_seq_cst) noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
;
__atomic_store_n(&_M_p, __p, __m);
}
inline __attribute__((always_inline)) void
store(__pointer_type __p,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
;
__atomic_store_n(&_M_p, __p, __m);
}
inline __attribute__((always_inline)) __pointer_type
load(memory_order __m = memory_order_seq_cst) const noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
return __atomic_load_n(&_M_p, __m);
}
inline __attribute__((always_inline)) __pointer_type
load(memory_order __m = memory_order_seq_cst) const volatile noexcept
{
memory_order __b = __m & __memory_order_mask;
;
;
return __atomic_load_n(&_M_p, __m);
}
inline __attribute__((always_inline)) __pointer_type
exchange(__pointer_type __p,
memory_order __m = memory_order_seq_cst) noexcept
{
return __atomic_exchange_n(&_M_p, __p, __m);
}
inline __attribute__((always_inline)) __pointer_type
exchange(__pointer_type __p,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
return __atomic_exchange_n(&_M_p, __p, __m);
}
inline __attribute__((always_inline)) bool
compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
memory_order __m1,
memory_order __m2) noexcept
{
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;
;
;
;
return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
}
inline __attribute__((always_inline)) bool
compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
memory_order __m1,
memory_order __m2) volatile noexcept
{
memory_order __b2 = __m2 & __memory_order_mask;
memory_order __b1 = __m1 & __memory_order_mask;
;
;
;
return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
}
inline __attribute__((always_inline)) __pointer_type
fetch_add(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) noexcept
{ return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); }
inline __attribute__((always_inline)) __pointer_type
fetch_add(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); }
inline __attribute__((always_inline)) __pointer_type
fetch_sub(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) noexcept
{ return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); }
inline __attribute__((always_inline)) __pointer_type
fetch_sub(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); }
};
}
namespace std __attribute__ ((__visibility__ ("default")))
{
struct atomic_bool
{
private:
__atomic_base<bool> _M_base;
public:
atomic_bool() noexcept = default;
~atomic_bool() noexcept = default;
atomic_bool(const atomic_bool&) = delete;
atomic_bool& operator=(const atomic_bool&) = delete;
atomic_bool& operator=(const atomic_bool&) volatile = delete;
constexpr atomic_bool(bool __i) noexcept : _M_base(__i) { }
bool
operator=(bool __i) noexcept
{ return _M_base.operator=(__i); }
bool
operator=(bool __i) volatile noexcept
{ return _M_base.operator=(__i); }
operator bool() const noexcept
{ return _M_base.load(); }
operator bool() const volatile noexcept
{ return _M_base.load(); }
bool
is_lock_free() const noexcept { return _M_base.is_lock_free(); }
bool
is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); }
void
store(bool __i, memory_order __m = memory_order_seq_cst) noexcept
{ _M_base.store(__i, __m); }
void
store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept
{ _M_base.store(__i, __m); }
bool
load(memory_order __m = memory_order_seq_cst) const noexcept
{ return _M_base.load(__m); }
bool
load(memory_order __m = memory_order_seq_cst) const volatile noexcept
{ return _M_base.load(__m); }
bool
exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept
{ return _M_base.exchange(__i, __m); }
bool
exchange(bool __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return _M_base.exchange(__i, __m); }
bool
compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
memory_order __m2) noexcept
{ return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
bool
compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
memory_order __m2) volatile noexcept
{ return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
bool
compare_exchange_weak(bool& __i1, bool __i2,
memory_order __m = memory_order_seq_cst) noexcept
{ return _M_base.compare_exchange_weak(__i1, __i2, __m); }
bool
compare_exchange_weak(bool& __i1, bool __i2,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return _M_base.compare_exchange_weak(__i1, __i2, __m); }
bool
compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
memory_order __m2) noexcept
{ return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
bool
compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
memory_order __m2) volatile noexcept
{ return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
bool
compare_exchange_strong(bool& __i1, bool __i2,
memory_order __m = memory_order_seq_cst) noexcept
{ return _M_base.compare_exchange_strong(__i1, __i2, __m); }
bool
compare_exchange_strong(bool& __i1, bool __i2,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return _M_base.compare_exchange_strong(__i1, __i2, __m); }
};
template<typename _Tp>
struct atomic
{
private:
_Tp _M_i;
static_assert(sizeof(_Tp) > 0,
"Incomplete or zero-sized types are not supported");
public:
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(_Tp __i) noexcept : _M_i(__i) { }
operator _Tp() const noexcept
{ return load(); }
operator _Tp() const volatile noexcept
{ return load(); }
_Tp
operator=(_Tp __i) noexcept
{ store(__i); return __i; }
_Tp
operator=(_Tp __i) volatile noexcept
{ store(__i); return __i; }
bool
is_lock_free() const noexcept
{ return __atomic_is_lock_free(sizeof(_M_i), nullptr); }
bool
is_lock_free() const volatile noexcept
{ return __atomic_is_lock_free(sizeof(_M_i), nullptr); }
void
store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
{ __atomic_store(&_M_i, &__i, __m); }
void
store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept
{ __atomic_store(&_M_i, &__i, __m); }
_Tp
load(memory_order __m = memory_order_seq_cst) const noexcept
{
_Tp tmp;
__atomic_load(&_M_i, &tmp, __m);
return tmp;
}
_Tp
load(memory_order __m = memory_order_seq_cst) const volatile noexcept
{
_Tp tmp;
__atomic_load(&_M_i, &tmp, __m);
return tmp;
}
_Tp
exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
{
_Tp tmp;
__atomic_exchange(&_M_i, &__i, &tmp, __m);
return tmp;
}
_Tp
exchange(_Tp __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
_Tp tmp;
__atomic_exchange(&_M_i, &__i, &tmp, __m);
return tmp;
}
bool
compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
memory_order __f) noexcept
{
return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f);
}
bool
compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
memory_order __f) volatile noexcept
{
return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f);
}
bool
compare_exchange_weak(_Tp& __e, _Tp __i,
memory_order __m = memory_order_seq_cst) noexcept
{ return compare_exchange_weak(__e, __i, __m,
__cmpexch_failure_order(__m)); }
bool
compare_exchange_weak(_Tp& __e, _Tp __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return compare_exchange_weak(__e, __i, __m,
__cmpexch_failure_order(__m)); }
bool
compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
memory_order __f) noexcept
{
return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f);
}
bool
compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
memory_order __f) volatile noexcept
{
return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f);
}
bool
compare_exchange_strong(_Tp& __e, _Tp __i,
memory_order __m = memory_order_seq_cst) noexcept
{ return compare_exchange_strong(__e, __i, __m,
__cmpexch_failure_order(__m)); }
bool
compare_exchange_strong(_Tp& __e, _Tp __i,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return compare_exchange_strong(__e, __i, __m,
__cmpexch_failure_order(__m)); }
};
template<typename _Tp>
struct atomic<_Tp*>
{
typedef _Tp* __pointer_type;
typedef __atomic_base<_Tp*> __base_type;
__base_type _M_b;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }
operator __pointer_type() const noexcept
{ return __pointer_type(_M_b); }
operator __pointer_type() const volatile noexcept
{ return __pointer_type(_M_b); }
__pointer_type
operator=(__pointer_type __p) noexcept
{ return _M_b.operator=(__p); }
__pointer_type
operator=(__pointer_type __p) volatile noexcept
{ return _M_b.operator=(__p); }
__pointer_type
operator++(int) noexcept
{ return _M_b++; }
__pointer_type
operator++(int) volatile noexcept
{ return _M_b++; }
__pointer_type
operator--(int) noexcept
{ return _M_b--; }
__pointer_type
operator--(int) volatile noexcept
{ return _M_b--; }
__pointer_type
operator++() noexcept
{ return ++_M_b; }
__pointer_type
operator++() volatile noexcept
{ return ++_M_b; }
__pointer_type
operator--() noexcept
{ return --_M_b; }
__pointer_type
operator--() volatile noexcept
{ return --_M_b; }
__pointer_type
operator+=(ptrdiff_t __d) noexcept
{ return _M_b.operator+=(__d); }
__pointer_type
operator+=(ptrdiff_t __d) volatile noexcept
{ return _M_b.operator+=(__d); }
__pointer_type
operator-=(ptrdiff_t __d) noexcept
{ return _M_b.operator-=(__d); }
__pointer_type
operator-=(ptrdiff_t __d) volatile noexcept
{ return _M_b.operator-=(__d); }
bool
is_lock_free() const noexcept
{ return _M_b.is_lock_free(); }
bool
is_lock_free() const volatile noexcept
{ return _M_b.is_lock_free(); }
void
store(__pointer_type __p,
memory_order __m = memory_order_seq_cst) noexcept
{ return _M_b.store(__p, __m); }
void
store(__pointer_type __p,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return _M_b.store(__p, __m); }
__pointer_type
load(memory_order __m = memory_order_seq_cst) const noexcept
{ return _M_b.load(__m); }
__pointer_type
load(memory_order __m = memory_order_seq_cst) const volatile noexcept
{ return _M_b.load(__m); }
__pointer_type
exchange(__pointer_type __p,
memory_order __m = memory_order_seq_cst) noexcept
{ return _M_b.exchange(__p, __m); }
__pointer_type
exchange(__pointer_type __p,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return _M_b.exchange(__p, __m); }
bool
compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
memory_order __m1, memory_order __m2) noexcept
{ return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
bool
compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
memory_order __m1,
memory_order __m2) volatile noexcept
{ return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
bool
compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
memory_order __m = memory_order_seq_cst) noexcept
{
return compare_exchange_weak(__p1, __p2, __m,
__cmpexch_failure_order(__m));
}
bool
compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
return compare_exchange_weak(__p1, __p2, __m,
__cmpexch_failure_order(__m));
}
bool
compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
memory_order __m1, memory_order __m2) noexcept
{ return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
bool
compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
memory_order __m1,
memory_order __m2) volatile noexcept
{ return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
bool
compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
memory_order __m = memory_order_seq_cst) noexcept
{
return _M_b.compare_exchange_strong(__p1, __p2, __m,
__cmpexch_failure_order(__m));
}
bool
compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
memory_order __m = memory_order_seq_cst) volatile noexcept
{
return _M_b.compare_exchange_strong(__p1, __p2, __m,
__cmpexch_failure_order(__m));
}
__pointer_type
fetch_add(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) noexcept
{ return _M_b.fetch_add(__d, __m); }
__pointer_type
fetch_add(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return _M_b.fetch_add(__d, __m); }
__pointer_type
fetch_sub(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) noexcept
{ return _M_b.fetch_sub(__d, __m); }
__pointer_type
fetch_sub(ptrdiff_t __d,
memory_order __m = memory_order_seq_cst) volatile noexcept
{ return _M_b.fetch_sub(__d, __m); }
};
template<>
struct atomic<bool> : public atomic_bool
{
typedef bool __integral_type;
typedef atomic_bool __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<char> : public atomic_char
{
typedef char __integral_type;
typedef atomic_char __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<signed char> : public atomic_schar
{
typedef signed char __integral_type;
typedef atomic_schar __base_type;
atomic() noexcept= default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<unsigned char> : public atomic_uchar
{
typedef unsigned char __integral_type;
typedef atomic_uchar __base_type;
atomic() noexcept= default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<short> : public atomic_short
{
typedef short __integral_type;
typedef atomic_short __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<unsigned short> : public atomic_ushort
{
typedef unsigned short __integral_type;
typedef atomic_ushort __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<int> : atomic_int
{
typedef int __integral_type;
typedef atomic_int __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<unsigned int> : public atomic_uint
{
typedef unsigned int __integral_type;
typedef atomic_uint __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<long> : public atomic_long
{
typedef long __integral_type;
typedef atomic_long __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<unsigned long> : public atomic_ulong
{
typedef unsigned long __integral_type;
typedef atomic_ulong __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<long long> : public atomic_llong
{
typedef long long __integral_type;
typedef atomic_llong __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<unsigned long long> : public atomic_ullong
{
typedef unsigned long long __integral_type;
typedef atomic_ullong __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<wchar_t> : public atomic_wchar_t
{
typedef wchar_t __integral_type;
typedef atomic_wchar_t __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<char16_t> : public atomic_char16_t
{
typedef char16_t __integral_type;
typedef atomic_char16_t __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
template<>
struct atomic<char32_t> : public atomic_char32_t
{
typedef char32_t __integral_type;
typedef atomic_char32_t __base_type;
atomic() noexcept = default;
~atomic() noexcept = default;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
using __base_type::operator __integral_type;
using __base_type::operator=;
};
inline bool
atomic_flag_test_and_set_explicit(atomic_flag* __a,
memory_order __m) noexcept
{ return __a->test_and_set(__m); }
inline bool
atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
memory_order __m) noexcept
{ return __a->test_and_set(__m); }
inline void
atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept
{ __a->clear(__m); }
inline void
atomic_flag_clear_explicit(volatile atomic_flag* __a,
memory_order __m) noexcept
{ __a->clear(__m); }
inline bool
atomic_flag_test_and_set(atomic_flag* __a) noexcept
{ return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
inline bool
atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept
{ return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
inline void
atomic_flag_clear(atomic_flag* __a) noexcept
{ atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
inline void
atomic_flag_clear(volatile atomic_flag* __a) noexcept
{ atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
template<typename _ITp>
inline bool
atomic_is_lock_free(const atomic<_ITp>* __a) noexcept
{ return __a->is_lock_free(); }
template<typename _ITp>
inline bool
atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept
{ return __a->is_lock_free(); }
template<typename _ITp>
inline void
atomic_init(atomic<_ITp>* __a, _ITp __i) noexcept;
template<typename _ITp>
inline void
atomic_init(volatile atomic<_ITp>* __a, _ITp __i) noexcept;
template<typename _ITp>
inline void
atomic_store_explicit(atomic<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ __a->store(__i, __m); }
template<typename _ITp>
inline void
atomic_store_explicit(volatile atomic<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ __a->store(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept
{ return __a->load(__m); }
template<typename _ITp>
inline _ITp
atomic_load_explicit(const volatile atomic<_ITp>* __a,
memory_order __m) noexcept
{ return __a->load(__m); }
template<typename _ITp>
inline _ITp
atomic_exchange_explicit(atomic<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->exchange(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_exchange_explicit(volatile atomic<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->exchange(__i, __m); }
template<typename _ITp>
inline bool
atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2,
memory_order __m1,
memory_order __m2) noexcept
{ return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
template<typename _ITp>
inline bool
atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2,
memory_order __m1,
memory_order __m2) noexcept
{ return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
template<typename _ITp>
inline bool
atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2,
memory_order __m1,
memory_order __m2) noexcept
{ return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
template<typename _ITp>
inline bool
atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2,
memory_order __m1,
memory_order __m2) noexcept
{ return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
template<typename _ITp>
inline void
atomic_store(atomic<_ITp>* __a, _ITp __i) noexcept
{ atomic_store_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline void
atomic_store(volatile atomic<_ITp>* __a, _ITp __i) noexcept
{ atomic_store_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_load(const atomic<_ITp>* __a) noexcept
{ return atomic_load_explicit(__a, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_load(const volatile atomic<_ITp>* __a) noexcept
{ return atomic_load_explicit(__a, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_exchange(atomic<_ITp>* __a, _ITp __i) noexcept
{ return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_exchange(volatile atomic<_ITp>* __a, _ITp __i) noexcept
{ return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline bool
atomic_compare_exchange_weak(atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2) noexcept
{
return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
memory_order_seq_cst,
memory_order_seq_cst);
}
template<typename _ITp>
inline bool
atomic_compare_exchange_weak(volatile atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2) noexcept
{
return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
memory_order_seq_cst,
memory_order_seq_cst);
}
template<typename _ITp>
inline bool
atomic_compare_exchange_strong(atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2) noexcept
{
return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
memory_order_seq_cst,
memory_order_seq_cst);
}
template<typename _ITp>
inline bool
atomic_compare_exchange_strong(volatile atomic<_ITp>* __a,
_ITp* __i1, _ITp __i2) noexcept
{
return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
memory_order_seq_cst,
memory_order_seq_cst);
}
template<typename _ITp>
inline _ITp
atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_add(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_add(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_sub(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_sub(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_and(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_and(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_or(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_or(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_xor(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
memory_order __m) noexcept
{ return __a->fetch_xor(__i, __m); }
template<typename _ITp>
inline _ITp
atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp
atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
{ return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
template<typename _ITp>
inline _ITp*
atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
memory_order __m) noexcept
{ return __a->fetch_add(__d, __m); }
template<typename _ITp>
inline _ITp*
atomic_fetch_add_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d,
memory_order __m) noexcept
{ return __a->fetch_add(__d, __m); }
template<typename _ITp>
inline _ITp*
atomic_fetch_add(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
{ return __a->fetch_add(__d); }
template<typename _ITp>
inline _ITp*
atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
{ return __a->fetch_add(__d); }
template<typename _ITp>
inline _ITp*
atomic_fetch_sub_explicit(volatile atomic<_ITp*>* __a,
ptrdiff_t __d, memory_order __m) noexcept
{ return __a->fetch_sub(__d, __m); }
template<typename _ITp>
inline _ITp*
atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
memory_order __m) noexcept
{ return __a->fetch_sub(__d, __m); }
template<typename _ITp>
inline _ITp*
atomic_fetch_sub(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
{ return __a->fetch_sub(__d); }
template<typename _ITp>
inline _ITp*
atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
{ return __a->fetch_sub(__d); }
}
namespace boost {
namespace asio {
namespace detail {
typedef std::atomic<long> atomic_count;
void increment(atomic_count& a, long b) ;
}
}
}
#define BOOST_ASIO_DETAIL_REACTOR_FWD_HPP
namespace boost {
namespace asio {
namespace detail {
typedef class epoll_reactor reactor;
}
}
}
#define BOOST_ASIO_DETAIL_TASK_IO_SERVICE_OPERATION_HPP
#define BOOST_ASIO_DETAIL_HANDLER_TRACKING_HPP
namespace boost {
namespace asio {
namespace detail {
#define BOOST_ASIO_INHERIT_TRACKED_HANDLER
#define BOOST_ASIO_ALSO_INHERIT_TRACKED_HANDLER
#define BOOST_ASIO_HANDLER_TRACKING_INIT (void)0
#define BOOST_ASIO_HANDLER_CREATION(args) (void)0
#define BOOST_ASIO_HANDLER_COMPLETION(args) (void)0
#define BOOST_ASIO_HANDLER_INVOCATION_BEGIN(args) (void)0
#define BOOST_ASIO_HANDLER_INVOCATION_END (void)0
#define BOOST_ASIO_HANDLER_OPERATION(args) (void)0
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_HANDLER_TRACKING_IPP
namespace boost {
namespace asio {
namespace detail {
class task_io_service;
class task_io_service_operation
{
public:
void complete(task_io_service& owner,
const boost::system::error_code& ec, std::size_t bytes_transferred)
;
void destroy()
;
protected:
typedef void (*func_type)(task_io_service*,
task_io_service_operation*,
const boost::system::error_code&, std::size_t);
task_io_service_operation(func_type func)
;
~task_io_service_operation()
;
private:
friend class op_queue_access;
task_io_service_operation* next_;
func_type func_;
protected:
friend class task_io_service;
unsigned int task_result_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
struct task_io_service_thread_info;
class task_io_service
: public boost::asio::detail::service_base<task_io_service>
{
public:
typedef task_io_service_operation operation;
inline task_io_service(boost::asio::io_service& io_service,
std::size_t concurrency_hint = 0);
inline void shutdown_service();
inline void init_task();
inline std::size_t run(boost::system::error_code& ec);
inline std::size_t run_one(boost::system::error_code& ec);
inline std::size_t poll(boost::system::error_code& ec);
inline std::size_t poll_one(boost::system::error_code& ec);
inline void stop();
inline bool stopped() const;
inline void reset();
void work_started()
;
void work_finished()
;
bool can_dispatch()
;
template <typename Handler>
void dispatch(Handler& handler);
template <typename Handler>
void post(Handler& handler);
inline void post_immediate_completion(
operation* op, bool is_continuation);
inline void post_deferred_completion(operation* op);
inline void post_deferred_completions(op_queue<operation>& ops);
inline void abandon_operations(op_queue<operation>& ops);
private:
typedef task_io_service_thread_info thread_info;
inline void do_dispatch(operation* op);
inline std::size_t do_run_one(mutex::scoped_lock& lock,
thread_info& this_thread, const boost::system::error_code& ec);
inline std::size_t do_poll_one(mutex::scoped_lock& lock,
thread_info& this_thread, const boost::system::error_code& ec);
inline void stop_all_threads(mutex::scoped_lock& lock);
inline bool wake_one_idle_thread_and_unlock(
mutex::scoped_lock& lock);
inline void wake_one_thread_and_unlock(
mutex::scoped_lock& lock);
struct task_cleanup;
friend struct task_cleanup;
struct work_cleanup;
friend struct work_cleanup;
const bool one_thread_;
mutable mutex mutex_;
reactor* task_;
struct task_operation : operation
{
task_operation() ;
} task_operation_;
bool task_interrupted_;
atomic_count outstanding_work_;
op_queue<operation> op_queue_;
bool stopped_;
bool shutdown_;
typedef call_stack<task_io_service, thread_info> thread_call_stack;
thread_info* first_idle_thread_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_TASK_IO_SERVICE_HPP
#define BOOST_ASIO_DETAIL_COMPLETION_HANDLER_HPP
#define BOOST_ASIO_DETAIL_FENCED_BLOCK_HPP
#define BOOST_ASIO_DETAIL_GCC_X86_FENCED_BLOCK_HPP
namespace boost {
namespace asio {
namespace detail {
class gcc_x86_fenced_block
: private noncopyable
{
public:
enum half_t { half };
enum full_t { full };
explicit gcc_x86_fenced_block(half_t)
;
explicit gcc_x86_fenced_block(full_t)
;
~gcc_x86_fenced_block()
;
private:
static int barrier()
;
static void lbarrier()
;
static void sbarrier()
;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
typedef gcc_x86_fenced_block fenced_block;
}
}
}
#define BOOST_ASIO_DETAIL_OPERATION_HPP
namespace boost {
namespace asio {
namespace detail {
typedef task_io_service_operation operation;
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Handler>
class completion_handler : public operation
{
public:
struct ptr { Handler* h; void* v; completion_handler* p; ~ptr() ; void reset() ; };
completion_handler(Handler& h)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_TASK_IO_SERVICE_IPP
#define BOOST_ASIO_DETAIL_LIMITS_HPP
#define BOOST_LIMITS
#define _GLIBCXX_NUMERIC_LIMITS 1
#define __glibcxx_integral_traps true
#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(T) ((T)(-1) < 0)
#define __glibcxx_min(T) (__glibcxx_signed (T) ? -__glibcxx_max (T) - 1 : (T)0)
#define __glibcxx_max(T) (__glibcxx_signed (T) ? (((((T)1 << (__glibcxx_digits (T) - 1)) - 1) << 1) + 1) : ~(T)0)
#define __glibcxx_digits(T) (sizeof(T) * __CHAR_BIT__ - __glibcxx_signed (T))
#define __glibcxx_digits10(T) (__glibcxx_digits (T) * 643L / 2136)
#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
};
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;
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;
};
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> { };
template<>
struct numeric_limits<bool>
{
static constexpr bool is_specialized = true;
static constexpr bool
min() noexcept { return false; }
static constexpr bool
max() noexcept { return true; }
static constexpr bool
lowest() noexcept { return min(); }
static constexpr int digits = 1;
static constexpr int digits10 = 0;
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr bool
epsilon() noexcept { return false; }
static constexpr bool
round_error() noexcept { return false; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr bool
infinity() noexcept { return false; }
static constexpr bool
quiet_NaN() noexcept { return false; }
static constexpr bool
signaling_NaN() noexcept { return false; }
static constexpr bool
denorm_min() noexcept { return false; }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<char>
{
static constexpr bool is_specialized = true;
static constexpr char
min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); }
static constexpr char
max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); }
static constexpr char
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = ((char)(-1) < 0);
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr char
epsilon() noexcept { return 0; }
static constexpr char
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr
char infinity() noexcept { return char(); }
static constexpr char
quiet_NaN() noexcept { return char(); }
static constexpr char
signaling_NaN() noexcept { return char(); }
static constexpr char
denorm_min() noexcept { return static_cast<char>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<signed char>
{
static constexpr bool is_specialized = true;
static constexpr signed char
min() noexcept { return -0x7f - 1; }
static constexpr signed char
max() noexcept { return 0x7f; }
static constexpr signed char
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
static constexpr int digits10
= ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr signed char
epsilon() noexcept { return 0; }
static constexpr signed char
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr signed char
infinity() noexcept { return static_cast<signed char>(0); }
static constexpr signed char
quiet_NaN() noexcept { return static_cast<signed char>(0); }
static constexpr signed char
signaling_NaN() noexcept
{ return static_cast<signed char>(0); }
static constexpr signed char
denorm_min() noexcept
{ return static_cast<signed char>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned char>
{
static constexpr bool is_specialized = true;
static constexpr unsigned char
min() noexcept { return 0; }
static constexpr unsigned char
max() noexcept { return 0x7f * 2U + 1; }
static constexpr unsigned char
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
static constexpr int digits10
= ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned char
epsilon() noexcept { return 0; }
static constexpr unsigned char
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned char
infinity() noexcept
{ return static_cast<unsigned char>(0); }
static constexpr unsigned char
quiet_NaN() noexcept
{ return static_cast<unsigned char>(0); }
static constexpr unsigned char
signaling_NaN() noexcept
{ return static_cast<unsigned char>(0); }
static constexpr unsigned char
denorm_min() noexcept
{ return static_cast<unsigned char>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<wchar_t>
{
static constexpr bool is_specialized = true;
static constexpr wchar_t
min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); }
static constexpr wchar_t
max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); }
static constexpr wchar_t
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
static constexpr int digits10
= ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = ((wchar_t)(-1) < 0);
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr wchar_t
epsilon() noexcept { return 0; }
static constexpr wchar_t
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr wchar_t
infinity() noexcept { return wchar_t(); }
static constexpr wchar_t
quiet_NaN() noexcept { return wchar_t(); }
static constexpr wchar_t
signaling_NaN() noexcept { return wchar_t(); }
static constexpr wchar_t
denorm_min() noexcept { return wchar_t(); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<char16_t>
{
static constexpr bool is_specialized = true;
static constexpr char16_t
min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); }
static constexpr char16_t
max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); }
static constexpr char16_t
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0));
static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = ((char16_t)(-1) < 0);
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr char16_t
epsilon() noexcept { return 0; }
static constexpr char16_t
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr char16_t
infinity() noexcept { return char16_t(); }
static constexpr char16_t
quiet_NaN() noexcept { return char16_t(); }
static constexpr char16_t
signaling_NaN() noexcept { return char16_t(); }
static constexpr char16_t
denorm_min() noexcept { return char16_t(); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
template<>
struct numeric_limits<char32_t>
{
static constexpr bool is_specialized = true;
static constexpr char32_t
min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); }
static constexpr char32_t
max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); }
static constexpr char32_t
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0));
static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = ((char32_t)(-1) < 0);
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr char32_t
epsilon() noexcept { return 0; }
static constexpr char32_t
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm = denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr char32_t
infinity() noexcept { return char32_t(); }
static constexpr char32_t
quiet_NaN() noexcept { return char32_t(); }
static constexpr char32_t
signaling_NaN() noexcept { return char32_t(); }
static constexpr char32_t
denorm_min() noexcept { return char32_t(); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};
template<>
struct numeric_limits<short>
{
static constexpr bool is_specialized = true;
static constexpr short
min() noexcept { return -0x7fff - 1; }
static constexpr short
max() noexcept { return 0x7fff; }
static constexpr short
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr short
epsilon() noexcept { return 0; }
static constexpr short
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr short
infinity() noexcept { return short(); }
static constexpr short
quiet_NaN() noexcept { return short(); }
static constexpr short
signaling_NaN() noexcept { return short(); }
static constexpr short
denorm_min() noexcept { return short(); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned short>
{
static constexpr bool is_specialized = true;
static constexpr unsigned short
min() noexcept { return 0; }
static constexpr unsigned short
max() noexcept { return 0x7fff * 2U + 1; }
static constexpr unsigned short
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
static constexpr int digits10
= ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned short
epsilon() noexcept { return 0; }
static constexpr unsigned short
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned short
infinity() noexcept
{ return static_cast<unsigned short>(0); }
static constexpr unsigned short
quiet_NaN() noexcept
{ return static_cast<unsigned short>(0); }
static constexpr unsigned short
signaling_NaN() noexcept
{ return static_cast<unsigned short>(0); }
static constexpr unsigned short
denorm_min() noexcept
{ return static_cast<unsigned short>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<int>
{
static constexpr bool is_specialized = true;
static constexpr int
min() noexcept { return -0x7fffffff - 1; }
static constexpr int
max() noexcept { return 0x7fffffff; }
static constexpr int
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr int
epsilon() noexcept { return 0; }
static constexpr int
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr int
infinity() noexcept { return static_cast<int>(0); }
static constexpr int
quiet_NaN() noexcept { return static_cast<int>(0); }
static constexpr int
signaling_NaN() noexcept { return static_cast<int>(0); }
static constexpr int
denorm_min() noexcept { return static_cast<int>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned int>
{
static constexpr bool is_specialized = true;
static constexpr unsigned int
min() noexcept { return 0; }
static constexpr unsigned int
max() noexcept { return 0x7fffffff * 2U + 1; }
static constexpr unsigned int
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
static constexpr int digits10
= ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned int
epsilon() noexcept { return 0; }
static constexpr unsigned int
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned int
infinity() noexcept { return static_cast<unsigned int>(0); }
static constexpr unsigned int
quiet_NaN() noexcept
{ return static_cast<unsigned int>(0); }
static constexpr unsigned int
signaling_NaN() noexcept
{ return static_cast<unsigned int>(0); }
static constexpr unsigned int
denorm_min() noexcept
{ return static_cast<unsigned int>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<long>
{
static constexpr bool is_specialized = true;
static constexpr long
min() noexcept { return -0x7fffffffffffffffL - 1; }
static constexpr long
max() noexcept { return 0x7fffffffffffffffL; }
static constexpr long
lowest() noexcept { return min(); }
static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr long
epsilon() noexcept { return 0; }
static constexpr long
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr long
infinity() noexcept { return static_cast<long>(0); }
static constexpr long
quiet_NaN() noexcept { return static_cast<long>(0); }
static constexpr long
signaling_NaN() noexcept { return static_cast<long>(0); }
static constexpr long
denorm_min() noexcept { return static_cast<long>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned long>
{
static constexpr bool is_specialized = true;
static constexpr unsigned long
min() noexcept { return 0; }
static constexpr unsigned long
max() noexcept { return 0x7fffffffffffffffL * 2UL + 1; }
static constexpr unsigned long
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
static constexpr int digits10
= ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned long
epsilon() noexcept { return 0; }
static constexpr unsigned long
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned long
infinity() noexcept
{ return static_cast<unsigned long>(0); }
static constexpr unsigned long
quiet_NaN() noexcept
{ return static_cast<unsigned long>(0); }
static constexpr unsigned long
signaling_NaN() noexcept
{ return static_cast<unsigned long>(0); }
static constexpr unsigned long
denorm_min() noexcept
{ return static_cast<unsigned long>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<long long>
{
static constexpr bool is_specialized = true;
static constexpr long long
min() noexcept { return -0x7fffffffffffffffLL - 1; }
static constexpr long long
max() noexcept { return 0x7fffffffffffffffLL; }
static constexpr long long
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(long long) * 8 - ((long long)(-1) < 0));
static constexpr int digits10
= ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr long long
epsilon() noexcept { return 0; }
static constexpr long long
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr long long
infinity() noexcept { return static_cast<long long>(0); }
static constexpr long long
quiet_NaN() noexcept { return static_cast<long long>(0); }
static constexpr long long
signaling_NaN() noexcept
{ return static_cast<long long>(0); }
static constexpr long long
denorm_min() noexcept { return static_cast<long long>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<unsigned long long>
{
static constexpr bool is_specialized = true;
static constexpr unsigned long long
min() noexcept { return 0; }
static constexpr unsigned long long
max() noexcept { return 0x7fffffffffffffffLL * 2ULL + 1; }
static constexpr unsigned long long
lowest() noexcept { return min(); }
static constexpr int digits
= (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
static constexpr int digits10
= ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136);
static constexpr int max_digits10 = 0;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;
static constexpr unsigned long long
epsilon() noexcept { return 0; }
static constexpr unsigned long long
round_error() noexcept { return 0; }
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr float_denorm_style has_denorm
= denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr unsigned long long
infinity() noexcept
{ return static_cast<unsigned long long>(0); }
static constexpr unsigned long long
quiet_NaN() noexcept
{ return static_cast<unsigned long long>(0); }
static constexpr unsigned long long
signaling_NaN() noexcept
{ return static_cast<unsigned long long>(0); }
static constexpr unsigned long long
denorm_min() noexcept
{ return static_cast<unsigned long long>(0); }
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};
template<>
struct numeric_limits<float>
{
static constexpr bool is_specialized = true;
static constexpr float
min() noexcept { return 1.17549435082228750797e-38F; }
static constexpr float
max() noexcept { return 3.40282346638528859812e+38F; }
static constexpr float
lowest() noexcept { return -3.40282346638528859812e+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.19209289550781250000e-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.40129846432481707092e-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 double(2.22507385850720138309e-308L); }
static constexpr double
max() noexcept { return double(1.79769313486231570815e+308L); }
static constexpr double
lowest() noexcept { return -double(1.79769313486231570815e+308L); }
static constexpr int digits = 53;
static constexpr int digits10 = 15;
static constexpr int max_digits10
= (2 + (53) * 643L / 2136);
static constexpr bool is_signed = true;
static constexpr bool is_integer = false;
static constexpr bool is_exact = false;
static constexpr int radix = 2;
static constexpr double
epsilon() noexcept { return double(2.22044604925031308085e-16L); }
static constexpr double
round_error() noexcept { return 0.5; }
static constexpr int min_exponent = (-1021);
static constexpr int min_exponent10 = (-307);
static constexpr int max_exponent = 1024;
static constexpr int max_exponent10 = 308;
static constexpr bool has_infinity = 1;
static constexpr bool has_quiet_NaN = 1;
static constexpr bool has_signaling_NaN = has_quiet_NaN;
static constexpr float_denorm_style has_denorm
= bool(1) ? denorm_present : denorm_absent;
static constexpr bool has_denorm_loss
= false;
static constexpr double
infinity() noexcept { return __builtin_huge_val(); }
static constexpr double
quiet_NaN() noexcept { return __builtin_nan(""); }
static constexpr double
signaling_NaN() noexcept { return __builtin_nans(""); }
static constexpr double
denorm_min() noexcept { return double(4.94065645841246544177e-324L); }
static constexpr bool is_iec559
= has_infinity && has_quiet_NaN && has_denorm == denorm_present;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = false;
static constexpr bool tinyness_before
= false;
static constexpr float_round_style round_style
= round_to_nearest;
};
#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.36210314311209350626e-4932L; }
static constexpr long double
max() noexcept { return 1.18973149535723176502e+4932L; }
static constexpr long double
lowest() noexcept { return -1.18973149535723176502e+4932L; }
static constexpr int digits = 64;
static constexpr int digits10 = 18;
static constexpr int max_digits10
= (2 + (64) * 643L / 2136);
static constexpr bool is_signed = true;
static constexpr bool is_integer = false;
static constexpr bool is_exact = false;
static constexpr int radix = 2;
static constexpr long double
epsilon() noexcept { return 1.08420217248550443401e-19L; }
static constexpr long double
round_error() noexcept { return 0.5L; }
static constexpr int min_exponent = (-16381);
static constexpr int min_exponent10 = (-4931);
static constexpr int max_exponent = 16384;
static constexpr int max_exponent10 = 4932;
static constexpr bool has_infinity = 1;
static constexpr bool has_quiet_NaN = 1;
static constexpr bool has_signaling_NaN = has_quiet_NaN;
static constexpr float_denorm_style has_denorm
= bool(1) ? denorm_present : denorm_absent;
static constexpr bool has_denorm_loss
= false;
static constexpr long double
infinity() noexcept { return __builtin_huge_vall(); }
static constexpr long double
quiet_NaN() noexcept { return __builtin_nanl(""); }
static constexpr long double
signaling_NaN() noexcept { return __builtin_nansl(""); }
static constexpr long double
denorm_min() noexcept { return 3.64519953188247460253e-4951L; }
static constexpr bool is_iec559
= has_infinity && has_quiet_NaN && has_denorm == denorm_present;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool traps = false;
static constexpr bool tinyness_before =
false;
static constexpr float_round_style round_style =
round_to_nearest;
};
#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
#define BOOST_ASIO_DETAIL_REACTOR_HPP
#define BOOST_ASIO_DETAIL_EPOLL_REACTOR_HPP
#define BOOST_ASIO_DETAIL_OBJECT_POOL_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Object>
class object_pool;
class object_pool_access
{
public:
template <typename Object>
static Object* create()
;
template <typename Object>
static void destroy(Object* o)
;
template <typename Object>
static Object*& next(Object* o)
;
template <typename Object>
static Object*& prev(Object* o)
;
};
template <typename Object>
class object_pool
: private noncopyable
{
public:
object_pool()
;
~object_pool()
;
Object* first()
;
Object* alloc()
;
void free(Object* o)
;
private:
void destroy_list(Object* list)
;
Object* live_list_;
Object* free_list_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTOR_OP_HPP
namespace boost {
namespace asio {
namespace detail {
class reactor_op
: public operation
{
public:
boost::system::error_code ec_;
std::size_t bytes_transferred_;
bool perform()
;
protected:
typedef bool (*perform_func_type)(reactor_op*);
reactor_op(perform_func_type perform_func, func_type complete_func)
;
private:
perform_func_type perform_func_;
};
}
}
}
#define BOOST_ASIO_DETAIL_SELECT_INTERRUPTER_HPP
#define BOOST_ASIO_DETAIL_EVENTFD_SELECT_INTERRUPTER_HPP
namespace boost {
namespace asio {
namespace detail {
class eventfd_select_interrupter
{
public:
inline eventfd_select_interrupter();
inline ~eventfd_select_interrupter();
inline void recreate();
inline void interrupt();
inline bool reset();
int read_descriptor() const
;
private:
inline void open_descriptors();
inline void close_descriptors();
int read_descriptor_;
int write_descriptor_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_EVENTFD_SELECT_INTERRUPTER_IPP
#define _SYS_STAT_H 1
#define __need_time_t
#define __need_timespec
extern "C" {
#define _BITS_STAT_H 1
#define _STAT_VER_KERNEL 0
#define _STAT_VER_LINUX 1
#define _MKNOD_VER_LINUX 0
#define _STAT_VER _STAT_VER_LINUX
struct stat
{
__dev_t st_dev;
__ino_t st_ino;
__nlink_t st_nlink;
__mode_t st_mode;
__uid_t st_uid;
__gid_t st_gid;
int __pad0;
__dev_t st_rdev;
__off_t st_size;
__blksize_t st_blksize;
__blkcnt_t st_blocks;
struct timespec st_atim;
struct timespec st_mtim;
struct timespec st_ctim;
#define st_atime st_atim.tv_sec
#define st_mtime st_mtim.tv_sec
#define st_ctime st_ctim.tv_sec
__syscall_slong_t __glibc_reserved[3];
};
struct stat64
{
__dev_t st_dev;
__ino64_t st_ino;
__nlink_t st_nlink;
__mode_t st_mode;
__uid_t st_uid;
__gid_t st_gid;
int __pad0;
__dev_t st_rdev;
__off_t st_size;
__blksize_t st_blksize;
__blkcnt64_t st_blocks;
struct timespec st_atim;
struct timespec st_mtim;
struct timespec st_ctim;
__syscall_slong_t __glibc_reserved[3];
};
#define _STATBUF_ST_BLKSIZE
#define _STATBUF_ST_RDEV
#define _STATBUF_ST_NSEC
#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) ((buf)->st_mode - (buf)->st_mode)
#define __S_TYPEISSEM(buf) ((buf)->st_mode - (buf)->st_mode)
#define __S_TYPEISSHM(buf) ((buf)->st_mode - (buf)->st_mode)
#define __S_ISUID 04000
#define __S_ISGID 02000
#define __S_ISVTX 01000
#define __S_IREAD 0400
#define __S_IWRITE 0200
#define __S_IEXEC 0100
#define UTIME_NOW ((1l << 30) - 1l)
#define UTIME_OMIT ((1l << 30) - 2l)
#define S_IFMT __S_IFMT
#define S_IFDIR __S_IFDIR
#define S_IFCHR __S_IFCHR
#define S_IFBLK __S_IFBLK
#define S_IFREG __S_IFREG
#define S_IFIFO __S_IFIFO
#define S_IFLNK __S_IFLNK
#define S_IFSOCK __S_IFSOCK
#define __S_ISTYPE(mode,mask) (((mode) & __S_IFMT) == (mask))
#define S_ISDIR(mode) __S_ISTYPE((mode), __S_IFDIR)
#define S_ISCHR(mode) __S_ISTYPE((mode), __S_IFCHR)
#define S_ISBLK(mode) __S_ISTYPE((mode), __S_IFBLK)
#define S_ISREG(mode) __S_ISTYPE((mode), __S_IFREG)
#define S_ISFIFO(mode) __S_ISTYPE((mode), __S_IFIFO)
#define S_ISLNK(mode) __S_ISTYPE((mode), __S_IFLNK)
#define S_ISSOCK(mode) __S_ISTYPE((mode), __S_IFSOCK)
#define S_TYPEISMQ(buf) __S_TYPEISMQ(buf)
#define S_TYPEISSEM(buf) __S_TYPEISSEM(buf)
#define S_TYPEISSHM(buf) __S_TYPEISSHM(buf)
#define S_ISUID __S_ISUID
#define S_ISGID __S_ISGID
#define S_ISVTX __S_ISVTX
#define S_IRUSR __S_IREAD
#define S_IWUSR __S_IWRITE
#define S_IXUSR __S_IEXEC
#define S_IRWXU (__S_IREAD|__S_IWRITE|__S_IEXEC)
#define S_IREAD S_IRUSR
#define S_IWRITE S_IWUSR
#define S_IEXEC S_IXUSR
#define S_IRGRP (S_IRUSR >> 3)
#define S_IWGRP (S_IWUSR >> 3)
#define S_IXGRP (S_IXUSR >> 3)
#define S_IRWXG (S_IRWXU >> 3)
#define S_IROTH (S_IRGRP >> 3)
#define S_IWOTH (S_IWGRP >> 3)
#define S_IXOTH (S_IXGRP >> 3)
#define S_IRWXO (S_IRWXG >> 3)
#define ACCESSPERMS (S_IRWXU|S_IRWXG|S_IRWXO)
#define ALLPERMS (S_ISUID|S_ISGID|S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO)
#define DEFFILEMODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)
#define S_BLKSIZE 512
extern int stat (const char *__restrict __file,
struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int fstat (int __fd, struct stat *__buf) throw () __attribute__ ((__nonnull__ (2)));
extern int stat64 (const char *__restrict __file,
struct stat64 *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int fstat64 (int __fd, struct stat64 *__buf) throw () __attribute__ ((__nonnull__ (2)));
extern int fstatat (int __fd, const char *__restrict __file,
struct stat *__restrict __buf, int __flag)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern int fstatat64 (int __fd, const char *__restrict __file,
struct stat64 *__restrict __buf, int __flag)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern int lstat (const char *__restrict __file,
struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int lstat64 (const char *__restrict __file,
struct stat64 *__restrict __buf)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int chmod (const char *__file, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (1)));
extern int lchmod (const char *__file, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (1)));
extern int fchmod (int __fd, __mode_t __mode) throw ();
extern int fchmodat (int __fd, const char *__file, __mode_t __mode,
int __flag)
throw () __attribute__ ((__nonnull__ (2))) ;
extern __mode_t umask (__mode_t __mask) throw ();
extern __mode_t getumask (void) throw ();
extern int mkdir (const char *__path, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (1)));
extern int mkdirat (int __fd, const char *__path, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (2)));
extern int mknod (const char *__path, __mode_t __mode, __dev_t __dev)
throw () __attribute__ ((__nonnull__ (1)));
extern int mknodat (int __fd, const char *__path, __mode_t __mode,
__dev_t __dev) throw () __attribute__ ((__nonnull__ (2)));
extern int mkfifo (const char *__path, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (1)));
extern int mkfifoat (int __fd, const char *__path, __mode_t __mode)
throw () __attribute__ ((__nonnull__ (2)));
extern int utimensat (int __fd, const char *__path,
const struct timespec __times[2],
int __flags)
throw () __attribute__ ((__nonnull__ (2)));
extern int futimens (int __fd, const struct timespec __times[2]) throw ();
#define _MKNOD_VER 0
extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf)
throw () __attribute__ ((__nonnull__ (3)));
extern int __xstat (int __ver, const char *__filename,
struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __lxstat (int __ver, const char *__filename,
struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __fxstatat (int __ver, int __fildes, const char *__filename,
struct stat *__stat_buf, int __flag)
throw () __attribute__ ((__nonnull__ (3, 4)));
extern int __fxstat64 (int __ver, int __fildes, struct stat64 *__stat_buf)
throw () __attribute__ ((__nonnull__ (3)));
extern int __xstat64 (int __ver, const char *__filename,
struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __lxstat64 (int __ver, const char *__filename,
struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __fxstatat64 (int __ver, int __fildes, const char *__filename,
struct stat64 *__stat_buf, int __flag)
throw () __attribute__ ((__nonnull__ (3, 4)));
extern int __xmknod (int __ver, const char *__path, __mode_t __mode,
__dev_t *__dev) throw () __attribute__ ((__nonnull__ (2, 4)));
extern int __xmknodat (int __ver, int __fd, const char *__path,
__mode_t __mode, __dev_t *__dev)
throw () __attribute__ ((__nonnull__ (3, 5)));
}
#define _FCNTL_H 1
extern "C" {
#define __O_LARGEFILE 0
#define F_GETLK64 5
#define F_SETLK64 6
#define F_SETLKW64 7
struct flock
{
short int l_type;
short int l_whence;
__off_t l_start;
__off_t l_len;
__pid_t l_pid;
};
struct flock64
{
short int l_type;
short int l_whence;
__off64_t l_start;
__off64_t l_len;
__pid_t l_pid;
};
#define O_ACCMODE 0003
#define O_RDONLY 00
#define O_WRONLY 01
#define O_RDWR 02
#define O_CREAT 0100
#define O_EXCL 0200
#define O_NOCTTY 0400
#define O_TRUNC 01000
#define O_APPEND 02000
#define O_NONBLOCK 04000
#define O_NDELAY O_NONBLOCK
#define O_SYNC 04010000
#define O_FSYNC O_SYNC
#define O_ASYNC 020000
#define __O_DIRECTORY 0200000
#define __O_NOFOLLOW 0400000
#define __O_CLOEXEC 02000000
#define __O_DIRECT 040000
#define __O_NOATIME 01000000
#define __O_PATH 010000000
#define __O_DSYNC 010000
#define __O_TMPFILE 020200000
#define F_GETLK 5
#define F_SETLK 6
#define F_SETLKW 7
#define O_LARGEFILE __O_LARGEFILE
#define O_DIRECTORY __O_DIRECTORY
#define O_NOFOLLOW __O_NOFOLLOW
#define O_CLOEXEC __O_CLOEXEC
#define O_DIRECT __O_DIRECT
#define O_NOATIME __O_NOATIME
#define O_PATH __O_PATH
#define O_TMPFILE __O_TMPFILE
#define O_DSYNC __O_DSYNC
#define O_RSYNC O_SYNC
#define F_DUPFD 0
#define F_GETFD 1
#define F_SETFD 2
#define F_GETFL 3
#define F_SETFL 4
#define __F_SETOWN 8
#define __F_GETOWN 9
#define F_SETOWN __F_SETOWN
#define F_GETOWN __F_GETOWN
#define __F_SETSIG 10
#define __F_GETSIG 11
#define __F_SETOWN_EX 15
#define __F_GETOWN_EX 16
#define F_SETSIG __F_SETSIG
#define F_GETSIG __F_GETSIG
#define F_SETOWN_EX __F_SETOWN_EX
#define F_GETOWN_EX __F_GETOWN_EX
#define F_SETLEASE 1024
#define F_GETLEASE 1025
#define F_NOTIFY 1026
#define F_SETPIPE_SZ 1031
#define F_GETPIPE_SZ 1032
#define F_DUPFD_CLOEXEC 1030
#define FD_CLOEXEC 1
#define F_RDLCK 0
#define F_WRLCK 1
#define F_UNLCK 2
#define F_EXLCK 4
#define F_SHLCK 8
#define LOCK_SH 1
#define LOCK_EX 2
#define LOCK_NB 4
#define LOCK_UN 8
#define LOCK_MAND 32
#define LOCK_READ 64
#define LOCK_WRITE 128
#define LOCK_RW 192
#define DN_ACCESS 0x00000001
#define DN_MODIFY 0x00000002
#define DN_CREATE 0x00000004
#define DN_DELETE 0x00000008
#define DN_RENAME 0x00000010
#define DN_ATTRIB 0x00000020
#define DN_MULTISHOT 0x80000000
enum __pid_type
{
F_OWNER_TID = 0,
F_OWNER_PID,
F_OWNER_PGRP,
F_OWNER_GID = F_OWNER_PGRP
};
struct f_owner_ex
{
enum __pid_type type;
__pid_t pid;
};
#define FAPPEND O_APPEND
#define FFSYNC O_FSYNC
#define FASYNC O_ASYNC
#define FNONBLOCK O_NONBLOCK
#define FNDELAY O_NDELAY
#define __POSIX_FADV_DONTNEED 4
#define __POSIX_FADV_NOREUSE 5
#define POSIX_FADV_NORMAL 0
#define POSIX_FADV_RANDOM 1
#define POSIX_FADV_SEQUENTIAL 2
#define POSIX_FADV_WILLNEED 3
#define POSIX_FADV_DONTNEED __POSIX_FADV_DONTNEED
#define POSIX_FADV_NOREUSE __POSIX_FADV_NOREUSE
#define SYNC_FILE_RANGE_WAIT_BEFORE 1
#define SYNC_FILE_RANGE_WRITE 2
#define SYNC_FILE_RANGE_WAIT_AFTER 4
#define SPLICE_F_MOVE 1
#define SPLICE_F_NONBLOCK 2
#define SPLICE_F_MORE 4
#define SPLICE_F_GIFT 8
#define FALLOC_FL_KEEP_SIZE 1
#define FALLOC_FL_PUNCH_HOLE 2
struct file_handle
{
unsigned int handle_bytes;
int handle_type;
unsigned char f_handle[0];
};
#define MAX_HANDLE_SZ 128
#define AT_FDCWD -100
#define AT_SYMLINK_NOFOLLOW 0x100
#define AT_REMOVEDIR 0x200
#define AT_SYMLINK_FOLLOW 0x400
#define AT_NO_AUTOMOUNT 0x800
#define AT_EMPTY_PATH 0x1000
#define AT_EACCESS 0x200
extern "C" {
extern ssize_t readahead (int __fd, __off64_t __offset, size_t __count)
throw ();
extern int sync_file_range (int __fd, __off64_t __offset, __off64_t __count,
unsigned int __flags);
extern ssize_t vmsplice (int __fdout, const struct iovec *__iov,
size_t __count, unsigned int __flags);
extern ssize_t splice (int __fdin, __off64_t *__offin, int __fdout,
__off64_t *__offout, size_t __len,
unsigned int __flags);
extern ssize_t tee (int __fdin, int __fdout, size_t __len,
unsigned int __flags);
extern int fallocate (int __fd, int __mode, __off_t __offset, __off_t __len);
extern int fallocate64 (int __fd, int __mode, __off64_t __offset,
__off64_t __len);
extern int name_to_handle_at (int __dfd, const char *__name,
struct file_handle *__handle, int *__mnt_id,
int __flags) throw ();
extern int open_by_handle_at (int __mountdirfd, struct file_handle *__handle,
int __flags);
}
#define __need_timespec
#define S_IFMT __S_IFMT
#define S_IFDIR __S_IFDIR
#define S_IFCHR __S_IFCHR
#define S_IFBLK __S_IFBLK
#define S_IFREG __S_IFREG
#define S_IFIFO __S_IFIFO
#define S_IFLNK __S_IFLNK
#define S_IFSOCK __S_IFSOCK
#define S_ISUID __S_ISUID
#define S_ISGID __S_ISGID
#define S_ISVTX __S_ISVTX
#define S_IRUSR __S_IREAD
#define S_IWUSR __S_IWRITE
#define S_IXUSR __S_IEXEC
#define S_IRWXU (__S_IREAD|__S_IWRITE|__S_IEXEC)
#define S_IRGRP (S_IRUSR >> 3)
#define S_IWGRP (S_IWUSR >> 3)
#define S_IXGRP (S_IXUSR >> 3)
#define S_IRWXG (S_IRWXU >> 3)
#define S_IROTH (S_IRGRP >> 3)
#define S_IWOTH (S_IWGRP >> 3)
#define S_IXOTH (S_IXGRP >> 3)
#define S_IRWXO (S_IRWXG >> 3)
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2
extern int fcntl (int __fd, int __cmd, ...);
extern int open (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
extern int open64 (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
extern int openat (int __fd, const char *__file, int __oflag, ...)
__attribute__ ((__nonnull__ (2)));
extern int openat64 (int __fd, const char *__file, int __oflag, ...)
__attribute__ ((__nonnull__ (2)));
extern int creat (const char *__file, mode_t __mode) __attribute__ ((__nonnull__ (1)));
extern int creat64 (const char *__file, mode_t __mode) __attribute__ ((__nonnull__ (1)));
extern int posix_fadvise (int __fd, off_t __offset, off_t __len,
int __advise) throw ();
extern int posix_fadvise64 (int __fd, off64_t __offset, off64_t __len,
int __advise) throw ();
extern int posix_fallocate (int __fd, off_t __offset, off_t __len);
extern int posix_fallocate64 (int __fd, off64_t __offset, off64_t __len);
}
#define _SYS_EVENTFD_H 1
enum
{
EFD_SEMAPHORE = 00000001,
#define EFD_SEMAPHORE EFD_SEMAPHORE
EFD_CLOEXEC = 02000000,
#define EFD_CLOEXEC EFD_CLOEXEC
EFD_NONBLOCK = 00004000
#define EFD_NONBLOCK EFD_NONBLOCK
};
typedef uint64_t eventfd_t;
extern "C" {
extern int eventfd (int __count, int __flags) throw ();
extern int eventfd_read (int __fd, eventfd_t *__value);
extern int eventfd_write (int __fd, eventfd_t __value);
}
#define BOOST_ASIO_DETAIL_CSTDINT_HPP
namespace boost {
namespace asio {
using std::int16_t;
using std::uint16_t;
using std::int32_t;
using std::uint32_t;
using std::int64_t;
using std::uint64_t;
}
}
namespace boost {
namespace asio {
namespace detail {
bool eventfd_select_interrupter::reset()
{
if (write_descriptor_ == read_descriptor_)
{
for (;;)
{
uint64_t counter(0);
(*__errno_location ()) = 0;
int bytes_read = ::read(read_descriptor_, &counter, sizeof(uint64_t));
if (bytes_read < 0 && (*__errno_location ()) == 4)
continue;
bool was_interrupted = (bytes_read > 0);
return was_interrupted;
}
}
else
{
for (;;)
{
char data[1024];
int bytes_read = ::read(read_descriptor_, data, sizeof(data));
if (bytes_read < 0 && (*__errno_location ()) == 4)
continue;
bool was_interrupted = (bytes_read > 0);
while (bytes_read == sizeof(data))
bytes_read = ::read(read_descriptor_, data, sizeof(data));
return was_interrupted;
}
}
}
}
}
}
namespace boost {
namespace asio {
namespace detail {
typedef eventfd_select_interrupter select_interrupter;
}
}
}
#define BOOST_ASIO_DETAIL_SOCKET_TYPES_HPP
#define _SYS_IOCTL_H 1
extern "C" {
#define __ASM_GENERIC_IOCTLS_H
#define _LINUX_IOCTL_H
#define _ASM_GENERIC_IOCTL_H
#define _IOC_NRBITS 8
#define _IOC_TYPEBITS 8
#define _IOC_SIZEBITS 14
#define _IOC_DIRBITS 2
#define _IOC_NRMASK ((1 << _IOC_NRBITS)-1)
#define _IOC_TYPEMASK ((1 << _IOC_TYPEBITS)-1)
#define _IOC_SIZEMASK ((1 << _IOC_SIZEBITS)-1)
#define _IOC_DIRMASK ((1 << _IOC_DIRBITS)-1)
#define _IOC_NRSHIFT 0
#define _IOC_TYPESHIFT (_IOC_NRSHIFT+_IOC_NRBITS)
#define _IOC_SIZESHIFT (_IOC_TYPESHIFT+_IOC_TYPEBITS)
#define _IOC_DIRSHIFT (_IOC_SIZESHIFT+_IOC_SIZEBITS)
#define _IOC_NONE 0U
#define _IOC_WRITE 1U
#define _IOC_READ 2U
#define _IOC(dir,type,nr,size) (((dir) << _IOC_DIRSHIFT) | ((type) << _IOC_TYPESHIFT) | ((nr) << _IOC_NRSHIFT) | ((size) << _IOC_SIZESHIFT))
#define _IOC_TYPECHECK(t) (sizeof(t))
#define _IO(type,nr) _IOC(_IOC_NONE,(type),(nr),0)
#define _IOR(type,nr,size) _IOC(_IOC_READ,(type),(nr),(_IOC_TYPECHECK(size)))
#define _IOW(type,nr,size) _IOC(_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(size)))
#define _IOWR(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(size)))
#define _IOR_BAD(type,nr,size) _IOC(_IOC_READ,(type),(nr),sizeof(size))
#define _IOW_BAD(type,nr,size) _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
#define _IOWR_BAD(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))
#define _IOC_DIR(nr) (((nr) >> _IOC_DIRSHIFT) & _IOC_DIRMASK)
#define _IOC_TYPE(nr) (((nr) >> _IOC_TYPESHIFT) & _IOC_TYPEMASK)
#define _IOC_NR(nr) (((nr) >> _IOC_NRSHIFT) & _IOC_NRMASK)
#define _IOC_SIZE(nr) (((nr) >> _IOC_SIZESHIFT) & _IOC_SIZEMASK)
#define IOC_IN (_IOC_WRITE << _IOC_DIRSHIFT)
#define IOC_OUT (_IOC_READ << _IOC_DIRSHIFT)
#define IOC_INOUT ((_IOC_WRITE|_IOC_READ) << _IOC_DIRSHIFT)
#define IOCSIZE_MASK (_IOC_SIZEMASK << _IOC_SIZESHIFT)
#define IOCSIZE_SHIFT (_IOC_SIZESHIFT)
#define TCGETS 0x5401
#define TCSETS 0x5402
#define TCSETSW 0x5403
#define TCSETSF 0x5404
#define TCGETA 0x5405
#define TCSETA 0x5406
#define TCSETAW 0x5407
#define TCSETAF 0x5408
#define TCSBRK 0x5409
#define TCXONC 0x540A
#define TCFLSH 0x540B
#define TIOCEXCL 0x540C
#define TIOCNXCL 0x540D
#define TIOCSCTTY 0x540E
#define TIOCGPGRP 0x540F
#define TIOCSPGRP 0x5410
#define TIOCOUTQ 0x5411
#define TIOCSTI 0x5412
#define TIOCGWINSZ 0x5413
#define TIOCSWINSZ 0x5414
#define TIOCMGET 0x5415
#define TIOCMBIS 0x5416
#define TIOCMBIC 0x5417
#define TIOCMSET 0x5418
#define TIOCGSOFTCAR 0x5419
#define TIOCSSOFTCAR 0x541A
#define FIONREAD 0x541B
#define TIOCINQ FIONREAD
#define TIOCLINUX 0x541C
#define TIOCCONS 0x541D
#define TIOCGSERIAL 0x541E
#define TIOCSSERIAL 0x541F
#define TIOCPKT 0x5420
#define FIONBIO 0x5421
#define TIOCNOTTY 0x5422
#define TIOCSETD 0x5423
#define TIOCGETD 0x5424
#define TCSBRKP 0x5425
#define TIOCSBRK 0x5427
#define TIOCCBRK 0x5428
#define TIOCGSID 0x5429
#define TCGETS2 _IOR('T', 0x2A, struct termios2)
#define TCSETS2 _IOW('T', 0x2B, struct termios2)
#define TCSETSW2 _IOW('T', 0x2C, struct termios2)
#define TCSETSF2 _IOW('T', 0x2D, struct termios2)
#define TIOCGRS485 0x542E
#define TIOCSRS485 0x542F
#define TIOCGPTN _IOR('T', 0x30, unsigned int)
#define TIOCSPTLCK _IOW('T', 0x31, int)
#define TIOCGDEV _IOR('T', 0x32, unsigned int)
#define TCGETX 0x5432
#define TCSETX 0x5433
#define TCSETXF 0x5434
#define TCSETXW 0x5435
#define TIOCSIG _IOW('T', 0x36, int)
#define TIOCVHANGUP 0x5437
#define TIOCGPKT _IOR('T', 0x38, int)
#define TIOCGPTLCK _IOR('T', 0x39, int)
#define TIOCGEXCL _IOR('T', 0x40, int)
#define FIONCLEX 0x5450
#define FIOCLEX 0x5451
#define FIOASYNC 0x5452
#define TIOCSERCONFIG 0x5453
#define TIOCSERGWILD 0x5454
#define TIOCSERSWILD 0x5455
#define TIOCGLCKTRMIOS 0x5456
#define TIOCSLCKTRMIOS 0x5457
#define TIOCSERGSTRUCT 0x5458
#define TIOCSERGETLSR 0x5459
#define TIOCSERGETMULTI 0x545A
#define TIOCSERSETMULTI 0x545B
#define TIOCMIWAIT 0x545C
#define TIOCGICOUNT 0x545D
#define FIOQSIZE 0x5460
#define TIOCPKT_DATA 0
#define TIOCPKT_FLUSHREAD 1
#define TIOCPKT_FLUSHWRITE 2
#define TIOCPKT_STOP 4
#define TIOCPKT_START 8
#define TIOCPKT_NOSTOP 16
#define TIOCPKT_DOSTOP 32
#define TIOCPKT_IOCTL 64
#define TIOCSER_TEMT 0x01
#define SIOCADDRT 0x890B
#define SIOCDELRT 0x890C
#define SIOCRTMSG 0x890D
#define SIOCGIFNAME 0x8910
#define SIOCSIFLINK 0x8911
#define SIOCGIFCONF 0x8912
#define SIOCGIFFLAGS 0x8913
#define SIOCSIFFLAGS 0x8914
#define SIOCGIFADDR 0x8915
#define SIOCSIFADDR 0x8916
#define SIOCGIFDSTADDR 0x8917
#define SIOCSIFDSTADDR 0x8918
#define SIOCGIFBRDADDR 0x8919
#define SIOCSIFBRDADDR 0x891a
#define SIOCGIFNETMASK 0x891b
#define SIOCSIFNETMASK 0x891c
#define SIOCGIFMETRIC 0x891d
#define SIOCSIFMETRIC 0x891e
#define SIOCGIFMEM 0x891f
#define SIOCSIFMEM 0x8920
#define SIOCGIFMTU 0x8921
#define SIOCSIFMTU 0x8922
#define SIOCSIFNAME 0x8923
#define SIOCSIFHWADDR 0x8924
#define SIOCGIFENCAP 0x8925
#define SIOCSIFENCAP 0x8926
#define SIOCGIFHWADDR 0x8927
#define SIOCGIFSLAVE 0x8929
#define SIOCSIFSLAVE 0x8930
#define SIOCADDMULTI 0x8931
#define SIOCDELMULTI 0x8932
#define SIOCGIFINDEX 0x8933
#define SIOGIFINDEX SIOCGIFINDEX
#define SIOCSIFPFLAGS 0x8934
#define SIOCGIFPFLAGS 0x8935
#define SIOCDIFADDR 0x8936
#define SIOCSIFHWBROADCAST 0x8937
#define SIOCGIFCOUNT 0x8938
#define SIOCGIFBR 0x8940
#define SIOCSIFBR 0x8941
#define SIOCGIFTXQLEN 0x8942
#define SIOCSIFTXQLEN 0x8943
#define SIOCDARP 0x8953
#define SIOCGARP 0x8954
#define SIOCSARP 0x8955
#define SIOCDRARP 0x8960
#define SIOCGRARP 0x8961
#define SIOCSRARP 0x8962
#define SIOCGIFMAP 0x8970
#define SIOCSIFMAP 0x8971
#define SIOCADDDLCI 0x8980
#define SIOCDELDLCI 0x8981
#define SIOCDEVPRIVATE 0x89F0
#define SIOCPROTOPRIVATE 0x89E0
struct winsize
{
unsigned short int ws_row;
unsigned short int ws_col;
unsigned short int ws_xpixel;
unsigned short int ws_ypixel;
};
#define NCC 8
struct termio
{
unsigned short int c_iflag;
unsigned short int c_oflag;
unsigned short int c_cflag;
unsigned short int c_lflag;
unsigned char c_line;
unsigned char c_cc[8];
};
#define TIOCM_LE 0x001
#define TIOCM_DTR 0x002
#define TIOCM_RTS 0x004
#define TIOCM_ST 0x008
#define TIOCM_SR 0x010
#define TIOCM_CTS 0x020
#define TIOCM_CAR 0x040
#define TIOCM_RNG 0x080
#define TIOCM_DSR 0x100
#define TIOCM_CD TIOCM_CAR
#define TIOCM_RI TIOCM_RNG
#define N_TTY 0
#define N_SLIP 1
#define N_MOUSE 2
#define N_PPP 3
#define N_STRIP 4
#define N_AX25 5
#define N_X25 6
#define N_6PACK 7
#define N_MASC 8
#define N_R3964 9
#define N_PROFIBUS_FDL 10
#define N_IRDA 11
#define N_SMSBLOCK 12
#define N_HDLC 13
#define N_SYNC_PPP 14
#define N_HCI 15
#define _SYS_TTYDEFAULTS_H_
#define TTYDEF_IFLAG (BRKINT | ISTRIP | ICRNL | IMAXBEL | IXON | IXANY)
#define TTYDEF_OFLAG (OPOST | ONLCR | XTABS)
#define TTYDEF_LFLAG (ECHO | ICANON | ISIG | IEXTEN | ECHOE|ECHOKE|ECHOCTL)
#define TTYDEF_CFLAG (CREAD | CS7 | PARENB | HUPCL)
#define TTYDEF_SPEED (B9600)
#define CTRL(x) (x&037)
#define CEOF CTRL('d')
#define CEOL _POSIX_VDISABLE
#define CERASE 0177
#define CINTR CTRL('c')
#define CSTATUS _POSIX_VDISABLE
#define CKILL CTRL('u')
#define CMIN 1
#define CQUIT 034
#define CSUSP CTRL('z')
#define CTIME 0
#define CDSUSP CTRL('y')
#define CSTART CTRL('q')
#define CSTOP CTRL('s')
#define CLNEXT CTRL('v')
#define CDISCARD CTRL('o')
#define CWERASE CTRL('w')
#define CREPRINT CTRL('r')
#define CEOT CEOF
#define CBRK CEOL
#define CRPRNT CREPRINT
#define CFLUSH CDISCARD
extern int ioctl (int __fd, unsigned long int __request, ...) throw ();
}
#define _SYS_POLL_H 1
#define POLLIN 0x001
#define POLLPRI 0x002
#define POLLOUT 0x004
#define POLLRDNORM 0x040
#define POLLRDBAND 0x080
#define POLLWRNORM 0x100
#define POLLWRBAND 0x200
#define POLLMSG 0x400
#define POLLREMOVE 0x1000
#define POLLRDHUP 0x2000
#define POLLERR 0x008
#define POLLHUP 0x010
#define POLLNVAL 0x020
#define __need_timespec
typedef unsigned long int nfds_t;
struct pollfd
{
int fd;
short int events;
short int revents;
};
extern "C" {
extern int poll (struct pollfd *__fds, nfds_t __nfds, int __timeout);
extern int ppoll (struct pollfd *__fds, nfds_t __nfds,
const struct timespec *__timeout,
const __sigset_t *__ss);
}
#define _SYS_UN_H 1
extern "C" {
struct sockaddr_un
{
sa_family_t sun_family;
char sun_path[108];
};
#define _STRING_H 1
extern "C" {
#define __need_size_t
#define __need_NULL
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
#define __CORRECT_ISO_CPP_STRING_H_PROTO
extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *memmove (void *__dest, const void *__src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
int __c, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern int memcmp (const void *__s1, const void *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++"
{
extern void *memchr (void *__s, int __c, size_t __n)
throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const void *memchr (const void *__s, int __c, size_t __n)
throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
}
extern "C++" void *rawmemchr (void *__s, int __c)
throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const void *rawmemchr (const void *__s, int __c)
throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" void *memrchr (void *__s, int __c, size_t __n)
throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const void *memrchr (const void *__s, int __c, size_t __n)
throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strncpy (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strcat (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strncat (char *__restrict __dest, const char *__restrict __src,
size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int strcmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strncmp (const char *__s1, const char *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strcoll (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern size_t strxfrm (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (2)));
extern int strcoll_l (const char *__s1, const char *__s2, __locale_t __l)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
__locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));
extern char *strdup (const char *__s)
throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
extern char *strndup (const char *__string, size_t __n)
throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
#define strdupa(s) (__extension__ ({ const char *__old = (s); size_t __len = strlen (__old) + 1; char *__new = (char *) __builtin_alloca (__len); (char *) memcpy (__new, __old, __len); }))
#define strndupa(s,n) (__extension__ ({ const char *__old = (s); size_t __len = strnlen (__old, (n)); char *__new = (char *) __builtin_alloca (__len + 1); __new[__len] = '\0'; (char *) memcpy (__new, __old, __len); }))
extern "C++"
{
extern char *strchr (char *__s, int __c)
throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *strchr (const char *__s, int __c)
throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
}
extern "C++"
{
extern char *strrchr (char *__s, int __c)
throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *strrchr (const char *__s, int __c)
throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
}
extern "C++" char *strchrnul (char *__s, int __c)
throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const char *strchrnul (const char *__s, int __c)
throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern size_t strcspn (const char *__s, const char *__reject)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern size_t strspn (const char *__s, const char *__accept)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++"
{
extern char *strpbrk (char *__s, const char *__accept)
throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern const char *strpbrk (const char *__s, const char *__accept)
throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
}
extern "C++"
{
extern char *strstr (char *__haystack, const char *__needle)
throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern const char *strstr (const char *__haystack, const char *__needle)
throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
}
extern char *strtok (char *__restrict __s, const char *__restrict __delim)
throw () __attribute__ ((__nonnull__ (2)));
extern char *__strtok_r (char *__restrict __s,
const char *__restrict __delim,
char **__restrict __save_ptr)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
char **__restrict __save_ptr)
throw () __attribute__ ((__nonnull__ (2, 3)));
extern "C++" char *strcasestr (char *__haystack, const char *__needle)
throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++" const char *strcasestr (const char *__haystack,
const char *__needle)
throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern void *memmem (const void *__haystack, size_t __haystacklen,
const void *__needle, size_t __needlelen)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));
extern void *__mempcpy (void *__restrict __dest,
const void *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *mempcpy (void *__restrict __dest,
const void *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern size_t strlen (const char *__s)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern size_t strnlen (const char *__string, size_t __maxlen)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern char *strerror (int __errnum) throw ();
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2))) ;
extern char *strerror_l (int __errnum, __locale_t __l) throw ();
extern void __bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern void bcopy (const void *__src, void *__dest, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern int bcmp (const void *__s1, const void *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++"
{
extern char *index (char *__s, int __c)
throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *index (const char *__s, int __c)
throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
}
extern "C++"
{
extern char *rindex (char *__s, int __c)
throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *rindex (const char *__s, int __c)
throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
}
extern int ffs (int __i) throw () __attribute__ ((__const__));
extern int ffsl (long int __l) throw () __attribute__ ((__const__));
__extension__ extern int ffsll (long long int __ll)
throw () __attribute__ ((__const__));
extern int strcasecmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int strcasecmp_l (const char *__s1, const char *__s2,
__locale_t __loc)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
extern int strncasecmp_l (const char *__s1, const char *__s2,
size_t __n, __locale_t __loc)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
extern char *strsep (char **__restrict __stringp,
const char *__restrict __delim)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *strsignal (int __sig) throw ();
extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *__stpncpy (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpncpy (char *__restrict __dest,
const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int strverscmp (const char *__s1, const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));
extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
extern "C++" char *basename (char *__filename)
throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
extern "C++" const char *basename (const char *__filename)
throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
}
#define SUN_LEN(ptr) ((size_t) (((struct sockaddr_un *) 0)->sun_path) + strlen ((ptr)->sun_path))
}
#define _NETINET_TCP_H 1
#define TCP_NODELAY 1
#define TCP_MAXSEG 2
#define TCP_CORK 3
#define TCP_KEEPIDLE 4
#define TCP_KEEPINTVL 5
#define TCP_KEEPCNT 6
#define TCP_SYNCNT 7
#define TCP_LINGER2 8
#define TCP_DEFER_ACCEPT 9
#define TCP_WINDOW_CLAMP 10
#define TCP_INFO 11
#define TCP_QUICKACK 12
#define TCP_CONGESTION 13
#define TCP_MD5SIG 14
#define TCP_COOKIE_TRANSACTIONS 15
#define TCP_THIN_LINEAR_TIMEOUTS 16
#define TCP_THIN_DUPACK 17
#define TCP_USER_TIMEOUT 18
#define TCP_REPAIR 19
#define TCP_REPAIR_QUEUE 20
#define TCP_QUEUE_SEQ 21
#define TCP_REPAIR_OPTIONS 22
#define TCP_FASTOPEN 23
#define TCP_TIMESTAMP 24
typedef u_int32_t tcp_seq;
struct tcphdr
{
__extension__ union
{
struct
{
u_int16_t th_sport;
u_int16_t th_dport;
tcp_seq th_seq;
tcp_seq th_ack;
u_int8_t th_x2:4;
u_int8_t th_off:4;
u_int8_t th_flags;
#define TH_FIN 0x01
#define TH_SYN 0x02
#define TH_RST 0x04
#define TH_PUSH 0x08
#define TH_ACK 0x10
#define TH_URG 0x20
u_int16_t th_win;
u_int16_t th_sum;
u_int16_t th_urp;
};
struct
{
u_int16_t source;
u_int16_t dest;
u_int32_t seq;
u_int32_t ack_seq;
u_int16_t res1:4;
u_int16_t doff:4;
u_int16_t fin:1;
u_int16_t syn:1;
u_int16_t rst:1;
u_int16_t psh:1;
u_int16_t ack:1;
u_int16_t urg:1;
u_int16_t res2:2;
u_int16_t window;
u_int16_t check;
u_int16_t urg_ptr;
};
};
};
enum
{
TCP_ESTABLISHED = 1,
TCP_SYN_SENT,
TCP_SYN_RECV,
TCP_FIN_WAIT1,
TCP_FIN_WAIT2,
TCP_TIME_WAIT,
TCP_CLOSE,
TCP_CLOSE_WAIT,
TCP_LAST_ACK,
TCP_LISTEN,
TCP_CLOSING
};
#define TCPOPT_EOL 0
#define TCPOPT_NOP 1
#define TCPOPT_MAXSEG 2
#define TCPOLEN_MAXSEG 4
#define TCPOPT_WINDOW 3
#define TCPOLEN_WINDOW 3
#define TCPOPT_SACK_PERMITTED 4
#define TCPOLEN_SACK_PERMITTED 2
#define TCPOPT_SACK 5
#define TCPOPT_TIMESTAMP 8
#define TCPOLEN_TIMESTAMP 10
#define TCPOLEN_TSTAMP_APPA (TCPOLEN_TIMESTAMP+2)
#define TCPOPT_TSTAMP_HDR (TCPOPT_NOP<<24|TCPOPT_NOP<<16|TCPOPT_TIMESTAMP<<8|TCPOLEN_TIMESTAMP)
#define TCP_MSS 512
#define TCP_MAXWIN 65535
#define TCP_MAX_WINSHIFT 14
#define SOL_TCP 6
#define TCPI_OPT_TIMESTAMPS 1
#define TCPI_OPT_SACK 2
#define TCPI_OPT_WSCALE 4
#define TCPI_OPT_ECN 8
#define TCPI_OPT_ECN_SEEN 16
#define TCPI_OPT_SYN_DATA 32
enum tcp_ca_state
{
TCP_CA_Open = 0,
TCP_CA_Disorder = 1,
TCP_CA_CWR = 2,
TCP_CA_Recovery = 3,
TCP_CA_Loss = 4
};
struct tcp_info
{
u_int8_t tcpi_state;
u_int8_t tcpi_ca_state;
u_int8_t tcpi_retransmits;
u_int8_t tcpi_probes;
u_int8_t tcpi_backoff;
u_int8_t tcpi_options;
u_int8_t tcpi_snd_wscale : 4, tcpi_rcv_wscale : 4;
u_int32_t tcpi_rto;
u_int32_t tcpi_ato;
u_int32_t tcpi_snd_mss;
u_int32_t tcpi_rcv_mss;
u_int32_t tcpi_unacked;
u_int32_t tcpi_sacked;
u_int32_t tcpi_lost;
u_int32_t tcpi_retrans;
u_int32_t tcpi_fackets;
u_int32_t tcpi_last_data_sent;
u_int32_t tcpi_last_ack_sent;
u_int32_t tcpi_last_data_recv;
u_int32_t tcpi_last_ack_recv;
u_int32_t tcpi_pmtu;
u_int32_t tcpi_rcv_ssthresh;
u_int32_t tcpi_rtt;
u_int32_t tcpi_rttvar;
u_int32_t tcpi_snd_ssthresh;
u_int32_t tcpi_snd_cwnd;
u_int32_t tcpi_advmss;
u_int32_t tcpi_reordering;
u_int32_t tcpi_rcv_rtt;
u_int32_t tcpi_rcv_space;
u_int32_t tcpi_total_retrans;
};
#define TCP_MD5SIG_MAXKEYLEN 80
struct tcp_md5sig
{
struct sockaddr_storage tcpm_addr;
u_int16_t __tcpm_pad1;
u_int16_t tcpm_keylen;
u_int32_t __tcpm_pad2;
u_int8_t tcpm_key[80];
};
struct tcp_repair_opt
{
u_int32_t opt_code;
u_int32_t opt_val;
};
enum
{
TCP_NO_QUEUE,
TCP_RECV_QUEUE,
TCP_SEND_QUEUE,
TCP_QUEUES_NR,
};
#define TCP_COOKIE_MIN 8
#define TCP_COOKIE_MAX 16
#define TCP_COOKIE_PAIR_SIZE (2*TCP_COOKIE_MAX)
#define TCP_COOKIE_IN_ALWAYS (1 << 0)
#define TCP_COOKIE_OUT_NEVER (1 << 1)
#define TCP_S_DATA_IN (1 << 2)
#define TCP_S_DATA_OUT (1 << 3)
#define TCP_MSS_DEFAULT 536U
#define TCP_MSS_DESIRED 1220U
struct tcp_cookie_transactions
{
u_int16_t tcpct_flags;
u_int8_t __tcpct_pad1;
u_int8_t tcpct_cookie_desired;
u_int16_t tcpct_s_data_desired;
u_int16_t tcpct_used;
u_int8_t tcpct_value[536U];
};
#define _ARPA_INET_H 1
extern "C" {
extern in_addr_t inet_addr (const char *__cp) throw ();
extern in_addr_t inet_lnaof (struct in_addr __in) throw ();
extern struct in_addr inet_makeaddr (in_addr_t __net, in_addr_t __host)
throw ();
extern in_addr_t inet_netof (struct in_addr __in) throw ();
extern in_addr_t inet_network (const char *__cp) throw ();
extern char *inet_ntoa (struct in_addr __in) throw ();
extern int inet_pton (int __af, const char *__restrict __cp,
void *__restrict __buf) throw ();
extern const char *inet_ntop (int __af, const void *__restrict __cp,
char *__restrict __buf, socklen_t __len)
throw ();
extern int inet_aton (const char *__cp, struct in_addr *__inp) throw ();
extern char *inet_neta (in_addr_t __net, char *__buf, size_t __len) throw ();
extern char *inet_net_ntop (int __af, const void *__cp, int __bits,
char *__buf, size_t __len) throw ();
extern int inet_net_pton (int __af, const char *__cp,
void *__buf, size_t __len) throw ();
extern unsigned int inet_nsap_addr (const char *__cp,
unsigned char *__buf, int __len) throw ();
extern char *inet_nsap_ntoa (int __len, const unsigned char *__cp,
char *__buf) throw ();
}
#define _NET_IF_H 1
#define IF_NAMESIZE 16
struct if_nameindex
{
unsigned int if_index;
char *if_name;
};
enum
{
IFF_UP = 0x1,
#define IFF_UP IFF_UP
IFF_BROADCAST = 0x2,
#define IFF_BROADCAST IFF_BROADCAST
IFF_DEBUG = 0x4,
#define IFF_DEBUG IFF_DEBUG
IFF_LOOPBACK = 0x8,
#define IFF_LOOPBACK IFF_LOOPBACK
IFF_POINTOPOINT = 0x10,
#define IFF_POINTOPOINT IFF_POINTOPOINT
IFF_NOTRAILERS = 0x20,
#define IFF_NOTRAILERS IFF_NOTRAILERS
IFF_RUNNING = 0x40,
#define IFF_RUNNING IFF_RUNNING
IFF_NOARP = 0x80,
#define IFF_NOARP IFF_NOARP
IFF_PROMISC = 0x100,
#define IFF_PROMISC IFF_PROMISC
IFF_ALLMULTI = 0x200,
#define IFF_ALLMULTI IFF_ALLMULTI
IFF_MASTER = 0x400,
#define IFF_MASTER IFF_MASTER
IFF_SLAVE = 0x800,
#define IFF_SLAVE IFF_SLAVE
IFF_MULTICAST = 0x1000,
#define IFF_MULTICAST IFF_MULTICAST
IFF_PORTSEL = 0x2000,
#define IFF_PORTSEL IFF_PORTSEL
IFF_AUTOMEDIA = 0x4000,
#define IFF_AUTOMEDIA IFF_AUTOMEDIA
IFF_DYNAMIC = 0x8000
#define IFF_DYNAMIC IFF_DYNAMIC
};
struct ifaddr
{
struct sockaddr ifa_addr;
union
{
struct sockaddr ifu_broadaddr;
struct sockaddr ifu_dstaddr;
} ifa_ifu;
struct iface *ifa_ifp;
struct ifaddr *ifa_next;
};
#define ifa_broadaddr ifa_ifu.ifu_broadaddr
#define ifa_dstaddr ifa_ifu.ifu_dstaddr
struct ifmap
{
unsigned long int mem_start;
unsigned long int mem_end;
unsigned short int base_addr;
unsigned char irq;
unsigned char dma;
unsigned char port;
};
struct ifreq
{
#define IFHWADDRLEN 6
#define IFNAMSIZ IF_NAMESIZE
union
{
char ifrn_name[16];
} ifr_ifrn;
union
{
struct sockaddr ifru_addr;
struct sockaddr ifru_dstaddr;
struct sockaddr ifru_broadaddr;
struct sockaddr ifru_netmask;
struct sockaddr ifru_hwaddr;
short int ifru_flags;
int ifru_ivalue;
int ifru_mtu;
struct ifmap ifru_map;
char ifru_slave[16];
char ifru_newname[16];
__caddr_t ifru_data;
} ifr_ifru;
};
#define ifr_name ifr_ifrn.ifrn_name
#define ifr_hwaddr ifr_ifru.ifru_hwaddr
#define ifr_addr ifr_ifru.ifru_addr
#define ifr_dstaddr ifr_ifru.ifru_dstaddr
#define ifr_broadaddr ifr_ifru.ifru_broadaddr
#define ifr_netmask ifr_ifru.ifru_netmask
#define ifr_flags ifr_ifru.ifru_flags
#define ifr_metric ifr_ifru.ifru_ivalue
#define ifr_mtu ifr_ifru.ifru_mtu
#define ifr_map ifr_ifru.ifru_map
#define ifr_slave ifr_ifru.ifru_slave
#define ifr_data ifr_ifru.ifru_data
#define ifr_ifindex ifr_ifru.ifru_ivalue
#define ifr_bandwidth ifr_ifru.ifru_ivalue
#define ifr_qlen ifr_ifru.ifru_ivalue
#define ifr_newname ifr_ifru.ifru_newname
#define _IOT_ifreq _IOT(_IOTS(char),IFNAMSIZ,_IOTS(char),16,0,0)
#define _IOT_ifreq_short _IOT(_IOTS(char),IFNAMSIZ,_IOTS(short),1,0,0)
#define _IOT_ifreq_int _IOT(_IOTS(char),IFNAMSIZ,_IOTS(int),1,0,0)
struct ifconf
{
int ifc_len;
union
{
__caddr_t ifcu_buf;
struct ifreq *ifcu_req;
} ifc_ifcu;
};
#define ifc_buf ifc_ifcu.ifcu_buf
#define ifc_req ifc_ifcu.ifcu_req
#define _IOT_ifconf _IOT(_IOTS(struct ifconf),1,0,0,0,0)
extern "C" {
extern unsigned int if_nametoindex (const char *__ifname) throw ();
extern char *if_indextoname (unsigned int __ifindex, char *__ifname) throw ();
extern struct if_nameindex *if_nameindex (void) throw ();
extern void if_freenameindex (struct if_nameindex *__ptr) throw ();
}
namespace boost {
namespace asio {
namespace detail {
typedef int socket_type;
const int invalid_socket = -1;
const int socket_error_retval = -1;
const int max_addr_v4_str_len = 16;
const int max_addr_v6_str_len = 46 + 1 + 16;
typedef sockaddr socket_addr_type;
typedef in_addr in4_addr_type;
typedef ip_mreq in4_mreq_type;
typedef sockaddr_in sockaddr_in4_type;
typedef in6_addr in6_addr_type;
typedef ipv6_mreq in6_mreq_type;
typedef sockaddr_in6 sockaddr_in6_type;
typedef sockaddr_storage sockaddr_storage_type;
typedef sockaddr_un sockaddr_un_type;
typedef addrinfo addrinfo_type;
typedef ::linger linger_type;
typedef int ioctl_arg_type;
typedef uint32_t u_long_type;
typedef uint16_t u_short_type;
typedef ssize_t signed_size_type;
#define BOOST_ASIO_OS_DEF(c) BOOST_ASIO_OS_DEF_ ##c
#define BOOST_ASIO_OS_DEF_AF_UNSPEC AF_UNSPEC
#define BOOST_ASIO_OS_DEF_AF_INET AF_INET
#define BOOST_ASIO_OS_DEF_AF_INET6 AF_INET6
#define BOOST_ASIO_OS_DEF_SOCK_STREAM SOCK_STREAM
#define BOOST_ASIO_OS_DEF_SOCK_DGRAM SOCK_DGRAM
#define BOOST_ASIO_OS_DEF_SOCK_RAW SOCK_RAW
#define BOOST_ASIO_OS_DEF_SOCK_SEQPACKET SOCK_SEQPACKET
#define BOOST_ASIO_OS_DEF_IPPROTO_IP IPPROTO_IP
#define BOOST_ASIO_OS_DEF_IPPROTO_IPV6 IPPROTO_IPV6
#define BOOST_ASIO_OS_DEF_IPPROTO_TCP IPPROTO_TCP
#define BOOST_ASIO_OS_DEF_IPPROTO_UDP IPPROTO_UDP
#define BOOST_ASIO_OS_DEF_IPPROTO_ICMP IPPROTO_ICMP
#define BOOST_ASIO_OS_DEF_IPPROTO_ICMPV6 IPPROTO_ICMPV6
#define BOOST_ASIO_OS_DEF_FIONBIO FIONBIO
#define BOOST_ASIO_OS_DEF_FIONREAD FIONREAD
#define BOOST_ASIO_OS_DEF_INADDR_ANY INADDR_ANY
#define BOOST_ASIO_OS_DEF_MSG_OOB MSG_OOB
#define BOOST_ASIO_OS_DEF_MSG_PEEK MSG_PEEK
#define BOOST_ASIO_OS_DEF_MSG_DONTROUTE MSG_DONTROUTE
#define BOOST_ASIO_OS_DEF_MSG_EOR MSG_EOR
#define BOOST_ASIO_OS_DEF_SHUT_RD SHUT_RD
#define BOOST_ASIO_OS_DEF_SHUT_WR SHUT_WR
#define BOOST_ASIO_OS_DEF_SHUT_RDWR SHUT_RDWR
#define BOOST_ASIO_OS_DEF_SOMAXCONN SOMAXCONN
#define BOOST_ASIO_OS_DEF_SOL_SOCKET SOL_SOCKET
#define BOOST_ASIO_OS_DEF_SO_BROADCAST SO_BROADCAST
#define BOOST_ASIO_OS_DEF_SO_DEBUG SO_DEBUG
#define BOOST_ASIO_OS_DEF_SO_DONTROUTE SO_DONTROUTE
#define BOOST_ASIO_OS_DEF_SO_KEEPALIVE SO_KEEPALIVE
#define BOOST_ASIO_OS_DEF_SO_LINGER SO_LINGER
#define BOOST_ASIO_OS_DEF_SO_SNDBUF SO_SNDBUF
#define BOOST_ASIO_OS_DEF_SO_RCVBUF SO_RCVBUF
#define BOOST_ASIO_OS_DEF_SO_SNDLOWAT SO_SNDLOWAT
#define BOOST_ASIO_OS_DEF_SO_RCVLOWAT SO_RCVLOWAT
#define BOOST_ASIO_OS_DEF_SO_REUSEADDR SO_REUSEADDR
#define BOOST_ASIO_OS_DEF_TCP_NODELAY TCP_NODELAY
#define BOOST_ASIO_OS_DEF_IP_MULTICAST_IF IP_MULTICAST_IF
#define BOOST_ASIO_OS_DEF_IP_MULTICAST_TTL IP_MULTICAST_TTL
#define BOOST_ASIO_OS_DEF_IP_MULTICAST_LOOP IP_MULTICAST_LOOP
#define BOOST_ASIO_OS_DEF_IP_ADD_MEMBERSHIP IP_ADD_MEMBERSHIP
#define BOOST_ASIO_OS_DEF_IP_DROP_MEMBERSHIP IP_DROP_MEMBERSHIP
#define BOOST_ASIO_OS_DEF_IP_TTL IP_TTL
#define BOOST_ASIO_OS_DEF_IPV6_UNICAST_HOPS IPV6_UNICAST_HOPS
#define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_IF IPV6_MULTICAST_IF
#define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_HOPS IPV6_MULTICAST_HOPS
#define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_LOOP IPV6_MULTICAST_LOOP
#define BOOST_ASIO_OS_DEF_IPV6_JOIN_GROUP IPV6_JOIN_GROUP
#define BOOST_ASIO_OS_DEF_IPV6_LEAVE_GROUP IPV6_LEAVE_GROUP
#define BOOST_ASIO_OS_DEF_AI_CANONNAME AI_CANONNAME
#define BOOST_ASIO_OS_DEF_AI_PASSIVE AI_PASSIVE
#define BOOST_ASIO_OS_DEF_AI_NUMERICHOST AI_NUMERICHOST
#define BOOST_ASIO_OS_DEF_AI_NUMERICSERV AI_NUMERICSERV
#define BOOST_ASIO_OS_DEF_AI_V4MAPPED AI_V4MAPPED
#define BOOST_ASIO_OS_DEF_AI_ALL AI_ALL
#define BOOST_ASIO_OS_DEF_AI_ADDRCONFIG AI_ADDRCONFIG
const int max_iov_len = 1024;
const int custom_socket_option_level = 0xA5100000;
const int enable_connection_aborted_option = 1;
const int always_fail_option = 2;
}
}
}
#define BOOST_ASIO_DETAIL_TIMER_QUEUE_BASE_HPP
namespace boost {
namespace asio {
namespace detail {
class timer_queue_base
: private noncopyable
{
public:
timer_queue_base() ;
virtual ~timer_queue_base() ;
virtual bool empty() const = 0;
virtual long wait_duration_msec(long max_duration) const = 0;
virtual long wait_duration_usec(long max_duration) const = 0;
virtual void get_ready_timers(op_queue<operation>& ops) = 0;
virtual void get_all_timers(op_queue<operation>& ops) = 0;
private:
friend class timer_queue_set;
timer_queue_base* next_;
};
template <typename Time_Traits>
class timer_queue;
}
}
}
#define BOOST_ASIO_DETAIL_TIMER_QUEUE_SET_HPP
namespace boost {
namespace asio {
namespace detail {
class timer_queue_set
{
public:
inline timer_queue_set();
inline void insert(timer_queue_base* q);
inline void erase(timer_queue_base* q);
inline bool all_empty() const;
inline long wait_duration_msec(long max_duration) const;
inline long wait_duration_usec(long max_duration) const;
inline void get_ready_timers(op_queue<operation>& ops);
inline void get_all_timers(op_queue<operation>& ops);
private:
timer_queue_base* first_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_TIMER_QUEUE_SET_IPP
namespace boost {
namespace asio {
namespace detail {
bool timer_queue_set::all_empty() const
{
for (timer_queue_base* p = first_; p; p = p->next_)
if (!p->empty())
return false;
return true;
}
}
}
}
#define BOOST_ASIO_DETAIL_WAIT_OP_HPP
namespace boost {
namespace asio {
namespace detail {
class wait_op
: public operation
{
public:
boost::system::error_code ec_;
protected:
wait_op(func_type func)
;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
class epoll_reactor
: public boost::asio::detail::service_base<epoll_reactor>
{
public:
enum op_types { read_op = 0, write_op = 1,
connect_op = 1, except_op = 2, max_ops = 3 };
class descriptor_state : operation
{
friend class epoll_reactor;
friend class object_pool_access;
descriptor_state* next_;
descriptor_state* prev_;
mutex mutex_;
epoll_reactor* reactor_;
int descriptor_;
uint32_t registered_events_;
op_queue<reactor_op> op_queue_[max_ops];
bool shutdown_;
inline descriptor_state();
void set_ready_events(uint32_t events) ;
inline operation* perform_io(uint32_t events);
inline static void do_complete(
io_service_impl* owner, operation* base,
const boost::system::error_code& ec, std::size_t bytes_transferred);
};
typedef descriptor_state* per_descriptor_data;
inline epoll_reactor(boost::asio::io_service& io_service);
inline ~epoll_reactor();
inline void shutdown_service();
inline void fork_service(
boost::asio::io_service::fork_event fork_ev);
inline void init_task();
inline int register_descriptor(socket_type descriptor,
per_descriptor_data& descriptor_data);
inline int register_internal_descriptor(
int op_type, socket_type descriptor,
per_descriptor_data& descriptor_data, reactor_op* op);
inline void move_descriptor(socket_type descriptor,
per_descriptor_data& target_descriptor_data,
per_descriptor_data& source_descriptor_data);
void post_immediate_completion(reactor_op* op, bool is_continuation)
;
inline void start_op(int op_type, socket_type descriptor,
per_descriptor_data& descriptor_data, reactor_op* op,
bool is_continuation, bool allow_speculative);
inline void cancel_ops(socket_type descriptor,
per_descriptor_data& descriptor_data);
inline void deregister_descriptor(socket_type descriptor,
per_descriptor_data& descriptor_data, bool closing);
inline void deregister_internal_descriptor(
socket_type descriptor, per_descriptor_data& descriptor_data);
template <typename Time_Traits>
void add_timer_queue(timer_queue<Time_Traits>& timer_queue);
template <typename Time_Traits>
void remove_timer_queue(timer_queue<Time_Traits>& timer_queue);
template <typename Time_Traits>
void schedule_timer(timer_queue<Time_Traits>& queue,
const typename Time_Traits::time_type& time,
typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op);
template <typename Time_Traits>
std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
typename timer_queue<Time_Traits>::per_timer_data& timer,
std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
inline void run(bool block, op_queue<operation>& ops);
inline void interrupt();
private:
enum { epoll_size = 20000 };
inline static int do_epoll_create();
inline static int do_timerfd_create();
inline descriptor_state* allocate_descriptor_state();
inline void free_descriptor_state(descriptor_state* s);
inline void do_add_timer_queue(timer_queue_base& queue);
inline void do_remove_timer_queue(timer_queue_base& queue);
inline void update_timeout();
inline int get_timeout();
inline int get_timeout(itimerspec& ts);
io_service_impl& io_service_;
mutex mutex_;
select_interrupter interrupter_;
int epoll_fd_;
int timer_fd_;
timer_queue_set timer_queues_;
bool shutdown_;
mutex registered_descriptors_mutex_;
object_pool<descriptor_state> registered_descriptors_;
struct perform_io_cleanup_on_block_exit;
friend struct perform_io_cleanup_on_block_exit;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_EPOLL_REACTOR_HPP
namespace boost {
namespace asio {
namespace detail {
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_EPOLL_REACTOR_IPP
#define _SYS_EPOLL_H 1
enum
{
EPOLL_CLOEXEC = 02000000
#define EPOLL_CLOEXEC EPOLL_CLOEXEC
};
#define __EPOLL_PACKED __attribute__ ((__packed__))
enum EPOLL_EVENTS
{
EPOLLIN = 0x001,
#define EPOLLIN EPOLLIN
EPOLLPRI = 0x002,
#define EPOLLPRI EPOLLPRI
EPOLLOUT = 0x004,
#define EPOLLOUT EPOLLOUT
EPOLLRDNORM = 0x040,
#define EPOLLRDNORM EPOLLRDNORM
EPOLLRDBAND = 0x080,
#define EPOLLRDBAND EPOLLRDBAND
EPOLLWRNORM = 0x100,
#define EPOLLWRNORM EPOLLWRNORM
EPOLLWRBAND = 0x200,
#define EPOLLWRBAND EPOLLWRBAND
EPOLLMSG = 0x400,
#define EPOLLMSG EPOLLMSG
EPOLLERR = 0x008,
#define EPOLLERR EPOLLERR
EPOLLHUP = 0x010,
#define EPOLLHUP EPOLLHUP
EPOLLRDHUP = 0x2000,
#define EPOLLRDHUP EPOLLRDHUP
EPOLLWAKEUP = 1u << 29,
#define EPOLLWAKEUP EPOLLWAKEUP
EPOLLONESHOT = 1u << 30,
#define EPOLLONESHOT EPOLLONESHOT
EPOLLET = 1u << 31
#define EPOLLET EPOLLET
};
#define EPOLL_CTL_ADD 1
#define EPOLL_CTL_DEL 2
#define EPOLL_CTL_MOD 3
typedef union epoll_data
{
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
struct epoll_event
{
uint32_t events;
epoll_data_t data;
} __attribute__ ((__packed__));
extern "C" {
extern int epoll_create (int __size) throw ();
extern int epoll_create1 (int __flags) throw ();
extern int epoll_ctl (int __epfd, int __op, int __fd,
struct epoll_event *__event) throw ();
extern int epoll_wait (int __epfd, struct epoll_event *__events,
int __maxevents, int __timeout);
extern int epoll_pwait (int __epfd, struct epoll_event *__events,
int __maxevents, int __timeout,
const __sigset_t *__ss);
}
#define _SYS_TIMERFD_H 1
enum
{
TFD_CLOEXEC = 02000000,
#define TFD_CLOEXEC TFD_CLOEXEC
TFD_NONBLOCK = 00004000
#define TFD_NONBLOCK TFD_NONBLOCK
};
enum
{
TFD_TIMER_ABSTIME = 1 << 0
#define TFD_TIMER_ABSTIME TFD_TIMER_ABSTIME
};
extern "C" {
extern int timerfd_create (clockid_t __clock_id, int __flags) throw ();
extern int timerfd_settime (int __ufd, int __flags,
const struct itimerspec *__utmr,
struct itimerspec *__otmr) throw ();
extern int timerfd_gettime (int __ufd, struct itimerspec *__otmr) throw ();
}
namespace boost {
namespace asio {
namespace detail {
struct epoll_reactor::perform_io_cleanup_on_block_exit
{
explicit perform_io_cleanup_on_block_exit(epoll_reactor* r)
;
~perform_io_cleanup_on_block_exit()
;
epoll_reactor* reactor_;
op_queue<operation> ops_;
operation* first_op_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
struct task_io_service::task_cleanup
{
~task_cleanup()
;
task_io_service* task_io_service_;
mutex::scoped_lock* lock_;
thread_info* this_thread_;
};
struct task_io_service::work_cleanup
{
~work_cleanup()
;
task_io_service* task_io_service_;
mutex::scoped_lock* lock_;
thread_info* this_thread_;
};
bool task_io_service::stopped() const
{
mutex::scoped_lock lock(mutex_);
return stopped_;
}
bool task_io_service::wake_one_idle_thread_and_unlock(
mutex::scoped_lock& lock)
{
if (first_idle_thread_)
{
thread_info* idle_thread = first_idle_thread_;
first_idle_thread_ = idle_thread->next;
idle_thread->next = 0;
idle_thread->wakeup_event->signal_and_unlock(lock);
return true;
}
return false;
}
}
}
}
namespace boost {
namespace asio {
}
}
#define BOOST_ASIO_IMPL_IO_SERVICE_IPP
#define BOOST_ASIO_DETAIL_SCOPED_PTR_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename T>
class scoped_ptr
{
public:
explicit scoped_ptr(T* p = 0)
;
~scoped_ptr()
;
T* get()
;
T* operator->()
;
T& operator*()
;
void reset(T* p = 0)
;
private:
scoped_ptr(const scoped_ptr&);
scoped_ptr& operator=(const scoped_ptr&);
T* p_;
};
}
}
}
namespace boost {
namespace asio {
bool io_service::stopped() const
{
return impl_.stopped();
}
}
}
namespace boost {
namespace asio {
namespace detail
{
template <typename IoObjectService>
class service_has_move
{
private:
typedef IoObjectService service_type;
typedef typename service_type::implementation_type implementation_type;
template <typename T, typename U>
static auto eval(T* t, U* u) -> decltype(t->move_construct(*u, *u), char());
static char (&eval(...))[2];
public:
static const bool value =
sizeof(service_has_move::eval(
static_cast<service_type*>(0),
static_cast<implementation_type*>(0))) == 1;
};
}
template <typename IoObjectService,
bool Movable = detail::service_has_move<IoObjectService>::value>
class basic_io_object
{
public:
typedef IoObjectService service_type;
typedef typename service_type::implementation_type implementation_type;
boost::asio::io_service& get_io_service()
;
protected:
explicit basic_io_object(boost::asio::io_service& io_service)
;
~basic_io_object()
;
service_type& get_service()
;
const service_type& get_service() const
;
service_type& service;
implementation_type& get_implementation()
;
const implementation_type& get_implementation() const
;
implementation_type implementation;
private:
basic_io_object(const basic_io_object&);
basic_io_object& operator=(const basic_io_object&);
};
template <typename IoObjectService>
class basic_io_object<IoObjectService, true>
{
public:
typedef IoObjectService service_type;
typedef typename service_type::implementation_type implementation_type;
boost::asio::io_service& get_io_service()
;
protected:
explicit basic_io_object(boost::asio::io_service& io_service)
;
basic_io_object(basic_io_object&& other)
;
~basic_io_object()
;
basic_io_object& operator=(basic_io_object&& other)
;
service_type& get_service()
;
const service_type& get_service() const
;
implementation_type& get_implementation()
;
const implementation_type& get_implementation() const
;
implementation_type implementation;
private:
basic_io_object(const basic_io_object&);
void operator=(const basic_io_object&);
IoObjectService* service_;
};
}
}
#define BOOST_ASIO_DETAIL_TYPE_TRAITS_HPP
namespace boost {
namespace asio {
using std::add_const;
using std::enable_if;
using std::is_const;
using std::is_convertible;
using std::is_function;
using std::is_same;
using std::remove_pointer;
using std::remove_reference;
}
}
#define BOOST_ASIO_SOCKET_BASE_HPP
#define BOOST_ASIO_DETAIL_IO_CONTROL_HPP
namespace boost {
namespace asio {
namespace detail {
namespace io_control {
class non_blocking_io
{
public:
non_blocking_io()
;
non_blocking_io(bool value)
;
int name() const
;
void set(bool value)
;
bool get() const
;
detail::ioctl_arg_type* data()
;
const detail::ioctl_arg_type* data() const
;
private:
detail::ioctl_arg_type value_;
};
class bytes_readable
{
public:
bytes_readable()
;
bytes_readable(std::size_t value)
;
int name() const
;
void set(std::size_t value)
;
std::size_t get() const
;
detail::ioctl_arg_type* data()
;
const detail::ioctl_arg_type* data() const
;
private:
detail::ioctl_arg_type value_;
};
}
}
}
}
#define BOOST_ASIO_DETAIL_SOCKET_OPTION_HPP
namespace boost {
namespace asio {
namespace detail {
namespace socket_option {
template <int Level, int Name>
class boolean
{
public:
boolean()
;
explicit boolean(bool v)
;
boolean& operator=(bool v)
;
bool value() const
;
operator bool() const
;
bool operator!() const
;
template <typename Protocol>
int level(const Protocol&) const
;
template <typename Protocol>
int name(const Protocol&) const
;
template <typename Protocol>
int* data(const Protocol&)
;
template <typename Protocol>
const int* data(const Protocol&) const
;
template <typename Protocol>
std::size_t size(const Protocol&) const
;
template <typename Protocol>
void resize(const Protocol&, std::size_t s)
;
private:
int value_;
};
template <int Level, int Name>
class integer
{
public:
integer()
;
explicit integer(int v)
;
integer& operator=(int v)
;
int value() const
;
template <typename Protocol>
int level(const Protocol&) const
;
template <typename Protocol>
int name(const Protocol&) const
;
template <typename Protocol>
int* data(const Protocol&)
;
template <typename Protocol>
const int* data(const Protocol&) const
;
template <typename Protocol>
std::size_t size(const Protocol&) const
;
template <typename Protocol>
void resize(const Protocol&, std::size_t s)
;
private:
int value_;
};
template <int Level, int Name>
class linger
{
public:
linger()
;
linger(bool e, int t)
;
void enabled(bool value)
;
bool enabled() const
;
void timeout (int value)
;
int timeout () const
;
template <typename Protocol>
int level(const Protocol&) const
;
template <typename Protocol>
int name(const Protocol&) const
;
template <typename Protocol>
detail::linger_type* data(const Protocol&)
;
template <typename Protocol>
const detail::linger_type* data(const Protocol&) const
;
template <typename Protocol>
std::size_t size(const Protocol&) const
;
template <typename Protocol>
void resize(const Protocol&, std::size_t s)
;
private:
detail::linger_type value_;
};
}
}
}
}
namespace boost {
namespace asio {
class socket_base
{
public:
enum shutdown_type
{
shutdown_receive = SHUT_RD,
shutdown_send = SHUT_WR,
shutdown_both = SHUT_RDWR
};
typedef int message_flags;
static const int message_peek = MSG_PEEK;
static const int message_out_of_band = MSG_OOB;
static const int message_do_not_route = MSG_DONTROUTE;
static const int message_end_of_record = MSG_EOR;
typedef boost::asio::detail::socket_option::boolean<
1, 6>
broadcast;
typedef boost::asio::detail::socket_option::boolean<
1, 1> debug;
typedef boost::asio::detail::socket_option::boolean<
1, 5>
do_not_route;
typedef boost::asio::detail::socket_option::boolean<
1, 9> keep_alive;
typedef boost::asio::detail::socket_option::integer<
1, 7>
send_buffer_size;
typedef boost::asio::detail::socket_option::integer<
1, 19>
send_low_watermark;
typedef boost::asio::detail::socket_option::integer<
1, 8>
receive_buffer_size;
typedef boost::asio::detail::socket_option::integer<
1, 18>
receive_low_watermark;
typedef boost::asio::detail::socket_option::boolean<
1, 2>
reuse_address;
typedef boost::asio::detail::socket_option::linger<
1, 13>
linger;
typedef boost::asio::detail::socket_option::boolean<
boost::asio::detail::custom_socket_option_level,
boost::asio::detail::enable_connection_aborted_option>
enable_connection_aborted;
typedef boost::asio::detail::io_control::non_blocking_io non_blocking_io;
typedef boost::asio::detail::io_control::bytes_readable bytes_readable;
static const int max_connections = 128;
protected:
~socket_base()
;
};
}
}
namespace boost {
namespace asio {
template <typename Protocol, typename SocketService>
class basic_socket
: public basic_io_object<SocketService>,
public socket_base
{
public:
typedef typename SocketService::native_handle_type native_type;
typedef typename SocketService::native_handle_type native_handle_type;
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
typedef basic_socket<Protocol, SocketService> lowest_layer_type;
explicit basic_socket(boost::asio::io_service& io_service)
;
basic_socket(boost::asio::io_service& io_service,
const protocol_type& protocol)
;
basic_socket(boost::asio::io_service& io_service,
const endpoint_type& endpoint)
;
basic_socket(boost::asio::io_service& io_service,
const protocol_type& protocol, const native_handle_type& native_socket)
;
basic_socket(basic_socket&& other)
;
basic_socket& operator=(basic_socket&& other)
;
template <typename Protocol1, typename SocketService1>
friend class basic_socket;
template <typename Protocol1, typename SocketService1>
basic_socket(basic_socket<Protocol1, SocketService1>&& other,
typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
;
template <typename Protocol1, typename SocketService1>
typename enable_if<is_convertible<Protocol1, Protocol>::value,
basic_socket>::type& operator=(
basic_socket<Protocol1, SocketService1>&& other)
;
lowest_layer_type& lowest_layer()
;
const lowest_layer_type& lowest_layer() const
;
void open(const protocol_type& protocol = protocol_type())
;
boost::system::error_code open(const protocol_type& protocol,
boost::system::error_code& ec)
;
void assign(const protocol_type& protocol,
const native_handle_type& native_socket)
;
boost::system::error_code assign(const protocol_type& protocol,
const native_handle_type& native_socket, boost::system::error_code& ec)
;
bool is_open() const
;
void close()
;
boost::system::error_code close(boost::system::error_code& ec)
;
native_type native()
;
native_handle_type native_handle()
;
void cancel()
;
boost::system::error_code cancel(boost::system::error_code& ec)
;
bool at_mark() const
;
bool at_mark(boost::system::error_code& ec) const
;
std::size_t available() const
;
std::size_t available(boost::system::error_code& ec) const
;
void bind(const endpoint_type& endpoint)
;
boost::system::error_code bind(const endpoint_type& endpoint,
boost::system::error_code& ec)
;
void connect(const endpoint_type& peer_endpoint)
;
boost::system::error_code connect(const endpoint_type& peer_endpoint,
boost::system::error_code& ec)
;
template <typename ConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ConnectHandler, void (boost::system::error_code)>::type>::type
async_connect(const endpoint_type& peer_endpoint,
ConnectHandler&& handler)
;
template <typename SettableSocketOption>
void set_option(const SettableSocketOption& option)
;
template <typename SettableSocketOption>
boost::system::error_code set_option(const SettableSocketOption& option,
boost::system::error_code& ec)
;
template <typename GettableSocketOption>
void get_option(GettableSocketOption& option) const
;
template <typename GettableSocketOption>
boost::system::error_code get_option(GettableSocketOption& option,
boost::system::error_code& ec) const
;
template <typename IoControlCommand>
void io_control(IoControlCommand& command)
;
template <typename IoControlCommand>
boost::system::error_code io_control(IoControlCommand& command,
boost::system::error_code& ec)
;
bool non_blocking() const
;
void non_blocking(bool mode)
;
boost::system::error_code non_blocking(
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking() const
;
void native_non_blocking(bool mode)
;
boost::system::error_code native_non_blocking(
bool mode, boost::system::error_code& ec)
;
endpoint_type local_endpoint() const
;
endpoint_type local_endpoint(boost::system::error_code& ec) const
;
endpoint_type remote_endpoint() const
;
endpoint_type remote_endpoint(boost::system::error_code& ec) const
;
void shutdown(shutdown_type what)
;
boost::system::error_code shutdown(shutdown_type what,
boost::system::error_code& ec)
;
protected:
~basic_socket()
;
};
}
}
#define BOOST_ASIO_DATAGRAM_SOCKET_SERVICE_HPP
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_HPP
#define BOOST_ASIO_BUFFER_HPP
#define _GLIBCXX_CSTRING 1
#undef memchr
#undef memcmp
#undef memcpy
#undef memmove
#undef memset
#undef strcat
#undef strchr
#undef strcmp
#undef strcoll
#undef strcpy
#undef strcspn
#undef strerror
#undef strlen
#undef strncat
#undef strncmp
#undef strncpy
#undef strpbrk
#undef strrchr
#undef strspn
#undef strstr
#undef strtok
#undef strxfrm
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::memchr;
using ::memcmp;
using ::memcpy;
using ::memmove;
using ::memset;
using ::strcat;
using ::strcmp;
using ::strcoll;
using ::strcpy;
using ::strcspn;
using ::strerror;
using ::strlen;
using ::strncat;
using ::strncmp;
using ::strncpy;
using ::strspn;
using ::strtok;
using ::strxfrm;
using ::strchr;
using ::strpbrk;
using ::strrchr;
using ::strstr;
}
#define BOOST_ASIO_DETAIL_ARRAY_FWD_HPP
namespace boost {
template<class T, std::size_t N>
class array;
}
namespace boost {
namespace asio {
class mutable_buffer;
class const_buffer;
namespace detail {
void* buffer_cast_helper(const mutable_buffer&);
const void* buffer_cast_helper(const const_buffer&);
std::size_t buffer_size_helper(const mutable_buffer&);
std::size_t buffer_size_helper(const const_buffer&);
}
class mutable_buffer
{
public:
mutable_buffer()
;
mutable_buffer(void* data, std::size_t size)
;
private:
friend void* boost::asio::detail::buffer_cast_helper(
const mutable_buffer& b);
friend std::size_t boost::asio::detail::buffer_size_helper(
const mutable_buffer& b);
void* data_;
std::size_t size_;
};
namespace detail {
void* buffer_cast_helper(const mutable_buffer& b)
;
std::size_t buffer_size_helper(const mutable_buffer& b)
;
}
class mutable_buffers_1
: public mutable_buffer
{
public:
typedef mutable_buffer value_type;
typedef const mutable_buffer* const_iterator;
mutable_buffers_1(void* data, std::size_t size)
;
explicit mutable_buffers_1(const mutable_buffer& b)
;
const_iterator begin() const
;
const_iterator end() const
;
};
class const_buffer
{
public:
const_buffer()
;
const_buffer(const void* data, std::size_t size)
;
const_buffer(const mutable_buffer& b)
;
private:
friend const void* boost::asio::detail::buffer_cast_helper(
const const_buffer& b);
friend std::size_t boost::asio::detail::buffer_size_helper(
const const_buffer& b);
const void* data_;
std::size_t size_;
};
namespace detail {
const void* buffer_cast_helper(const const_buffer& b)
;
std::size_t buffer_size_helper(const const_buffer& b)
;
}
class const_buffers_1
: public const_buffer
{
public:
typedef const_buffer value_type;
typedef const const_buffer* const_iterator;
const_buffers_1(const void* data, std::size_t size)
;
explicit const_buffers_1(const const_buffer& b)
;
const_iterator begin() const
;
const_iterator end() const
;
};
class null_buffers
{
public:
typedef mutable_buffer value_type;
typedef const mutable_buffer* const_iterator;
const_iterator begin() const
;
const_iterator end() const
;
private:
mutable_buffer buf_;
};
std::size_t buffer_size(const mutable_buffer& b)
;
std::size_t buffer_size(const mutable_buffers_1& b)
;
std::size_t buffer_size(const const_buffer& b)
;
std::size_t buffer_size(const const_buffers_1& b)
;
template <typename BufferSequence>
std::size_t buffer_size(const BufferSequence& b)
;
template <typename PointerToPodType>
PointerToPodType buffer_cast(const mutable_buffer& b)
;
template <typename PointerToPodType>
PointerToPodType buffer_cast(const const_buffer& b)
;
mutable_buffer operator+(const mutable_buffer& b, std::size_t start)
;
mutable_buffer operator+(std::size_t start, const mutable_buffer& b)
;
const_buffer operator+(const const_buffer& b, std::size_t start)
;
const_buffer operator+(std::size_t start, const const_buffer& b)
;
mutable_buffers_1 buffer(const mutable_buffer& b)
;
mutable_buffers_1 buffer(const mutable_buffer& b,
std::size_t max_size_in_bytes)
;
const_buffers_1 buffer(const const_buffer& b)
;
const_buffers_1 buffer(const const_buffer& b,
std::size_t max_size_in_bytes)
;
mutable_buffers_1 buffer(void* data, std::size_t size_in_bytes)
;
const_buffers_1 buffer(const void* data,
std::size_t size_in_bytes)
;
template <typename PodType, std::size_t N>
mutable_buffers_1 buffer(PodType (&data)[N])
;
template <typename PodType, std::size_t N>
mutable_buffers_1 buffer(PodType (&data)[N],
std::size_t max_size_in_bytes)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(const PodType (&data)[N])
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(const PodType (&data)[N],
std::size_t max_size_in_bytes)
;
template <typename PodType, std::size_t N>
mutable_buffers_1 buffer(boost::array<PodType, N>& data)
;
template <typename PodType, std::size_t N>
mutable_buffers_1 buffer(boost::array<PodType, N>& data,
std::size_t max_size_in_bytes)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(boost::array<const PodType, N>& data)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(boost::array<const PodType, N>& data,
std::size_t max_size_in_bytes)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(const boost::array<PodType, N>& data)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(const boost::array<PodType, N>& data,
std::size_t max_size_in_bytes)
;
template <typename PodType, std::size_t N>
mutable_buffers_1 buffer(std::array<PodType, N>& data)
;
template <typename PodType, std::size_t N>
mutable_buffers_1 buffer(std::array<PodType, N>& data,
std::size_t max_size_in_bytes)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(std::array<const PodType, N>& data)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(std::array<const PodType, N>& data,
std::size_t max_size_in_bytes)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(const std::array<PodType, N>& data)
;
template <typename PodType, std::size_t N>
const_buffers_1 buffer(const std::array<PodType, N>& data,
std::size_t max_size_in_bytes)
;
template <typename PodType, typename Allocator>
mutable_buffers_1 buffer(std::vector<PodType, Allocator>& data)
;
template <typename PodType, typename Allocator>
mutable_buffers_1 buffer(std::vector<PodType, Allocator>& data,
std::size_t max_size_in_bytes)
;
template <typename PodType, typename Allocator>
const_buffers_1 buffer(
const std::vector<PodType, Allocator>& data)
;
template <typename PodType, typename Allocator>
const_buffers_1 buffer(
const std::vector<PodType, Allocator>& data, std::size_t max_size_in_bytes)
;
template <typename Elem, typename Traits, typename Allocator>
const_buffers_1 buffer(
const std::basic_string<Elem, Traits, Allocator>& data)
;
template <typename Elem, typename Traits, typename Allocator>
const_buffers_1 buffer(
const std::basic_string<Elem, Traits, Allocator>& data,
std::size_t max_size_in_bytes)
;
std::size_t buffer_copy(const mutable_buffer& target,
const const_buffer& source)
;
std::size_t buffer_copy(const mutable_buffer& target,
const const_buffers_1& source)
;
std::size_t buffer_copy(const mutable_buffer& target,
const mutable_buffer& source)
;
std::size_t buffer_copy(const mutable_buffer& target,
const mutable_buffers_1& source)
;
template <typename ConstBufferSequence>
std::size_t buffer_copy(const mutable_buffer& target,
const ConstBufferSequence& source)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const const_buffer& source)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const const_buffers_1& source)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const mutable_buffer& source)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const mutable_buffers_1& source)
;
template <typename ConstBufferSequence>
std::size_t buffer_copy(const mutable_buffers_1& target,
const ConstBufferSequence& source)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const const_buffer& source)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const const_buffers_1& source)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const mutable_buffer& source)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const mutable_buffers_1& source)
;
template <typename MutableBufferSequence, typename ConstBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const ConstBufferSequence& source)
;
std::size_t buffer_copy(const mutable_buffer& target,
const const_buffer& source, std::size_t max_bytes_to_copy)
;
std::size_t buffer_copy(const mutable_buffer& target,
const const_buffers_1& source, std::size_t max_bytes_to_copy)
;
std::size_t buffer_copy(const mutable_buffer& target,
const mutable_buffer& source, std::size_t max_bytes_to_copy)
;
std::size_t buffer_copy(const mutable_buffer& target,
const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
;
template <typename ConstBufferSequence>
std::size_t buffer_copy(const mutable_buffer& target,
const ConstBufferSequence& source, std::size_t max_bytes_to_copy)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const const_buffer& source, std::size_t max_bytes_to_copy)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const const_buffers_1& source, std::size_t max_bytes_to_copy)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const mutable_buffer& source, std::size_t max_bytes_to_copy)
;
std::size_t buffer_copy(const mutable_buffers_1& target,
const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
;
template <typename ConstBufferSequence>
std::size_t buffer_copy(const mutable_buffers_1& target,
const ConstBufferSequence& source, std::size_t max_bytes_to_copy)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const const_buffer& source, std::size_t max_bytes_to_copy)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const const_buffers_1& source, std::size_t max_bytes_to_copy)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const mutable_buffer& source, std::size_t max_bytes_to_copy)
;
template <typename MutableBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
;
template <typename MutableBufferSequence, typename ConstBufferSequence>
std::size_t buffer_copy(const MutableBufferSequence& target,
const ConstBufferSequence& source, std::size_t max_bytes_to_copy)
;
}
}
#define BOOST_ASIO_DETAIL_BUFFER_SEQUENCE_ADAPTER_HPP
namespace boost {
namespace asio {
namespace detail {
class buffer_sequence_adapter_base
{
protected:
enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len };
typedef iovec native_buffer_type;
static void init_iov_base(void*& base, void* addr)
;
template <typename T>
static void init_iov_base(T& base, void* addr)
;
static void init_native_buffer(iovec& iov,
const boost::asio::mutable_buffer& buffer)
;
static void init_native_buffer(iovec& iov,
const boost::asio::const_buffer& buffer)
;
};
template <typename Buffer, typename Buffers>
class buffer_sequence_adapter
: buffer_sequence_adapter_base
{
public:
explicit buffer_sequence_adapter(const Buffers& buffer_sequence)
;
native_buffer_type* buffers()
;
std::size_t count() const
;
bool all_empty() const
;
static bool all_empty(const Buffers& buffer_sequence)
;
static void validate(const Buffers& buffer_sequence)
;
static Buffer first(const Buffers& buffer_sequence)
;
private:
native_buffer_type buffers_[max_buffers];
std::size_t count_;
std::size_t total_buffer_size_;
};
template <typename Buffer>
class buffer_sequence_adapter<Buffer, boost::asio::mutable_buffers_1>
: buffer_sequence_adapter_base
{
public:
explicit buffer_sequence_adapter(
const boost::asio::mutable_buffers_1& buffer_sequence)
;
native_buffer_type* buffers()
;
std::size_t count() const
;
bool all_empty() const
;
static bool all_empty(const boost::asio::mutable_buffers_1& buffer_sequence)
;
static void validate(const boost::asio::mutable_buffers_1& buffer_sequence)
;
static Buffer first(const boost::asio::mutable_buffers_1& buffer_sequence)
;
private:
native_buffer_type buffer_;
std::size_t total_buffer_size_;
};
template <typename Buffer>
class buffer_sequence_adapter<Buffer, boost::asio::const_buffers_1>
: buffer_sequence_adapter_base
{
public:
explicit buffer_sequence_adapter(
const boost::asio::const_buffers_1& buffer_sequence)
;
native_buffer_type* buffers()
;
std::size_t count() const
;
bool all_empty() const
;
static bool all_empty(const boost::asio::const_buffers_1& buffer_sequence)
;
static void validate(const boost::asio::const_buffers_1& buffer_sequence)
;
static Buffer first(const boost::asio::const_buffers_1& buffer_sequence)
;
private:
native_buffer_type buffer_;
std::size_t total_buffer_size_;
};
template <typename Buffer, typename Elem>
class buffer_sequence_adapter<Buffer, boost::array<Elem, 2> >
: buffer_sequence_adapter_base
{
public:
explicit buffer_sequence_adapter(
const boost::array<Elem, 2>& buffer_sequence)
;
native_buffer_type* buffers()
;
std::size_t count() const
;
bool all_empty() const
;
static bool all_empty(const boost::array<Elem, 2>& buffer_sequence)
;
static void validate(const boost::array<Elem, 2>& buffer_sequence)
;
static Buffer first(const boost::array<Elem, 2>& buffer_sequence)
;
private:
native_buffer_type buffers_[2];
std::size_t total_buffer_size_;
};
template <typename Buffer, typename Elem>
class buffer_sequence_adapter<Buffer, std::array<Elem, 2> >
: buffer_sequence_adapter_base
{
public:
explicit buffer_sequence_adapter(
const std::array<Elem, 2>& buffer_sequence)
;
native_buffer_type* buffers()
;
std::size_t count() const
;
bool all_empty() const
;
static bool all_empty(const std::array<Elem, 2>& buffer_sequence)
;
static void validate(const std::array<Elem, 2>& buffer_sequence)
;
static Buffer first(const std::array<Elem, 2>& buffer_sequence)
;
private:
native_buffer_type buffers_[2];
std::size_t total_buffer_size_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_BUFFER_SEQUENCE_ADAPTER_IPP
#define BOOST_ASIO_DETAIL_REACTIVE_NULL_BUFFERS_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Handler>
class reactive_null_buffers_op : public reactor_op
{
public:
struct ptr { Handler* h; void* v; reactive_null_buffers_op* p; ~ptr() ; void reset() ; };
reactive_null_buffers_op(Handler& handler)
;
static bool do_perform(reactor_op*)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_ACCEPT_OP_HPP
#define BOOST_ASIO_DETAIL_SOCKET_HOLDER_HPP
#define BOOST_ASIO_DETAIL_SOCKET_OPS_HPP
#define BOOST_ASIO_DETAIL_SHARED_PTR_HPP
namespace boost {
namespace asio {
namespace detail {
using std::shared_ptr;
}
}
}
#define BOOST_ASIO_DETAIL_WEAK_PTR_HPP
namespace boost {
namespace asio {
namespace detail {
using std::weak_ptr;
}
}
}
namespace boost {
namespace asio {
namespace detail {
namespace socket_ops {
enum
{
user_set_non_blocking = 1,
internal_non_blocking = 2,
non_blocking = user_set_non_blocking | internal_non_blocking,
enable_connection_aborted = 4,
user_set_linger = 8,
stream_oriented = 16,
datagram_oriented = 32,
possible_dup = 64
};
typedef unsigned char state_type;
struct noop_deleter { void operator()(void*) ; };
typedef shared_ptr<void> shared_cancel_token_type;
typedef weak_ptr<void> weak_cancel_token_type;
inline socket_type accept(socket_type s, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec);
inline socket_type sync_accept(socket_type s,
state_type state, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec);
inline bool non_blocking_accept(socket_type s,
state_type state, socket_addr_type* addr, std::size_t* addrlen,
boost::system::error_code& ec, socket_type& new_socket);
inline int bind(socket_type s, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec);
inline int close(socket_type s, state_type& state,
bool destruction, boost::system::error_code& ec);
inline bool set_user_non_blocking(socket_type s,
state_type& state, bool value, boost::system::error_code& ec);
inline bool set_internal_non_blocking(socket_type s,
state_type& state, bool value, boost::system::error_code& ec);
inline int shutdown(socket_type s,
int what, boost::system::error_code& ec);
inline int connect(socket_type s, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec);
inline void sync_connect(socket_type s, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec);
inline bool non_blocking_connect(socket_type s,
boost::system::error_code& ec);
inline int socketpair(int af, int type, int protocol,
socket_type sv[2], boost::system::error_code& ec);
inline bool sockatmark(socket_type s, boost::system::error_code& ec);
inline size_t available(socket_type s, boost::system::error_code& ec);
inline int listen(socket_type s,
int backlog, boost::system::error_code& ec);
typedef iovec buf;
inline void init_buf(buf& b, void* data, size_t size);
inline void init_buf(buf& b, const void* data, size_t size);
inline signed_size_type recv(socket_type s, buf* bufs,
size_t count, int flags, boost::system::error_code& ec);
inline size_t sync_recv(socket_type s, state_type state, buf* bufs,
size_t count, int flags, bool all_empty, boost::system::error_code& ec);
inline bool non_blocking_recv(socket_type s,
buf* bufs, size_t count, int flags, bool is_stream,
boost::system::error_code& ec, size_t& bytes_transferred);
inline signed_size_type recvfrom(socket_type s, buf* bufs,
size_t count, int flags, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec);
inline size_t sync_recvfrom(socket_type s, state_type state,
buf* bufs, size_t count, int flags, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec);
inline bool non_blocking_recvfrom(socket_type s,
buf* bufs, size_t count, int flags,
socket_addr_type* addr, std::size_t* addrlen,
boost::system::error_code& ec, size_t& bytes_transferred);
inline signed_size_type recvmsg(socket_type s, buf* bufs,
size_t count, int in_flags, int& out_flags,
boost::system::error_code& ec);
inline size_t sync_recvmsg(socket_type s, state_type state,
buf* bufs, size_t count, int in_flags, int& out_flags,
boost::system::error_code& ec);
inline bool non_blocking_recvmsg(socket_type s,
buf* bufs, size_t count, int in_flags, int& out_flags,
boost::system::error_code& ec, size_t& bytes_transferred);
inline signed_size_type send(socket_type s, const buf* bufs,
size_t count, int flags, boost::system::error_code& ec);
inline size_t sync_send(socket_type s, state_type state,
const buf* bufs, size_t count, int flags,
bool all_empty, boost::system::error_code& ec);
inline bool non_blocking_send(socket_type s,
const buf* bufs, size_t count, int flags,
boost::system::error_code& ec, size_t& bytes_transferred);
inline signed_size_type sendto(socket_type s, const buf* bufs,
size_t count, int flags, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec);
inline size_t sync_sendto(socket_type s, state_type state,
const buf* bufs, size_t count, int flags, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec);
inline bool non_blocking_sendto(socket_type s,
const buf* bufs, size_t count, int flags,
const socket_addr_type* addr, std::size_t addrlen,
boost::system::error_code& ec, size_t& bytes_transferred);
inline socket_type socket(int af, int type, int protocol,
boost::system::error_code& ec);
inline int setsockopt(socket_type s, state_type& state,
int level, int optname, const void* optval,
std::size_t optlen, boost::system::error_code& ec);
inline int getsockopt(socket_type s, state_type state,
int level, int optname, void* optval,
size_t* optlen, boost::system::error_code& ec);
inline int getpeername(socket_type s, socket_addr_type* addr,
std::size_t* addrlen, bool cached, boost::system::error_code& ec);
inline int getsockname(socket_type s, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec);
inline int ioctl(socket_type s, state_type& state,
int cmd, ioctl_arg_type* arg, boost::system::error_code& ec);
inline int select(int nfds, fd_set* readfds, fd_set* writefds,
fd_set* exceptfds, timeval* timeout, boost::system::error_code& ec);
inline int poll_read(socket_type s,
state_type state, boost::system::error_code& ec);
inline int poll_write(socket_type s,
state_type state, boost::system::error_code& ec);
inline int poll_connect(socket_type s, boost::system::error_code& ec);
inline const char* inet_ntop(int af, const void* src, char* dest,
size_t length, unsigned long scope_id, boost::system::error_code& ec);
inline int inet_pton(int af, const char* src, void* dest,
unsigned long* scope_id, boost::system::error_code& ec);
inline int gethostname(char* name,
int namelen, boost::system::error_code& ec);
inline boost::system::error_code getaddrinfo(const char* host,
const char* service, const addrinfo_type& hints,
addrinfo_type** result, boost::system::error_code& ec);
inline boost::system::error_code background_getaddrinfo(
const weak_cancel_token_type& cancel_token, const char* host,
const char* service, const addrinfo_type& hints,
addrinfo_type** result, boost::system::error_code& ec);
inline void freeaddrinfo(addrinfo_type* ai);
inline boost::system::error_code getnameinfo(
const socket_addr_type* addr, std::size_t addrlen,
char* host, std::size_t hostlen, char* serv,
std::size_t servlen, int flags, boost::system::error_code& ec);
inline boost::system::error_code sync_getnameinfo(
const socket_addr_type* addr, std::size_t addrlen,
char* host, std::size_t hostlen, char* serv,
std::size_t servlen, int sock_type, boost::system::error_code& ec);
inline boost::system::error_code background_getnameinfo(
const weak_cancel_token_type& cancel_token,
const socket_addr_type* addr, std::size_t addrlen,
char* host, std::size_t hostlen, char* serv,
std::size_t servlen, int sock_type, boost::system::error_code& ec);
inline u_long_type network_to_host_long(u_long_type value);
inline u_long_type host_to_network_long(u_long_type value);
inline u_short_type network_to_host_short(u_short_type value);
inline u_short_type host_to_network_short(u_short_type value);
}
}
}
}
#define BOOST_ASIO_DETAIL_SOCKET_OPS_IPP
#undef __need_error_t
namespace boost {
namespace asio {
namespace detail {
namespace socket_ops {
void clear_last_error()
;
template <typename ReturnType>
ReturnType error_wrapper(ReturnType return_value,
boost::system::error_code& ec)
;
template <typename SockLenType>
socket_type call_accept(SockLenType msghdr::*,
socket_type s, socket_addr_type* addr, std::size_t* addrlen)
;
socket_type accept(socket_type s, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec)
;
socket_type sync_accept(socket_type s, state_type state,
socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec)
;
bool non_blocking_accept(socket_type s,
state_type state, socket_addr_type* addr, std::size_t* addrlen,
boost::system::error_code& ec, socket_type& new_socket)
;
template <typename SockLenType>
int call_bind(SockLenType msghdr::*,
socket_type s, const socket_addr_type* addr, std::size_t addrlen)
;
int bind(socket_type s, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec)
;
int close(socket_type s, state_type& state,
bool destruction, boost::system::error_code& ec)
;
bool set_user_non_blocking(socket_type s,
state_type& state, bool value, boost::system::error_code& ec)
;
bool set_internal_non_blocking(socket_type s,
state_type& state, bool value, boost::system::error_code& ec)
;
int shutdown(socket_type s, int what, boost::system::error_code& ec)
;
template <typename SockLenType>
int call_connect(SockLenType msghdr::*,
socket_type s, const socket_addr_type* addr, std::size_t addrlen)
;
int connect(socket_type s, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec)
;
void sync_connect(socket_type s, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec)
;
bool non_blocking_connect(socket_type s, boost::system::error_code& ec)
;
int socketpair(int af, int type, int protocol,
socket_type sv[2], boost::system::error_code& ec)
;
bool sockatmark(socket_type s, boost::system::error_code& ec)
;
size_t available(socket_type s, boost::system::error_code& ec)
;
int listen(socket_type s, int backlog, boost::system::error_code& ec)
;
void init_buf_iov_base(void*& base, void* addr)
;
template <typename T>
void init_buf_iov_base(T& base, void* addr)
;
typedef iovec buf;
void init_buf(buf& b, void* data, size_t size)
;
void init_buf(buf& b, const void* data, size_t size)
;
void init_msghdr_msg_name(void*& name, socket_addr_type* addr)
;
void init_msghdr_msg_name(void*& name, const socket_addr_type* addr)
;
template <typename T>
void init_msghdr_msg_name(T& name, socket_addr_type* addr)
;
template <typename T>
void init_msghdr_msg_name(T& name, const socket_addr_type* addr)
;
signed_size_type recv(socket_type s, buf* bufs, size_t count,
int flags, boost::system::error_code& ec)
;
size_t sync_recv(socket_type s, state_type state, buf* bufs,
size_t count, int flags, bool all_empty, boost::system::error_code& ec)
;
bool non_blocking_recv(socket_type s,
buf* bufs, size_t count, int flags, bool is_stream,
boost::system::error_code& ec, size_t& bytes_transferred)
;
signed_size_type recvfrom(socket_type s, buf* bufs, size_t count,
int flags, socket_addr_type* addr, std::size_t* addrlen,
boost::system::error_code& ec)
;
size_t sync_recvfrom(socket_type s, state_type state, buf* bufs,
size_t count, int flags, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec)
;
bool non_blocking_recvfrom(socket_type s,
buf* bufs, size_t count, int flags,
socket_addr_type* addr, std::size_t* addrlen,
boost::system::error_code& ec, size_t& bytes_transferred)
;
signed_size_type recvmsg(socket_type s, buf* bufs, size_t count,
int in_flags, int& out_flags, boost::system::error_code& ec)
;
size_t sync_recvmsg(socket_type s, state_type state,
buf* bufs, size_t count, int in_flags, int& out_flags,
boost::system::error_code& ec)
;
bool non_blocking_recvmsg(socket_type s,
buf* bufs, size_t count, int in_flags, int& out_flags,
boost::system::error_code& ec, size_t& bytes_transferred)
;
signed_size_type send(socket_type s, const buf* bufs, size_t count,
int flags, boost::system::error_code& ec)
;
size_t sync_send(socket_type s, state_type state, const buf* bufs,
size_t count, int flags, bool all_empty, boost::system::error_code& ec)
;
bool non_blocking_send(socket_type s,
const buf* bufs, size_t count, int flags,
boost::system::error_code& ec, size_t& bytes_transferred)
;
signed_size_type sendto(socket_type s, const buf* bufs, size_t count,
int flags, const socket_addr_type* addr, std::size_t addrlen,
boost::system::error_code& ec)
;
size_t sync_sendto(socket_type s, state_type state, const buf* bufs,
size_t count, int flags, const socket_addr_type* addr,
std::size_t addrlen, boost::system::error_code& ec)
;
bool non_blocking_sendto(socket_type s,
const buf* bufs, size_t count, int flags,
const socket_addr_type* addr, std::size_t addrlen,
boost::system::error_code& ec, size_t& bytes_transferred)
;
socket_type socket(int af, int type, int protocol,
boost::system::error_code& ec)
;
template <typename SockLenType>
int call_setsockopt(SockLenType msghdr::*,
socket_type s, int level, int optname,
const void* optval, std::size_t optlen)
;
int setsockopt(socket_type s, state_type& state, int level, int optname,
const void* optval, std::size_t optlen, boost::system::error_code& ec)
;
template <typename SockLenType>
int call_getsockopt(SockLenType msghdr::*,
socket_type s, int level, int optname,
void* optval, std::size_t* optlen)
;
int getsockopt(socket_type s, state_type state, int level, int optname,
void* optval, size_t* optlen, boost::system::error_code& ec)
;
template <typename SockLenType>
int call_getpeername(SockLenType msghdr::*,
socket_type s, socket_addr_type* addr, std::size_t* addrlen)
;
int getpeername(socket_type s, socket_addr_type* addr,
std::size_t* addrlen, bool cached, boost::system::error_code& ec)
;
template <typename SockLenType>
int call_getsockname(SockLenType msghdr::*,
socket_type s, socket_addr_type* addr, std::size_t* addrlen)
;
int getsockname(socket_type s, socket_addr_type* addr,
std::size_t* addrlen, boost::system::error_code& ec)
;
int ioctl(socket_type s, state_type& state, int cmd,
ioctl_arg_type* arg, boost::system::error_code& ec)
;
int select(int nfds, fd_set* readfds, fd_set* writefds,
fd_set* exceptfds, timeval* timeout, boost::system::error_code& ec)
;
int poll_read(socket_type s, state_type state, boost::system::error_code& ec)
;
int poll_write(socket_type s, state_type state, boost::system::error_code& ec)
;
int poll_connect(socket_type s, boost::system::error_code& ec)
;
const char* inet_ntop(int af, const void* src, char* dest, size_t length,
unsigned long scope_id, boost::system::error_code& ec)
;
int inet_pton(int af, const char* src, void* dest,
unsigned long* scope_id, boost::system::error_code& ec)
;
int gethostname(char* name, int namelen, boost::system::error_code& ec)
;
boost::system::error_code translate_addrinfo_error(int error)
;
boost::system::error_code getaddrinfo(const char* host,
const char* service, const addrinfo_type& hints,
addrinfo_type** result, boost::system::error_code& ec)
;
boost::system::error_code background_getaddrinfo(
const weak_cancel_token_type& cancel_token, const char* host,
const char* service, const addrinfo_type& hints,
addrinfo_type** result, boost::system::error_code& ec)
;
void freeaddrinfo(addrinfo_type* ai)
;
boost::system::error_code getnameinfo(const socket_addr_type* addr,
std::size_t addrlen, char* host, std::size_t hostlen,
char* serv, std::size_t servlen, int flags, boost::system::error_code& ec)
;
boost::system::error_code sync_getnameinfo(
const socket_addr_type* addr, std::size_t addrlen,
char* host, std::size_t hostlen, char* serv,
std::size_t servlen, int sock_type, boost::system::error_code& ec)
;
boost::system::error_code background_getnameinfo(
const weak_cancel_token_type& cancel_token,
const socket_addr_type* addr, std::size_t addrlen,
char* host, std::size_t hostlen, char* serv,
std::size_t servlen, int sock_type, boost::system::error_code& ec)
;
u_long_type network_to_host_long(u_long_type value)
;
u_long_type host_to_network_long(u_long_type value)
;
u_short_type network_to_host_short(u_short_type value)
;
u_short_type host_to_network_short(u_short_type value)
;
}
}
}
}
namespace boost {
namespace asio {
namespace detail {
class socket_holder
: private noncopyable
{
public:
socket_holder()
;
explicit socket_holder(socket_type s)
;
~socket_holder()
;
socket_type get() const
;
void reset()
;
void reset(socket_type s)
;
socket_type release()
;
private:
socket_type socket_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Socket, typename Protocol>
class reactive_socket_accept_op_base : public reactor_op
{
public:
reactive_socket_accept_op_base(socket_type socket,
socket_ops::state_type state, Socket& peer, const Protocol& protocol,
typename Protocol::endpoint* peer_endpoint, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
socket_type socket_;
socket_ops::state_type state_;
Socket& peer_;
Protocol protocol_;
typename Protocol::endpoint* peer_endpoint_;
};
template <typename Socket, typename Protocol, typename Handler>
class reactive_socket_accept_op :
public reactive_socket_accept_op_base<Socket, Protocol>
{
public:
struct ptr { Handler* h; void* v; reactive_socket_accept_op* p; ~ptr() ; void reset() ; };
reactive_socket_accept_op(socket_type socket,
socket_ops::state_type state, Socket& peer, const Protocol& protocol,
typename Protocol::endpoint* peer_endpoint, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_CONNECT_OP_HPP
namespace boost {
namespace asio {
namespace detail {
class reactive_socket_connect_op_base : public reactor_op
{
public:
reactive_socket_connect_op_base(socket_type socket, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
socket_type socket_;
};
template <typename Handler>
class reactive_socket_connect_op : public reactive_socket_connect_op_base
{
public:
struct ptr { Handler* h; void* v; reactive_socket_connect_op* p; ~ptr() ; void reset() ; };
reactive_socket_connect_op(socket_type socket, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECVFROM_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename MutableBufferSequence, typename Endpoint>
class reactive_socket_recvfrom_op_base : public reactor_op
{
public:
reactive_socket_recvfrom_op_base(socket_type socket, int protocol_type,
const MutableBufferSequence& buffers, Endpoint& endpoint,
socket_base::message_flags flags, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
socket_type socket_;
int protocol_type_;
MutableBufferSequence buffers_;
Endpoint& sender_endpoint_;
socket_base::message_flags flags_;
};
template <typename MutableBufferSequence, typename Endpoint, typename Handler>
class reactive_socket_recvfrom_op :
public reactive_socket_recvfrom_op_base<MutableBufferSequence, Endpoint>
{
public:
struct ptr { Handler* h; void* v; reactive_socket_recvfrom_op* p; ~ptr() ; void reset() ; };
reactive_socket_recvfrom_op(socket_type socket, int protocol_type,
const MutableBufferSequence& buffers, Endpoint& endpoint,
socket_base::message_flags flags, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SENDTO_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename ConstBufferSequence, typename Endpoint>
class reactive_socket_sendto_op_base : public reactor_op
{
public:
reactive_socket_sendto_op_base(socket_type socket,
const ConstBufferSequence& buffers, const Endpoint& endpoint,
socket_base::message_flags flags, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
socket_type socket_;
ConstBufferSequence buffers_;
Endpoint destination_;
socket_base::message_flags flags_;
};
template <typename ConstBufferSequence, typename Endpoint, typename Handler>
class reactive_socket_sendto_op :
public reactive_socket_sendto_op_base<ConstBufferSequence, Endpoint>
{
public:
struct ptr { Handler* h; void* v; reactive_socket_sendto_op* p; ~ptr() ; void reset() ; };
reactive_socket_sendto_op(socket_type socket,
const ConstBufferSequence& buffers, const Endpoint& endpoint,
socket_base::message_flags flags, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_BASE_HPP
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECV_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename MutableBufferSequence>
class reactive_socket_recv_op_base : public reactor_op
{
public:
reactive_socket_recv_op_base(socket_type socket,
socket_ops::state_type state, const MutableBufferSequence& buffers,
socket_base::message_flags flags, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
socket_type socket_;
socket_ops::state_type state_;
MutableBufferSequence buffers_;
socket_base::message_flags flags_;
};
template <typename MutableBufferSequence, typename Handler>
class reactive_socket_recv_op :
public reactive_socket_recv_op_base<MutableBufferSequence>
{
public:
struct ptr { Handler* h; void* v; reactive_socket_recv_op* p; ~ptr() ; void reset() ; };
reactive_socket_recv_op(socket_type socket,
socket_ops::state_type state, const MutableBufferSequence& buffers,
socket_base::message_flags flags, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECVMSG_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename MutableBufferSequence>
class reactive_socket_recvmsg_op_base : public reactor_op
{
public:
reactive_socket_recvmsg_op_base(socket_type socket,
const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
socket_base::message_flags& out_flags, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
socket_type socket_;
MutableBufferSequence buffers_;
socket_base::message_flags in_flags_;
socket_base::message_flags& out_flags_;
};
template <typename MutableBufferSequence, typename Handler>
class reactive_socket_recvmsg_op :
public reactive_socket_recvmsg_op_base<MutableBufferSequence>
{
public:
struct ptr { Handler* h; void* v; reactive_socket_recvmsg_op* p; ~ptr() ; void reset() ; };
reactive_socket_recvmsg_op(socket_type socket,
const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
socket_base::message_flags& out_flags, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SEND_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename ConstBufferSequence>
class reactive_socket_send_op_base : public reactor_op
{
public:
reactive_socket_send_op_base(socket_type socket,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
socket_type socket_;
ConstBufferSequence buffers_;
socket_base::message_flags flags_;
};
template <typename ConstBufferSequence, typename Handler>
class reactive_socket_send_op :
public reactive_socket_send_op_base<ConstBufferSequence>
{
public:
struct ptr { Handler* h; void* v; reactive_socket_send_op* p; ~ptr() ; void reset() ; };
reactive_socket_send_op(socket_type socket,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
class reactive_socket_service_base
{
public:
typedef socket_type native_handle_type;
struct base_implementation_type
{
socket_type socket_;
socket_ops::state_type state_;
reactor::per_descriptor_data reactor_data_;
};
inline reactive_socket_service_base(
boost::asio::io_service& io_service);
inline void shutdown_service();
inline void construct(base_implementation_type& impl);
inline void base_move_construct(base_implementation_type& impl,
base_implementation_type& other_impl);
inline void base_move_assign(base_implementation_type& impl,
reactive_socket_service_base& other_service,
base_implementation_type& other_impl);
inline void destroy(base_implementation_type& impl);
bool is_open(const base_implementation_type& impl) const
;
inline boost::system::error_code close(
base_implementation_type& impl, boost::system::error_code& ec);
native_handle_type native_handle(base_implementation_type& impl)
;
inline boost::system::error_code cancel(
base_implementation_type& impl, boost::system::error_code& ec);
bool at_mark(const base_implementation_type& impl,
boost::system::error_code& ec) const
;
std::size_t available(const base_implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code listen(base_implementation_type& impl,
int backlog, boost::system::error_code& ec)
;
template <typename IO_Control_Command>
boost::system::error_code io_control(base_implementation_type& impl,
IO_Control_Command& command, boost::system::error_code& ec)
;
bool non_blocking(const base_implementation_type& impl) const
;
boost::system::error_code non_blocking(base_implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const base_implementation_type& impl) const
;
boost::system::error_code native_non_blocking(base_implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
boost::system::error_code shutdown(base_implementation_type& impl,
socket_base::shutdown_type what, boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
size_t send(base_implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
size_t send(base_implementation_type& impl, const null_buffers&,
socket_base::message_flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename Handler>
void async_send(base_implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, Handler& handler)
;
template <typename Handler>
void async_send(base_implementation_type& impl, const null_buffers&,
socket_base::message_flags, Handler& handler)
;
template <typename MutableBufferSequence>
size_t receive(base_implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
size_t receive(base_implementation_type& impl, const null_buffers&,
socket_base::message_flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename Handler>
void async_receive(base_implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags, Handler& handler)
;
template <typename Handler>
void async_receive(base_implementation_type& impl, const null_buffers&,
socket_base::message_flags flags, Handler& handler)
;
template <typename MutableBufferSequence>
size_t receive_with_flags(base_implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags in_flags,
socket_base::message_flags& out_flags, boost::system::error_code& ec)
;
size_t receive_with_flags(base_implementation_type& impl,
const null_buffers&, socket_base::message_flags,
socket_base::message_flags& out_flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename Handler>
void async_receive_with_flags(base_implementation_type& impl,
const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
socket_base::message_flags& out_flags, Handler& handler)
;
template <typename Handler>
void async_receive_with_flags(base_implementation_type& impl,
const null_buffers&, socket_base::message_flags in_flags,
socket_base::message_flags& out_flags, Handler& handler)
;
protected:
inline boost::system::error_code do_open(
base_implementation_type& impl, int af,
int type, int protocol, boost::system::error_code& ec);
inline boost::system::error_code do_assign(
base_implementation_type& impl, int type,
const native_handle_type& native_socket, boost::system::error_code& ec);
inline void start_op(base_implementation_type& impl, int op_type,
reactor_op* op, bool is_continuation, bool is_non_blocking, bool noop);
inline void start_accept_op(base_implementation_type& impl,
reactor_op* op, bool is_continuation, bool peer_is_open);
inline void start_connect_op(base_implementation_type& impl,
reactor_op* op, bool is_continuation,
const socket_addr_type* addr, size_t addrlen);
reactor& reactor_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_REACTIVE_SOCKET_SERVICE_BASE_IPP
namespace boost {
namespace asio {
namespace detail {
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Protocol>
class reactive_socket_service :
public reactive_socket_service_base
{
public:
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
typedef socket_type native_handle_type;
struct implementation_type :
reactive_socket_service_base::base_implementation_type
{
implementation_type()
;
protocol_type protocol_;
};
reactive_socket_service(boost::asio::io_service& io_service)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
reactive_socket_service_base& other_service,
implementation_type& other_impl)
;
template <typename Protocol1>
void converting_move_construct(implementation_type& impl,
typename reactive_socket_service<
Protocol1>::implementation_type& other_impl)
;
boost::system::error_code open(implementation_type& impl,
const protocol_type& protocol, boost::system::error_code& ec)
;
boost::system::error_code assign(implementation_type& impl,
const protocol_type& protocol, const native_handle_type& native_socket,
boost::system::error_code& ec)
;
native_handle_type native_handle(implementation_type& impl)
;
boost::system::error_code bind(implementation_type& impl,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
template <typename Option>
boost::system::error_code set_option(implementation_type& impl,
const Option& option, boost::system::error_code& ec)
;
template <typename Option>
boost::system::error_code get_option(const implementation_type& impl,
Option& option, boost::system::error_code& ec) const
;
endpoint_type local_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
endpoint_type remote_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
template <typename ConstBufferSequence>
size_t send_to(implementation_type& impl, const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags,
boost::system::error_code& ec)
;
size_t send_to(implementation_type& impl, const null_buffers&,
const endpoint_type&, socket_base::message_flags,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename Handler>
void async_send_to(implementation_type& impl,
const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags,
Handler& handler)
;
template <typename Handler>
void async_send_to(implementation_type& impl, const null_buffers&,
const endpoint_type&, socket_base::message_flags, Handler& handler)
;
template <typename MutableBufferSequence>
size_t receive_from(implementation_type& impl,
const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint, socket_base::message_flags flags,
boost::system::error_code& ec)
;
size_t receive_from(implementation_type& impl, const null_buffers&,
endpoint_type& sender_endpoint, socket_base::message_flags,
boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename Handler>
void async_receive_from(implementation_type& impl,
const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
socket_base::message_flags flags, Handler& handler)
;
template <typename Handler>
void async_receive_from(implementation_type& impl,
const null_buffers&, endpoint_type& sender_endpoint,
socket_base::message_flags flags, Handler& handler)
;
template <typename Socket>
boost::system::error_code accept(implementation_type& impl,
Socket& peer, endpoint_type* peer_endpoint, boost::system::error_code& ec)
;
template <typename Socket, typename Handler>
void async_accept(implementation_type& impl, Socket& peer,
endpoint_type* peer_endpoint, Handler& handler)
;
boost::system::error_code connect(implementation_type& impl,
const endpoint_type& peer_endpoint, boost::system::error_code& ec)
;
template <typename Handler>
void async_connect(implementation_type& impl,
const endpoint_type& peer_endpoint, Handler& handler)
;
};
}
}
}
namespace boost {
namespace asio {
template <typename Protocol>
class datagram_socket_service
: public boost::asio::detail::service_base<datagram_socket_service<Protocol> >
{
public:
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
private:
typedef detail::reactive_socket_service<Protocol> service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
typedef typename service_impl_type::native_handle_type native_type;
typedef typename service_impl_type::native_handle_type native_handle_type;
explicit datagram_socket_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
datagram_socket_service& other_service,
implementation_type& other_impl)
;
template <typename Protocol1>
void converting_move_construct(implementation_type& impl,
typename datagram_socket_service<
Protocol1>::implementation_type& other_impl,
typename enable_if<is_convertible<
Protocol1, Protocol>::value>::type* = 0)
;
void destroy(implementation_type& impl)
;
boost::system::error_code open(implementation_type& impl,
const protocol_type& protocol, boost::system::error_code& ec)
;
boost::system::error_code assign(implementation_type& impl,
const protocol_type& protocol, const native_handle_type& native_socket,
boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_type native(implementation_type& impl)
;
native_handle_type native_handle(implementation_type& impl)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
bool at_mark(const implementation_type& impl,
boost::system::error_code& ec) const
;
std::size_t available(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code bind(implementation_type& impl,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
boost::system::error_code connect(implementation_type& impl,
const endpoint_type& peer_endpoint, boost::system::error_code& ec)
;
template <typename ConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ConnectHandler, void (boost::system::error_code)>::type>::type
async_connect(implementation_type& impl,
const endpoint_type& peer_endpoint,
ConnectHandler&& handler)
;
template <typename SettableSocketOption>
boost::system::error_code set_option(implementation_type& impl,
const SettableSocketOption& option, boost::system::error_code& ec)
;
template <typename GettableSocketOption>
boost::system::error_code get_option(const implementation_type& impl,
GettableSocketOption& option, boost::system::error_code& ec) const
;
template <typename IoControlCommand>
boost::system::error_code io_control(implementation_type& impl,
IoControlCommand& command, boost::system::error_code& ec)
;
bool non_blocking(const implementation_type& impl) const
;
boost::system::error_code non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const implementation_type& impl) const
;
boost::system::error_code native_non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
endpoint_type local_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
endpoint_type remote_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code shutdown(implementation_type& impl,
socket_base::shutdown_type what, boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t send(implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(implementation_type& impl, const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename ConstBufferSequence>
std::size_t send_to(implementation_type& impl,
const ConstBufferSequence& buffers, const endpoint_type& destination,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send_to(implementation_type& impl,
const ConstBufferSequence& buffers, const endpoint_type& destination,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags,
ReadHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive_from(implementation_type& impl,
const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive_from(implementation_type& impl,
const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
socket_base::message_flags flags,
ReadHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename Protocol,
typename DatagramSocketService = datagram_socket_service<Protocol> >
class basic_datagram_socket
: public basic_socket<Protocol, DatagramSocketService>
{
public:
typedef typename DatagramSocketService::native_handle_type native_type;
typedef typename DatagramSocketService::native_handle_type native_handle_type;
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
explicit basic_datagram_socket(boost::asio::io_service& io_service)
;
basic_datagram_socket(boost::asio::io_service& io_service,
const protocol_type& protocol)
;
basic_datagram_socket(boost::asio::io_service& io_service,
const endpoint_type& endpoint)
;
basic_datagram_socket(boost::asio::io_service& io_service,
const protocol_type& protocol, const native_handle_type& native_socket)
;
basic_datagram_socket(basic_datagram_socket&& other)
;
basic_datagram_socket& operator=(basic_datagram_socket&& other)
;
template <typename Protocol1, typename DatagramSocketService1>
basic_datagram_socket(
basic_datagram_socket<Protocol1, DatagramSocketService1>&& other,
typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
;
template <typename Protocol1, typename DatagramSocketService1>
typename enable_if<is_convertible<Protocol1, Protocol>::value,
basic_datagram_socket>::type& operator=(
basic_datagram_socket<Protocol1, DatagramSocketService1>&& other)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename ConstBufferSequence>
std::size_t send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination)
;
template <typename ConstBufferSequence>
std::size_t send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags)
;
template <typename ConstBufferSequence>
std::size_t send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination,
WriteHandler&& handler)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags,
ReadHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint)
;
template <typename MutableBufferSequence>
std::size_t receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint, socket_base::message_flags flags)
;
template <typename MutableBufferSequence>
std::size_t receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint, socket_base::message_flags flags,
boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint,
ReadHandler&& handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint, socket_base::message_flags flags,
ReadHandler&& handler)
;
};
}
}
#define BOOST_ASIO_BASIC_DEADLINE_TIMER_HPP
#define BOOST_ASIO_DEADLINE_TIMER_SERVICE_HPP
#define BOOST_ASIO_DETAIL_DEADLINE_TIMER_SERVICE_HPP
#define BOOST_ASIO_DETAIL_TIMER_QUEUE_HPP
#define BOOST_ASIO_DETAIL_DATE_TIME_FWD_HPP
namespace boost {
namespace date_time {
template<class T, class TimeSystem>
class base_time;
}
namespace posix_time {
class ptime;
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Time_Traits>
class timer_queue
: public timer_queue_base
{
public:
typedef typename Time_Traits::time_type time_type;
typedef typename Time_Traits::duration_type duration_type;
class per_timer_data
{
public:
per_timer_data() ;
private:
friend class timer_queue;
op_queue<wait_op> op_queue_;
std::size_t heap_index_;
per_timer_data* next_;
per_timer_data* prev_;
};
timer_queue()
;
bool enqueue_timer(const time_type& time, per_timer_data& timer, wait_op* op)
;
virtual bool empty() const
;
virtual long wait_duration_msec(long max_duration) const
;
virtual long wait_duration_usec(long max_duration) const
;
virtual void get_ready_timers(op_queue<operation>& ops)
;
virtual void get_all_timers(op_queue<operation>& ops)
;
std::size_t cancel_timer(per_timer_data& timer, op_queue<operation>& ops,
std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)())
;
private:
void up_heap(std::size_t index)
;
void down_heap(std::size_t index)
;
void swap_heap(std::size_t index1, std::size_t index2)
;
void remove_timer(per_timer_data& timer)
;
template <typename Time_Type>
static bool is_positive_infinity(const Time_Type&)
;
template <typename T, typename TimeSystem>
static bool is_positive_infinity(
const boost::date_time::base_time<T, TimeSystem>& time)
;
template <typename Duration>
long to_msec(const Duration& d, long max_duration) const
;
template <typename Duration>
long to_usec(const Duration& d, long max_duration) const
;
per_timer_data* timers_;
struct heap_entry
{
time_type time_;
per_timer_data* timer_;
};
std::vector<heap_entry> heap_;
};
}
}
}
#define BOOST_ASIO_DETAIL_TIMER_SCHEDULER_HPP
#define BOOST_ASIO_DETAIL_TIMER_SCHEDULER_FWD_HPP
namespace boost {
namespace asio {
namespace detail {
typedef class epoll_reactor timer_scheduler;
}
}
}
#define BOOST_ASIO_DETAIL_WAIT_HANDLER_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Handler>
class wait_handler : public wait_op
{
public:
struct ptr { Handler* h; void* v; wait_handler* p; ~ptr() ; void reset() ; };
wait_handler(Handler& h)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Time_Traits>
class deadline_timer_service
{
public:
typedef typename Time_Traits::time_type time_type;
typedef typename Time_Traits::duration_type duration_type;
struct implementation_type
: private boost::asio::detail::noncopyable
{
time_type expiry;
bool might_have_pending_waits;
typename timer_queue<Time_Traits>::per_timer_data timer_data;
};
deadline_timer_service(boost::asio::io_service& io_service)
;
~deadline_timer_service()
;
void shutdown_service()
;
void construct(implementation_type& impl)
;
void destroy(implementation_type& impl)
;
std::size_t cancel(implementation_type& impl, boost::system::error_code& ec)
;
std::size_t cancel_one(implementation_type& impl,
boost::system::error_code& ec)
;
time_type expires_at(const implementation_type& impl) const
;
std::size_t expires_at(implementation_type& impl,
const time_type& expiry_time, boost::system::error_code& ec)
;
duration_type expires_from_now(const implementation_type& impl) const
;
std::size_t expires_from_now(implementation_type& impl,
const duration_type& expiry_time, boost::system::error_code& ec)
;
void wait(implementation_type& impl, boost::system::error_code& ec)
;
template <typename Handler>
void async_wait(implementation_type& impl, Handler& handler)
;
private:
template <typename Duration>
void do_wait(const Duration& timeout, boost::system::error_code& ec)
;
timer_queue<Time_Traits> timer_queue_;
timer_scheduler& scheduler_;
};
}
}
}
#define BOOST_ASIO_TIME_TRAITS_HPP
#define POSIX_TIME_TYPES_HPP___
#define DATE_TIME_TIME_CLOCK_HPP___
#define DATE_TIME_C_TIME_HPP___
#define _GLIBCXX_CTIME 1
#undef clock
#undef difftime
#undef mktime
#undef time
#undef asctime
#undef ctime
#undef gmtime
#undef localtime
#undef strftime
namespace std
{
using ::clock_t;
using ::time_t;
using ::tm;
using ::clock;
using ::difftime;
using ::mktime;
using ::time;
using ::asctime;
using ::ctime;
using ::gmtime;
using ::localtime;
using ::strftime;
}
#define DATE_TIME_COMPILER_CONFIG_HPP___
#define DATE_TIME_LOCALE_CONFIG_HPP___
#define BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK
#define BOOST_DATE_TIME_OPTIONAL_GREGORIAN_TYPES
#define BOOST_DATE_TIME_UNREACHABLE_EXPRESSION(x) std::abort()
#define BOOST_DATE_TIME_DECL
#define BOOST_LIB_NAME boost_date_time
#undef BOOST_LIB_NAME
#define BOOST_DATE_TIME_HAS_REENTRANT_STD_FUNCTIONS
#define _SYS_TIME_H 1
#define __need_time_t
#define __need_timeval
#undef __need_timeval
extern "C" {
#define TIMEVAL_TO_TIMESPEC(tv,ts) { (ts)->tv_sec = (tv)->tv_sec; (ts)->tv_nsec = (tv)->tv_usec * 1000; }
#define TIMESPEC_TO_TIMEVAL(tv,ts) { (tv)->tv_sec = (ts)->tv_sec; (tv)->tv_usec = (ts)->tv_nsec / 1000; }
struct timezone
{
int tz_minuteswest;
int tz_dsttime;
};
typedef struct timezone *__restrict __timezone_ptr_t;
extern int gettimeofday (struct timeval *__restrict __tv,
__timezone_ptr_t __tz) throw () __attribute__ ((__nonnull__ (1)));
extern int settimeofday (const struct timeval *__tv,
const struct timezone *__tz)
throw ();
extern int adjtime (const struct timeval *__delta,
struct timeval *__olddelta) throw ();
enum __itimer_which
{
ITIMER_REAL = 0,
#define ITIMER_REAL ITIMER_REAL
ITIMER_VIRTUAL = 1,
#define ITIMER_VIRTUAL ITIMER_VIRTUAL
ITIMER_PROF = 2
#define ITIMER_PROF ITIMER_PROF
};
struct itimerval
{
struct timeval it_interval;
struct timeval it_value;
};
typedef int __itimer_which_t;
extern int getitimer (__itimer_which_t __which,
struct itimerval *__value) throw ();
extern int setitimer (__itimer_which_t __which,
const struct itimerval *__restrict __new,
struct itimerval *__restrict __old) throw ();
extern int utimes (const char *__file, const struct timeval __tvp[2])
throw () __attribute__ ((__nonnull__ (1)));
extern int lutimes (const char *__file, const struct timeval __tvp[2])
throw () __attribute__ ((__nonnull__ (1)));
extern int futimes (int __fd, const struct timeval __tvp[2]) throw ();
extern int futimesat (int __fd, const char *__file,
const struct timeval __tvp[2]) throw ();
#define timerisset(tvp) ((tvp)->tv_sec || (tvp)->tv_usec)
#define timerclear(tvp) ((tvp)->tv_sec = (tvp)->tv_usec = 0)
#define timercmp(a,b,CMP) (((a)->tv_sec == (b)->tv_sec) ? ((a)->tv_usec CMP (b)->tv_usec) : ((a)->tv_sec CMP (b)->tv_sec))
#define timeradd(a,b,result) do { (result)->tv_sec = (a)->tv_sec + (b)->tv_sec; (result)->tv_usec = (a)->tv_usec + (b)->tv_usec; if ((result)->tv_usec >= 1000000) { ++(result)->tv_sec; (result)->tv_usec -= 1000000; } } while (0)
#define timersub(a,b,result) do { (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; (result)->tv_usec = (a)->tv_usec - (b)->tv_usec; if ((result)->tv_usec < 0) { --(result)->tv_sec; (result)->tv_usec += 1000000; } } while (0)
}
namespace boost {
namespace date_time {
struct c_time {
public:
static std::tm* localtime(const std::time_t* t, std::tm* result)
;
static std::tm* gmtime(const std::time_t* t, std::tm* result)
;
};
}}
#define BOOST_SHARED_PTR_HPP_INCLUDED
#define BOOST_SMART_PTR_SHARED_PTR_HPP_INCLUDED
#define BOOST_CONFIG_MEMORY
#define BOOST_TR1_NO_RECURSION
#define BOOST_CONFIG_NO_MEMORY_RECURSION
#undef BOOST_TR1_NO_RECURSION
#undef BOOST_CONFIG_NO_MEMORY_RECURSION
#undef BOOST_ASSERT
#undef _ASSERT_H
#undef assert
#undef __ASSERT_VOID_CAST
#undef assert_perror
#define _ASSERT_H 1
#define __ASSERT_VOID_CAST static_cast<void>
#define assert(expr) (__ASSERT_VOID_CAST (0))
#define assert_perror(errnum) (__ASSERT_VOID_CAST (0))
#define BOOST_ASSERT(expr) assert(expr)
#undef BOOST_ASSERT_MSG
#define BOOST_ASSERT_MSG(expr,msg) ((void)0)
#undef BOOST_VERIFY
#define BOOST_VERIFY(expr) ((void)(expr))
#define BOOST_CHECKED_DELETE_HPP_INCLUDED
namespace boost
{
template<class T> void checked_delete(T * x)
;
template<class T> void checked_array_delete(T * x)
;
template<class T> struct checked_deleter
{
typedef void result_type;
typedef T * argument_type;
void operator()(T * x) const
;
};
template<class T> struct checked_array_deleter
{
typedef void result_type;
typedef T * argument_type;
void operator()(T * x) const
;
};
}
#define BOOST_SMART_PTR_DETAIL_SHARED_COUNT_HPP_INCLUDED
#define BOOST_SMART_PTR_BAD_WEAK_PTR_HPP_INCLUDED
namespace boost
{
class bad_weak_ptr: public std::exception
{
public:
virtual char const * what() const throw()
;
};
}
#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_HPP_INCLUDED
#define BOOST_SMART_PTR_DETAIL_SP_HAS_SYNC_HPP_INCLUDED
#define BOOST_SP_HAS_SYNC
#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_GCC_X86_HPP_INCLUDED
#define BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED
namespace boost
{
namespace detail
{
typedef std::type_info sp_typeinfo;
}
}
#define BOOST_SP_TYPEID(T) typeid(T)
namespace boost
{
namespace detail
{
int atomic_exchange_and_add( int * pw, int dv )
;
void atomic_increment( int * pw )
;
int atomic_conditional_increment( int * pw )
;
class sp_counted_base
{
private:
sp_counted_base( sp_counted_base const & );
sp_counted_base & operator= ( sp_counted_base const & );
int use_count_;
int weak_count_;
public:
sp_counted_base()
;
virtual ~sp_counted_base()
;
virtual void dispose() = 0;
virtual void destroy()
;
virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
virtual void * get_untyped_deleter() = 0;
void add_ref_copy()
;
bool add_ref_lock()
;
void release()
;
void weak_add_ref()
;
void weak_release()
;
long use_count() const
;
};
}
}
#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_IMPL_HPP_INCLUDED
namespace boost
{
namespace detail
{
template<class X> class sp_counted_impl_p: public sp_counted_base
{
private:
X * px_;
sp_counted_impl_p( sp_counted_impl_p const & );
sp_counted_impl_p & operator= ( sp_counted_impl_p const & );
typedef sp_counted_impl_p<X> this_type;
public:
explicit sp_counted_impl_p( X * px )
;
virtual void dispose()
;
virtual void * get_deleter( detail::sp_typeinfo const & )
;
virtual void * get_untyped_deleter()
;
};
template<class P, class D> class sp_counted_impl_pd: public sp_counted_base
{
private:
P ptr;
D del;
sp_counted_impl_pd( sp_counted_impl_pd const & );
sp_counted_impl_pd & operator= ( sp_counted_impl_pd const & );
typedef sp_counted_impl_pd<P, D> this_type;
public:
sp_counted_impl_pd( P p, D & d )
;
sp_counted_impl_pd( P p )
;
virtual void dispose()
;
virtual void * get_deleter( detail::sp_typeinfo const & ti )
;
virtual void * get_untyped_deleter()
;
};
template<class P, class D, class A> class sp_counted_impl_pda: public sp_counted_base
{
private:
P p_;
D d_;
A a_;
sp_counted_impl_pda( sp_counted_impl_pda const & );
sp_counted_impl_pda & operator= ( sp_counted_impl_pda const & );
typedef sp_counted_impl_pda<P, D, A> this_type;
public:
sp_counted_impl_pda( P p, D & d, A a )
;
sp_counted_impl_pda( P p, A a )
;
virtual void dispose()
;
virtual void destroy()
;
virtual void * get_deleter( detail::sp_typeinfo const & ti )
;
virtual void * get_untyped_deleter()
;
};
}
}
#define BOOST_UTILITY_ADDRESSOF_HPP
namespace boost
{
namespace detail
{
template<class T> struct addr_impl_ref
{
T & v_;
addr_impl_ref( T & v ) ;
operator T& () const ;
private:
addr_impl_ref & operator=(const addr_impl_ref &);
};
template<class T> struct addressof_impl
{
static T * f( T & v, long )
;
static T * f( T * v, int )
;
};
}
template<class T> T * addressof( T & v )
;
}
namespace boost
{
namespace detail
{
struct sp_nothrow_tag {};
template< class D > struct sp_inplace_tag
{
};
template< class T > class sp_reference_wrapper
{
public:
explicit sp_reference_wrapper( T & t)
;
template< class Y > void operator()( Y * p ) const
;
private:
T * t_;
};
template< class D > struct sp_convert_reference
{
typedef D type;
};
template< class D > struct sp_convert_reference< D& >
{
typedef sp_reference_wrapper< D > type;
};
class weak_count;
class shared_count
{
private:
sp_counted_base * pi_;
friend class weak_count;
public:
shared_count()
;
template<class Y> explicit shared_count( Y * p )
;
template<class P, class D> shared_count( P p, D d )
;
template< class P, class D > shared_count( P p, sp_inplace_tag<D> )
;
template<class P, class D, class A> shared_count( P p, D d, A a )
;
template< class P, class D, class A > shared_count( P p, sp_inplace_tag< D >, A a )
;
template<class Y>
explicit shared_count( std::auto_ptr<Y> & r )
;
template<class Y, class D>
explicit shared_count( std::unique_ptr<Y, D> & r )
;
~shared_count()
;
shared_count(shared_count const & r)
;
shared_count(shared_count && r)
;
explicit shared_count(weak_count const & r);
shared_count( weak_count const & r, sp_nothrow_tag );
shared_count & operator= (shared_count const & r)
;
void swap(shared_count & r)
;
long use_count() const
;
bool unique() const
;
bool empty() const
;
friend bool operator==(shared_count const & a, shared_count const & b)
;
friend bool operator<(shared_count const & a, shared_count const & b)
;
void * get_deleter( sp_typeinfo const & ti ) const
;
void * get_untyped_deleter() const
;
};
class weak_count
{
private:
sp_counted_base * pi_;
friend class shared_count;
public:
weak_count()
;
weak_count(shared_count const & r)
;
weak_count(weak_count const & r)
;
weak_count(weak_count && r)
;
~weak_count()
;
weak_count & operator= (shared_count const & r)
;
weak_count & operator= (weak_count const & r)
;
void swap(weak_count & r)
;
long use_count() const
;
bool empty() const
;
friend bool operator==(weak_count const & a, weak_count const & b)
;
friend bool operator<(weak_count const & a, weak_count const & b)
;
};
}
}
#define BOOST_SMART_PTR_DETAIL_SP_CONVERTIBLE_HPP_INCLUDED
namespace boost
{
namespace detail
{
template< class Y, class T > struct sp_convertible
{
typedef char (&yes) [1];
typedef char (&no) [2];
static yes f( T* );
static no f( ... );
enum _vt { value = sizeof( (f)( static_cast<Y*>(0) ) ) == sizeof(yes) };
};
template< class Y, class T > struct sp_convertible< Y, T[] >
{
enum _vt { value = false };
};
template< class Y, class T > struct sp_convertible< Y[], T[] >
{
enum _vt { value = sp_convertible< Y[1], T[1] >::value };
};
template< class Y, std::size_t N, class T > struct sp_convertible< Y[N], T[] >
{
enum _vt { value = sp_convertible< Y[1], T[1] >::value };
};
struct sp_empty
{
};
template< bool > struct sp_enable_if_convertible_impl;
template<> struct sp_enable_if_convertible_impl<true>
{
typedef sp_empty type;
};
template<> struct sp_enable_if_convertible_impl<false>
{
};
template< class Y, class T > struct sp_enable_if_convertible: public sp_enable_if_convertible_impl< sp_convertible< Y, T >::value >
{
};
}
}
#define BOOST_SMART_PTR_DETAIL_SP_NULLPTR_T_HPP_INCLUDED
namespace boost
{
namespace detail
{
typedef std::nullptr_t sp_nullptr_t;
}
}
#define BOOST_SMART_PTR_DETAIL_SPINLOCK_POOL_HPP_INCLUDED
#define BOOST_SMART_PTR_DETAIL_SPINLOCK_HPP_INCLUDED
#define BOOST_SMART_PTR_DETAIL_SPINLOCK_SYNC_HPP_INCLUDED
#define BOOST_SMART_PTR_DETAIL_YIELD_K_HPP_INCLUDED
#define BOOST_SMT_PAUSE __asm__ __volatile__( "rep; nop" : : : "memory" );
namespace boost
{
namespace detail
{
void yield( unsigned k )
;
}
}
namespace boost
{
namespace detail
{
class spinlock
{
public:
int v_;
public:
bool try_lock()
;
void lock()
;
void unlock()
;
public:
class scoped_lock
{
private:
spinlock & sp_;
scoped_lock( scoped_lock const & );
scoped_lock & operator=( scoped_lock const & );
public:
explicit scoped_lock( spinlock & sp )
;
~scoped_lock()
;
};
};
}
}
#define BOOST_DETAIL_SPINLOCK_INIT {0}
namespace boost
{
namespace detail
{
template< int I > class spinlock_pool
{
private:
static spinlock pool_[ 41 ];
public:
static spinlock & spinlock_for( void const * pv )
;
class scoped_lock
{
private:
spinlock & sp_;
scoped_lock( scoped_lock const & );
scoped_lock & operator=( scoped_lock const & );
public:
explicit scoped_lock( void const * pv )
;
~scoped_lock()
;
};
};
template< int I > spinlock spinlock_pool< I >::pool_[ 41 ] =
{
{0}, {0}, {0}, {0}, {0},
{0}, {0}, {0}, {0}, {0},
{0}, {0}, {0}, {0}, {0},
{0}, {0}, {0}, {0}, {0},
{0}, {0}, {0}, {0}, {0},
{0}, {0}, {0}, {0}, {0},
{0}, {0}, {0}, {0}, {0},
{0}, {0}, {0}, {0}, {0},
{0}
};
}
}
#define BOOST_MEMORY_ORDER_HPP_INCLUDED
namespace boost
{
enum memory_order
{
memory_order_relaxed = 0,
memory_order_acquire = 1,
memory_order_release = 2,
memory_order_acq_rel = 3,
memory_order_seq_cst = 7,
memory_order_consume = 8
};
}
#define _GLIBCXX_ALGORITHM 1
#define _STL_ALGO_H 1
#define _GLIBCXX_ALGORITHMFWD_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _IIter, typename _Predicate>
bool
all_of(_IIter, _IIter, _Predicate);
template<typename _IIter, typename _Predicate>
bool
any_of(_IIter, _IIter, _Predicate);
template<typename _FIter, typename _Tp>
bool
binary_search(_FIter, _FIter, const _Tp&);
template<typename _FIter, typename _Tp, typename _Compare>
bool
binary_search(_FIter, _FIter, const _Tp&, _Compare);
template<typename _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);
template<typename _FIter>
void
rotate(_FIter, _FIter, _FIter);
template<typename _FIter, typename _OIter>
_OIter
rotate_copy(_FIter, _FIter, _FIter, _OIter);
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);
template<typename _Tp>
void
swap(_Tp&, _Tp&)
noexcept(__and_<is_nothrow_move_constructible<_Tp>,
is_nothrow_move_assignable<_Tp>>::value)
;
template<typename _Tp, size_t _Nm>
void
swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
noexcept(noexcept(swap(*__a, *__b)))
;
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);
}
#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)
;
template<typename _RandomAccessIterator, typename _Distance>
bool
__is_heap(_RandomAccessIterator __first, _Distance __n)
;
template<typename _RandomAccessIterator, typename _Compare,
typename _Distance>
bool
__is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
;
template<typename _RandomAccessIterator>
bool
__is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
bool
__is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
typename _Compare>
void
__push_heap(_RandomAccessIterator __first,
_Distance __holeIndex, _Distance __topIndex, _Tp __value,
_Compare __comp)
;
template<typename _RandomAccessIterator>
void
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Distance,
typename _Tp, typename _Compare>
void
__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
_Distance __len, _Tp __value, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_RandomAccessIterator __result, _Compare __comp)
;
template<typename _RandomAccessIterator>
void
pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
pop_heap(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator>
void
make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator>
void
sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator>
_RandomAccessIterator
is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
_RandomAccessIterator
is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator>
bool
is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
bool
is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
}
#define _GLIBCXX_RANDOM 1
#define _MATH_H 1
extern "C" {
#define HUGE_VAL (__builtin_huge_val())
#define HUGE_VALF (__builtin_huge_valf())
#define HUGE_VALL (__builtin_huge_vall())
#define INFINITY (__builtin_inff())
#define NAN (__builtin_nanf (""))
#define _MATH_H_MATHDEF 1
typedef float float_t;
typedef double double_t;
#define FP_ILOGB0 (-2147483647 - 1)
#define FP_ILOGBNAN (-2147483647 - 1)
#define __MATHCALL(function,suffix,args) __MATHDECL (_Mdouble_,function,suffix, args)
#define __MATHDECL(type,function,suffix,args) __MATHDECL_1(type, function,suffix, args); __MATHDECL_1(type, __CONCAT(__,function),suffix, args)
#define __MATHCALLX(function,suffix,args,attrib) __MATHDECLX (_Mdouble_,function,suffix, args, attrib)
#define __MATHDECLX(type,function,suffix,args,attrib) __MATHDECL_1(type, function,suffix, args) __attribute__ (attrib); __MATHDECL_1(type, __CONCAT(__,function),suffix, args) __attribute__ (attrib)
#define __MATHDECL_1(type,function,suffix,args) extern type __MATH_PRECNAME(function,suffix) args __THROW
#define _Mdouble_ double
#define __MATH_PRECNAME(name,r) __CONCAT(name,r)
#define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_STD
#define _Mdouble_END_NAMESPACE __END_NAMESPACE_STD
extern double acos (double __x) throw (); extern double __acos (double __x) throw ();
extern double asin (double __x) throw (); extern double __asin (double __x) throw ();
extern double atan (double __x) throw (); extern double __atan (double __x) throw ();
extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();
extern double cos (double __x) throw (); extern double __cos (double __x) throw ();
extern double sin (double __x) throw (); extern double __sin (double __x) throw ();
extern double tan (double __x) throw (); extern double __tan (double __x) throw ();
extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();
extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();
extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();
extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ();
extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();
extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();
extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();
extern double exp (double __x) throw (); extern double __exp (double __x) throw ();
extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();
extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();
extern double log (double __x) throw (); extern double __log (double __x) throw ();
extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();
extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw () __attribute__ ((__nonnull__ (2)));
extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();
extern double pow10 (double __x) throw (); extern double __pow10 (double __x) throw ();
extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();
extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();
extern double logb (double __x) throw (); extern double __logb (double __x) throw ();
extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();
extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();
extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();
extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();
extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();
extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();
extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));
extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));
extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));
extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();
extern int __isinf (double __value) throw () __attribute__ ((__const__));
extern int __finite (double __value) throw () __attribute__ ((__const__));
extern int isinf (double __value) throw () __attribute__ ((__const__));
extern int finite (double __value) throw () __attribute__ ((__const__));
extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();
extern double significand (double __x) throw (); extern double __significand (double __x) throw ();
extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));
extern double nan (const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (const char *__tagb) throw () __attribute__ ((__const__));
extern int __isnan (double __value) throw () __attribute__ ((__const__));
extern int isnan (double __value) throw () __attribute__ ((__const__));
extern double j0 (double) throw (); extern double __j0 (double) throw ();
extern double j1 (double) throw (); extern double __j1 (double) throw ();
extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
extern double y0 (double) throw (); extern double __y0 (double) throw ();
extern double y1 (double) throw (); extern double __y1 (double) throw ();
extern double yn (int, double) throw (); extern double __yn (int, double) throw ();
extern double erf (double) throw (); extern double __erf (double) throw ();
extern double erfc (double) throw (); extern double __erfc (double) throw ();
extern double lgamma (double) throw (); extern double __lgamma (double) throw ();
extern double tgamma (double) throw (); extern double __tgamma (double) throw ();
extern double gamma (double) throw (); extern double __gamma (double) throw ();
extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();
extern double rint (double __x) throw (); extern double __rint (double __x) throw ();
extern double nextafter (double __x, double __y) throw () __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) throw () __attribute__ ((__const__));
extern double nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) throw () __attribute__ ((__const__));
extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();
extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();
extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();
extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();
extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();
extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));
extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));
extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();
extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
__extension__
extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();
extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
__extension__
extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();
extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();
extern double fmax (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmax (double __x, double __y) throw () __attribute__ ((__const__));
extern double fmin (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmin (double __x, double __y) throw () __attribute__ ((__const__));
extern int __fpclassify (double __value) throw ()
__attribute__ ((__const__));
extern int __signbit (double __value) throw ()
__attribute__ ((__const__));
extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();
extern int __issignaling (double __value) throw ()
__attribute__ ((__const__));
extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
#undef _Mdouble_
#undef _Mdouble_BEGIN_NAMESPACE
#undef _Mdouble_END_NAMESPACE
#undef __MATH_PRECNAME
#define _Mfloat_ float
#define _Mdouble_ _Mfloat_
#define __MATH_PRECNAME(name,r) name ##f ##r
#define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_C99
#define _Mdouble_END_NAMESPACE __END_NAMESPACE_C99
extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();
extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();
extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();
extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();
extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();
extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();
extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();
extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();
extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();
extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();
extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw ();
extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();
extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();
extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();
extern float expf (float __x) throw (); extern float __expf (float __x) throw ();
extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();
extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();
extern float logf (float __x) throw (); extern float __logf (float __x) throw ();
extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();
extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw () __attribute__ ((__nonnull__ (2)));
extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();
extern float pow10f (float __x) throw (); extern float __pow10f (float __x) throw ();
extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();
extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();
extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();
extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();
extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();
extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();
extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();
extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();
extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();
extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));
extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));
extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));
extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();
extern int __isinff (float __value) throw () __attribute__ ((__const__));
extern int __finitef (float __value) throw () __attribute__ ((__const__));
extern int isinff (float __value) throw () __attribute__ ((__const__));
extern int finitef (float __value) throw () __attribute__ ((__const__));
extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();
extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();
extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));
extern float nanf (const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (const char *__tagb) throw () __attribute__ ((__const__));
extern int __isnanf (float __value) throw () __attribute__ ((__const__));
extern int isnanf (float __value) throw () __attribute__ ((__const__));
extern float j0f (float) throw (); extern float __j0f (float) throw ();
extern float j1f (float) throw (); extern float __j1f (float) throw ();
extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
extern float y0f (float) throw (); extern float __y0f (float) throw ();
extern float y1f (float) throw (); extern float __y1f (float) throw ();
extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();
extern float erff (float) throw (); extern float __erff (float) throw ();
extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();
extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();
extern float gammaf (float) throw (); extern float __gammaf (float) throw ();
extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();
extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();
extern float nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) throw () __attribute__ ((__const__));
extern float nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__));
extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();
extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();
extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();
extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();
extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();
extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));
extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));
extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();
extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
__extension__
extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();
extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
__extension__
extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();
extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();
extern float fmaxf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) throw () __attribute__ ((__const__));
extern float fminf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminf (float __x, float __y) throw () __attribute__ ((__const__));
extern int __fpclassifyf (float __value) throw ()
__attribute__ ((__const__));
extern int __signbitf (float __value) throw ()
__attribute__ ((__const__));
extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();
extern int __issignalingf (float __value) throw ()
__attribute__ ((__const__));
extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
#undef _Mdouble_
#undef _Mdouble_BEGIN_NAMESPACE
#undef _Mdouble_END_NAMESPACE
#undef __MATH_PRECNAME
#define _Mlong_double_ long double
#define _Mdouble_ _Mlong_double_
#define __MATH_PRECNAME(name,r) name ##l ##r
#define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_C99
#define _Mdouble_END_NAMESPACE __END_NAMESPACE_C99
#define __MATH_DECLARE_LDOUBLE 1
extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();
extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();
extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();
extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();
extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();
extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();
extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();
extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();
extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();
extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();
extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw ();
extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();
extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();
extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();
extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();
extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();
extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();
extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();
extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();
extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw () __attribute__ ((__nonnull__ (2)));
extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();
extern long double pow10l (long double __x) throw (); extern long double __pow10l (long double __x) throw ();
extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();
extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();
extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();
extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();
extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();
extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();
extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();
extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();
extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();
extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));
extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));
extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));
extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();
extern int __isinfl (long double __value) throw () __attribute__ ((__const__));
extern int __finitel (long double __value) throw () __attribute__ ((__const__));
extern int isinfl (long double __value) throw () __attribute__ ((__const__));
extern int finitel (long double __value) throw () __attribute__ ((__const__));
extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();
extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();
extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern long double nanl (const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (const char *__tagb) throw () __attribute__ ((__const__));
extern int __isnanl (long double __value) throw () __attribute__ ((__const__));
extern int isnanl (long double __value) throw () __attribute__ ((__const__));
extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();
extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();
extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();
extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();
extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();
extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();
extern long double nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern long double nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();
extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();
extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();
extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();
extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();
extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));
extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));
extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();
extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
__extension__
extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();
extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
__extension__
extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();
extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();
extern long double fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern long double fminl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern int __fpclassifyl (long double __value) throw ()
__attribute__ ((__const__));
extern int __signbitl (long double __value) throw ()
__attribute__ ((__const__));
extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();
extern int __issignalingl (long double __value) throw ()
__attribute__ ((__const__));
extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
#undef _Mdouble_
#undef _Mdouble_BEGIN_NAMESPACE
#undef _Mdouble_END_NAMESPACE
#undef __MATH_PRECNAME
#undef __MATHDECL_1
#undef __MATHDECL
#undef __MATHCALL
extern int signgam;
enum
{
FP_NAN =
#define FP_NAN 0
0,
FP_INFINITE =
#define FP_INFINITE 1
1,
FP_ZERO =
#define FP_ZERO 2
2,
FP_SUBNORMAL =
#define FP_SUBNORMAL 3
3,
FP_NORMAL =
#define FP_NORMAL 4
4
};
#define fpclassify(x) (sizeof (x) == sizeof (float) ? __fpclassifyf (x) : sizeof (x) == sizeof (double) ? __fpclassify (x) : __fpclassifyl (x))
#define signbit(x) (sizeof (x) == sizeof (float) ? __signbitf (x) : sizeof (x) == sizeof (double) ? __signbit (x) : __signbitl (x))
#define isfinite(x) (sizeof (x) == sizeof (float) ? __finitef (x) : sizeof (x) == sizeof (double) ? __finite (x) : __finitel (x))
#define isnormal(x) (fpclassify (x) == FP_NORMAL)
#define isnan(x) (sizeof (x) == sizeof (float) ? __isnanf (x) : sizeof (x) == sizeof (double) ? __isnan (x) : __isnanl (x))
#define isinf(x) (sizeof (x) == sizeof (float) ? __isinff (x) : sizeof (x) == sizeof (double) ? __isinf (x) : __isinfl (x))
#define MATH_ERRNO 1
#define MATH_ERREXCEPT 2
#define math_errhandling (MATH_ERRNO | MATH_ERREXCEPT)
#define issignaling(x) (sizeof (x) == sizeof (float) ? __issignalingf (x) : sizeof (x) == sizeof (double) ? __issignaling (x) : __issignalingl (x))
typedef enum
{
_IEEE_ = -1,
_SVID_,
_XOPEN_,
_POSIX_,
_ISOC_
} _LIB_VERSION_TYPE;
extern _LIB_VERSION_TYPE _LIB_VERSION;
struct __exception
{
int type;
char *name;
double arg1;
double arg2;
double retval;
};
extern int matherr (struct __exception *__exc) throw ();
#define X_TLOSS 1.41484755040568800000e+16
#define DOMAIN 1
#define SING 2
#define OVERFLOW 3
#define UNDERFLOW 4
#define TLOSS 5
#define PLOSS 6
#define HUGE 3.40282347e+38F
#define M_E 2.7182818284590452354
#define M_LOG2E 1.4426950408889634074
#define M_LOG10E 0.43429448190325182765
#define M_LN2 0.69314718055994530942
#define M_LN10 2.30258509299404568402
#define M_PI 3.14159265358979323846
#define M_PI_2 1.57079632679489661923
#define M_PI_4 0.78539816339744830962
#define M_1_PI 0.31830988618379067154
#define M_2_PI 0.63661977236758134308
#define M_2_SQRTPI 1.12837916709551257390
#define M_SQRT2 1.41421356237309504880
#define M_SQRT1_2 0.70710678118654752440
#define M_El 2.718281828459045235360287471352662498L
#define M_LOG2El 1.442695040888963407359924681001892137L
#define M_LOG10El 0.434294481903251827651128918916605082L
#define M_LN2l 0.693147180559945309417232121458176568L
#define M_LN10l 2.302585092994045684017991454684364208L
#define M_PIl 3.141592653589793238462643383279502884L
#define M_PI_2l 1.570796326794896619231321691639751442L
#define M_PI_4l 0.785398163397448309615660845819875721L
#define M_1_PIl 0.318309886183790671537767526745028724L
#define M_2_PIl 0.636619772367581343075535053490057448L
#define M_2_SQRTPIl 1.128379167095512573896158903121545172L
#define M_SQRT2l 1.414213562373095048801688724209698079L
#define M_SQRT1_2l 0.707106781186547524400844362104849039L
#define __NO_MATH_INLINES 1
#define isgreater(x,y) __builtin_isgreater(x, y)
#define isgreaterequal(x,y) __builtin_isgreaterequal(x, y)
#define isless(x,y) __builtin_isless(x, y)
#define islessequal(x,y) __builtin_islessequal(x, y)
#define islessgreater(x,y) __builtin_islessgreater(x, y)
#define isunordered(u,v) __builtin_isunordered(u, v)
}
#define _GLIBCXX_CMATH 1
#undef abs
#undef div
#undef acos
#undef asin
#undef atan
#undef atan2
#undef ceil
#undef cos
#undef cosh
#undef exp
#undef fabs
#undef floor
#undef fmod
#undef frexp
#undef ldexp
#undef log
#undef log10
#undef modf
#undef pow
#undef sin
#undef sinh
#undef sqrt
#undef tan
#undef tanh
namespace std __attribute__ ((__visibility__ ("default")))
{
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); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
abs(_Tp __x)
{ return __builtin_fabs(__x); }
using ::acos;
inline constexpr float
acos(float __x)
{ return __builtin_acosf(__x); }
inline constexpr long double
acos(long double __x)
{ return __builtin_acosl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
acos(_Tp __x)
{ return __builtin_acos(__x); }
using ::asin;
inline constexpr float
asin(float __x)
{ return __builtin_asinf(__x); }
inline constexpr long double
asin(long double __x)
{ return __builtin_asinl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
asin(_Tp __x)
{ return __builtin_asin(__x); }
using ::atan;
inline constexpr float
atan(float __x)
{ return __builtin_atanf(__x); }
inline constexpr long double
atan(long double __x)
{ return __builtin_atanl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
atan(_Tp __x)
{ return __builtin_atan(__x); }
using ::atan2;
inline constexpr float
atan2(float __y, float __x)
{ return __builtin_atan2f(__y, __x); }
inline constexpr long double
atan2(long double __y, long double __x)
{ return __builtin_atan2l(__y, __x); }
template<typename _Tp, typename _Up>
inline constexpr
typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
atan2(_Tp __y, _Up __x)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return atan2(__type(__y), __type(__x));
}
using ::ceil;
inline constexpr float
ceil(float __x)
{ return __builtin_ceilf(__x); }
inline constexpr long double
ceil(long double __x)
{ return __builtin_ceill(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
ceil(_Tp __x)
{ return __builtin_ceil(__x); }
using ::cos;
inline constexpr float
cos(float __x)
{ return __builtin_cosf(__x); }
inline constexpr long double
cos(long double __x)
{ return __builtin_cosl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
cos(_Tp __x)
{ return __builtin_cos(__x); }
using ::cosh;
inline constexpr float
cosh(float __x)
{ return __builtin_coshf(__x); }
inline constexpr long double
cosh(long double __x)
{ return __builtin_coshl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
cosh(_Tp __x)
{ return __builtin_cosh(__x); }
using ::exp;
inline constexpr float
exp(float __x)
{ return __builtin_expf(__x); }
inline constexpr long double
exp(long double __x)
{ return __builtin_expl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
exp(_Tp __x)
{ return __builtin_exp(__x); }
using ::fabs;
inline constexpr float
fabs(float __x)
{ return __builtin_fabsf(__x); }
inline constexpr long double
fabs(long double __x)
{ return __builtin_fabsl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
fabs(_Tp __x)
{ return __builtin_fabs(__x); }
using ::floor;
inline constexpr float
floor(float __x)
{ return __builtin_floorf(__x); }
inline constexpr long double
floor(long double __x)
{ return __builtin_floorl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
floor(_Tp __x)
{ return __builtin_floor(__x); }
using ::fmod;
inline constexpr float
fmod(float __x, float __y)
{ return __builtin_fmodf(__x, __y); }
inline constexpr long double
fmod(long double __x, long double __y)
{ return __builtin_fmodl(__x, __y); }
template<typename _Tp, typename _Up>
inline constexpr
typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
fmod(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return fmod(__type(__x), __type(__y));
}
using ::frexp;
float
frexp(float __x, int* __exp)
;
long double
frexp(long double __x, int* __exp)
;
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
frexp(_Tp __x, int* __exp)
{ return __builtin_frexp(__x, __exp); }
using ::ldexp;
inline constexpr float
ldexp(float __x, int __exp)
{ return __builtin_ldexpf(__x, __exp); }
inline constexpr long double
ldexp(long double __x, int __exp)
{ return __builtin_ldexpl(__x, __exp); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
ldexp(_Tp __x, int __exp)
{ return __builtin_ldexp(__x, __exp); }
using ::log;
inline constexpr float
log(float __x)
{ return __builtin_logf(__x); }
inline constexpr long double
log(long double __x)
{ return __builtin_logl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log(_Tp __x)
{ return __builtin_log(__x); }
using ::log10;
inline constexpr float
log10(float __x)
{ return __builtin_log10f(__x); }
inline constexpr long double
log10(long double __x)
{ return __builtin_log10l(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log10(_Tp __x)
{ return __builtin_log10(__x); }
using ::modf;
float
modf(float __x, float* __iptr)
;
long double
modf(long double __x, long double* __iptr)
;
using ::pow;
inline constexpr float
pow(float __x, float __y)
{ return __builtin_powf(__x, __y); }
inline constexpr long double
pow(long double __x, long double __y)
{ return __builtin_powl(__x, __y); }
template<typename _Tp, typename _Up>
inline constexpr
typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
pow(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return pow(__type(__x), __type(__y));
}
using ::sin;
inline constexpr float
sin(float __x)
{ return __builtin_sinf(__x); }
inline constexpr long double
sin(long double __x)
{ return __builtin_sinl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
sin(_Tp __x)
{ return __builtin_sin(__x); }
using ::sinh;
inline constexpr float
sinh(float __x)
{ return __builtin_sinhf(__x); }
inline constexpr long double
sinh(long double __x)
{ return __builtin_sinhl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
sinh(_Tp __x)
{ return __builtin_sinh(__x); }
using ::sqrt;
inline constexpr float
sqrt(float __x)
{ return __builtin_sqrtf(__x); }
inline constexpr long double
sqrt(long double __x)
{ return __builtin_sqrtl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
sqrt(_Tp __x)
{ return __builtin_sqrt(__x); }
using ::tan;
inline constexpr float
tan(float __x)
{ return __builtin_tanf(__x); }
inline constexpr long double
tan(long double __x)
{ return __builtin_tanl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
tan(_Tp __x)
{ return __builtin_tan(__x); }
using ::tanh;
inline constexpr float
tanh(float __x)
{ return __builtin_tanhf(__x); }
inline constexpr long double
tanh(long double __x)
{ return __builtin_tanhl(__x); }
template<typename _Tp>
inline constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
tanh(_Tp __x)
{ return __builtin_tanh(__x); }
}
#undef fpclassify
#undef isfinite
#undef isinf
#undef isnan
#undef isnormal
#undef signbit
#undef isgreater
#undef isgreaterequal
#undef isless
#undef islessequal
#undef islessgreater
#undef isunordered
namespace std __attribute__ ((__visibility__ ("default")))
{
constexpr int
fpclassify(float __x)
{ return __builtin_fpclassify(0, 1, 4,
3, 2, __x); }
constexpr int
fpclassify(double __x)
{ return __builtin_fpclassify(0, 1, 4,
3, 2, __x); }
constexpr int
fpclassify(long double __x)
{ return __builtin_fpclassify(0, 1, 4,
3, 2, __x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
int>::__type
fpclassify(_Tp __x)
{ return __x != 0 ? 4 : 2; }
constexpr bool
isfinite(float __x)
{ return __builtin_isfinite(__x); }
constexpr bool
isfinite(double __x)
{ return __builtin_isfinite(__x); }
constexpr bool
isfinite(long double __x)
{ return __builtin_isfinite(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
isfinite(_Tp __x)
{ return true; }
constexpr bool
isinf(float __x)
{ return __builtin_isinf(__x); }
constexpr bool
isinf(double __x)
{ return __builtin_isinf(__x); }
constexpr bool
isinf(long double __x)
{ return __builtin_isinf(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
isinf(_Tp __x)
{ return false; }
constexpr bool
isnan(float __x)
{ return __builtin_isnan(__x); }
constexpr bool
isnan(double __x)
{ return __builtin_isnan(__x); }
constexpr bool
isnan(long double __x)
{ return __builtin_isnan(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
isnan(_Tp __x)
{ return false; }
constexpr bool
isnormal(float __x)
{ return __builtin_isnormal(__x); }
constexpr bool
isnormal(double __x)
{ return __builtin_isnormal(__x); }
constexpr bool
isnormal(long double __x)
{ return __builtin_isnormal(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
isnormal(_Tp __x)
{ return __x != 0 ? true : false; }
constexpr bool
signbit(float __x)
{ return __builtin_signbitf(__x); }
constexpr bool
signbit(double __x)
{ return __builtin_signbit(__x); }
constexpr bool
signbit(long double __x)
{ return __builtin_signbitl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
bool>::__type
signbit(_Tp __x)
{ return __x < 0 ? true : false; }
constexpr bool
isgreater(float __x, float __y)
{ return __builtin_isgreater(__x, __y); }
constexpr bool
isgreater(double __x, double __y)
{ return __builtin_isgreater(__x, __y); }
constexpr bool
isgreater(long double __x, long double __y)
{ return __builtin_isgreater(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
isgreater(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_isgreater(__type(__x), __type(__y));
}
constexpr bool
isgreaterequal(float __x, float __y)
{ return __builtin_isgreaterequal(__x, __y); }
constexpr bool
isgreaterequal(double __x, double __y)
{ return __builtin_isgreaterequal(__x, __y); }
constexpr bool
isgreaterequal(long double __x, long double __y)
{ return __builtin_isgreaterequal(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
isgreaterequal(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_isgreaterequal(__type(__x), __type(__y));
}
constexpr bool
isless(float __x, float __y)
{ return __builtin_isless(__x, __y); }
constexpr bool
isless(double __x, double __y)
{ return __builtin_isless(__x, __y); }
constexpr bool
isless(long double __x, long double __y)
{ return __builtin_isless(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
isless(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_isless(__type(__x), __type(__y));
}
constexpr bool
islessequal(float __x, float __y)
{ return __builtin_islessequal(__x, __y); }
constexpr bool
islessequal(double __x, double __y)
{ return __builtin_islessequal(__x, __y); }
constexpr bool
islessequal(long double __x, long double __y)
{ return __builtin_islessequal(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
islessequal(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_islessequal(__type(__x), __type(__y));
}
constexpr bool
islessgreater(float __x, float __y)
{ return __builtin_islessgreater(__x, __y); }
constexpr bool
islessgreater(double __x, double __y)
{ return __builtin_islessgreater(__x, __y); }
constexpr bool
islessgreater(long double __x, long double __y)
{ return __builtin_islessgreater(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
islessgreater(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_islessgreater(__type(__x), __type(__y));
}
constexpr bool
isunordered(float __x, float __y)
{ return __builtin_isunordered(__x, __y); }
constexpr bool
isunordered(double __x, double __y)
{ return __builtin_isunordered(__x, __y); }
constexpr bool
isunordered(long double __x, long double __y)
{ return __builtin_isunordered(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
&& __is_arithmetic<_Up>::__value), bool>::__type
isunordered(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return __builtin_isunordered(__type(__x), __type(__y));
}
}
#undef acosh
#undef acoshf
#undef acoshl
#undef asinh
#undef asinhf
#undef asinhl
#undef atanh
#undef atanhf
#undef atanhl
#undef cbrt
#undef cbrtf
#undef cbrtl
#undef copysign
#undef copysignf
#undef copysignl
#undef erf
#undef erff
#undef erfl
#undef erfc
#undef erfcf
#undef erfcl
#undef exp2
#undef exp2f
#undef exp2l
#undef expm1
#undef expm1f
#undef expm1l
#undef fdim
#undef fdimf
#undef fdiml
#undef fma
#undef fmaf
#undef fmal
#undef fmax
#undef fmaxf
#undef fmaxl
#undef fmin
#undef fminf
#undef fminl
#undef hypot
#undef hypotf
#undef hypotl
#undef ilogb
#undef ilogbf
#undef ilogbl
#undef lgamma
#undef lgammaf
#undef lgammal
#undef llrint
#undef llrintf
#undef llrintl
#undef llround
#undef llroundf
#undef llroundl
#undef log1p
#undef log1pf
#undef log1pl
#undef log2
#undef log2f
#undef log2l
#undef logb
#undef logbf
#undef logbl
#undef lrint
#undef lrintf
#undef lrintl
#undef lround
#undef lroundf
#undef lroundl
#undef nan
#undef nanf
#undef nanl
#undef nearbyint
#undef nearbyintf
#undef nearbyintl
#undef nextafter
#undef nextafterf
#undef nextafterl
#undef nexttoward
#undef nexttowardf
#undef nexttowardl
#undef remainder
#undef remainderf
#undef remainderl
#undef remquo
#undef remquof
#undef remquol
#undef rint
#undef rintf
#undef rintl
#undef round
#undef roundf
#undef roundl
#undef scalbln
#undef scalblnf
#undef scalblnl
#undef scalbn
#undef scalbnf
#undef scalbnl
#undef tgamma
#undef tgammaf
#undef tgammal
#undef trunc
#undef truncf
#undef truncl
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::double_t;
using ::float_t;
using ::acosh;
using ::acoshf;
using ::acoshl;
using ::asinh;
using ::asinhf;
using ::asinhl;
using ::atanh;
using ::atanhf;
using ::atanhl;
using ::cbrt;
using ::cbrtf;
using ::cbrtl;
using ::copysign;
using ::copysignf;
using ::copysignl;
using ::erf;
using ::erff;
using ::erfl;
using ::erfc;
using ::erfcf;
using ::erfcl;
using ::exp2;
using ::exp2f;
using ::exp2l;
using ::expm1;
using ::expm1f;
using ::expm1l;
using ::fdim;
using ::fdimf;
using ::fdiml;
using ::fma;
using ::fmaf;
using ::fmal;
using ::fmax;
using ::fmaxf;
using ::fmaxl;
using ::fmin;
using ::fminf;
using ::fminl;
using ::hypot;
using ::hypotf;
using ::hypotl;
using ::ilogb;
using ::ilogbf;
using ::ilogbl;
using ::lgamma;
using ::lgammaf;
using ::lgammal;
using ::llrint;
using ::llrintf;
using ::llrintl;
using ::llround;
using ::llroundf;
using ::llroundl;
using ::log1p;
using ::log1pf;
using ::log1pl;
using ::log2;
using ::log2f;
using ::log2l;
using ::logb;
using ::logbf;
using ::logbl;
using ::lrint;
using ::lrintf;
using ::lrintl;
using ::lround;
using ::lroundf;
using ::lroundl;
using ::nan;
using ::nanf;
using ::nanl;
using ::nearbyint;
using ::nearbyintf;
using ::nearbyintl;
using ::nextafter;
using ::nextafterf;
using ::nextafterl;
using ::nexttoward;
using ::nexttowardf;
using ::nexttowardl;
using ::remainder;
using ::remainderf;
using ::remainderl;
using ::remquo;
using ::remquof;
using ::remquol;
using ::rint;
using ::rintf;
using ::rintl;
using ::round;
using ::roundf;
using ::roundl;
using ::scalbln;
using ::scalblnf;
using ::scalblnl;
using ::scalbn;
using ::scalbnf;
using ::scalbnl;
using ::tgamma;
using ::tgammaf;
using ::tgammal;
using ::trunc;
using ::truncf;
using ::truncl;
constexpr float
acosh(float __x)
{ return __builtin_acoshf(__x); }
constexpr long double
acosh(long double __x)
{ return __builtin_acoshl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
acosh(_Tp __x)
{ return __builtin_acosh(__x); }
constexpr float
asinh(float __x)
{ return __builtin_asinhf(__x); }
constexpr long double
asinh(long double __x)
{ return __builtin_asinhl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
asinh(_Tp __x)
{ return __builtin_asinh(__x); }
constexpr float
atanh(float __x)
{ return __builtin_atanhf(__x); }
constexpr long double
atanh(long double __x)
{ return __builtin_atanhl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
atanh(_Tp __x)
{ return __builtin_atanh(__x); }
constexpr float
cbrt(float __x)
{ return __builtin_cbrtf(__x); }
constexpr long double
cbrt(long double __x)
{ return __builtin_cbrtl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
cbrt(_Tp __x)
{ return __builtin_cbrt(__x); }
constexpr float
copysign(float __x, float __y)
{ return __builtin_copysignf(__x, __y); }
constexpr long double
copysign(long double __x, long double __y)
{ return __builtin_copysignl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
copysign(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return copysign(__type(__x), __type(__y));
}
constexpr float
erf(float __x)
{ return __builtin_erff(__x); }
constexpr long double
erf(long double __x)
{ return __builtin_erfl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
erf(_Tp __x)
{ return __builtin_erf(__x); }
constexpr float
erfc(float __x)
{ return __builtin_erfcf(__x); }
constexpr long double
erfc(long double __x)
{ return __builtin_erfcl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
erfc(_Tp __x)
{ return __builtin_erfc(__x); }
constexpr float
exp2(float __x)
{ return __builtin_exp2f(__x); }
constexpr long double
exp2(long double __x)
{ return __builtin_exp2l(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
exp2(_Tp __x)
{ return __builtin_exp2(__x); }
constexpr float
expm1(float __x)
{ return __builtin_expm1f(__x); }
constexpr long double
expm1(long double __x)
{ return __builtin_expm1l(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
expm1(_Tp __x)
{ return __builtin_expm1(__x); }
constexpr float
fdim(float __x, float __y)
{ return __builtin_fdimf(__x, __y); }
constexpr long double
fdim(long double __x, long double __y)
{ return __builtin_fdiml(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
fdim(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return fdim(__type(__x), __type(__y));
}
constexpr float
fma(float __x, float __y, float __z)
{ return __builtin_fmaf(__x, __y, __z); }
constexpr long double
fma(long double __x, long double __y, long double __z)
{ return __builtin_fmal(__x, __y, __z); }
template<typename _Tp, typename _Up, typename _Vp>
constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
fma(_Tp __x, _Up __y, _Vp __z)
{
typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
return fma(__type(__x), __type(__y), __type(__z));
}
constexpr float
fmax(float __x, float __y)
{ return __builtin_fmaxf(__x, __y); }
constexpr long double
fmax(long double __x, long double __y)
{ return __builtin_fmaxl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
fmax(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return fmax(__type(__x), __type(__y));
}
constexpr float
fmin(float __x, float __y)
{ return __builtin_fminf(__x, __y); }
constexpr long double
fmin(long double __x, long double __y)
{ return __builtin_fminl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
fmin(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return fmin(__type(__x), __type(__y));
}
constexpr float
hypot(float __x, float __y)
{ return __builtin_hypotf(__x, __y); }
constexpr long double
hypot(long double __x, long double __y)
{ return __builtin_hypotl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
hypot(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return hypot(__type(__x), __type(__y));
}
constexpr int
ilogb(float __x)
{ return __builtin_ilogbf(__x); }
constexpr int
ilogb(long double __x)
{ return __builtin_ilogbl(__x); }
template<typename _Tp>
constexpr
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
int>::__type
ilogb(_Tp __x)
{ return __builtin_ilogb(__x); }
constexpr float
lgamma(float __x)
{ return __builtin_lgammaf(__x); }
constexpr long double
lgamma(long double __x)
{ return __builtin_lgammal(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
lgamma(_Tp __x)
{ return __builtin_lgamma(__x); }
constexpr long long
llrint(float __x)
{ return __builtin_llrintf(__x); }
constexpr long long
llrint(long double __x)
{ return __builtin_llrintl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
long long>::__type
llrint(_Tp __x)
{ return __builtin_llrint(__x); }
constexpr long long
llround(float __x)
{ return __builtin_llroundf(__x); }
constexpr long long
llround(long double __x)
{ return __builtin_llroundl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
long long>::__type
llround(_Tp __x)
{ return __builtin_llround(__x); }
constexpr float
log1p(float __x)
{ return __builtin_log1pf(__x); }
constexpr long double
log1p(long double __x)
{ return __builtin_log1pl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log1p(_Tp __x)
{ return __builtin_log1p(__x); }
constexpr float
log2(float __x)
{ return __builtin_log2f(__x); }
constexpr long double
log2(long double __x)
{ return __builtin_log2l(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
log2(_Tp __x)
{ return __builtin_log2(__x); }
constexpr float
logb(float __x)
{ return __builtin_logbf(__x); }
constexpr long double
logb(long double __x)
{ return __builtin_logbl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
logb(_Tp __x)
{ return __builtin_logb(__x); }
constexpr long
lrint(float __x)
{ return __builtin_lrintf(__x); }
constexpr long
lrint(long double __x)
{ return __builtin_lrintl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
long>::__type
lrint(_Tp __x)
{ return __builtin_lrint(__x); }
constexpr long
lround(float __x)
{ return __builtin_lroundf(__x); }
constexpr long
lround(long double __x)
{ return __builtin_lroundl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
long>::__type
lround(_Tp __x)
{ return __builtin_lround(__x); }
constexpr float
nearbyint(float __x)
{ return __builtin_nearbyintf(__x); }
constexpr long double
nearbyint(long double __x)
{ return __builtin_nearbyintl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
nearbyint(_Tp __x)
{ return __builtin_nearbyint(__x); }
constexpr float
nextafter(float __x, float __y)
{ return __builtin_nextafterf(__x, __y); }
constexpr long double
nextafter(long double __x, long double __y)
{ return __builtin_nextafterl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
nextafter(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return nextafter(__type(__x), __type(__y));
}
constexpr float
nexttoward(float __x, long double __y)
{ return __builtin_nexttowardf(__x, __y); }
constexpr long double
nexttoward(long double __x, long double __y)
{ return __builtin_nexttowardl(__x, __y); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
nexttoward(_Tp __x, long double __y)
{ return __builtin_nexttoward(__x, __y); }
constexpr float
remainder(float __x, float __y)
{ return __builtin_remainderf(__x, __y); }
constexpr long double
remainder(long double __x, long double __y)
{ return __builtin_remainderl(__x, __y); }
template<typename _Tp, typename _Up>
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
remainder(_Tp __x, _Up __y)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return remainder(__type(__x), __type(__y));
}
inline float
remquo(float __x, float __y, int* __pquo)
{ return __builtin_remquof(__x, __y, __pquo); }
inline long double
remquo(long double __x, long double __y, int* __pquo)
{ return __builtin_remquol(__x, __y, __pquo); }
template<typename _Tp, typename _Up>
inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
remquo(_Tp __x, _Up __y, int* __pquo)
{
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return remquo(__type(__x), __type(__y), __pquo);
}
constexpr float
rint(float __x)
{ return __builtin_rintf(__x); }
constexpr long double
rint(long double __x)
{ return __builtin_rintl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
rint(_Tp __x)
{ return __builtin_rint(__x); }
constexpr float
round(float __x)
{ return __builtin_roundf(__x); }
constexpr long double
round(long double __x)
{ return __builtin_roundl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
round(_Tp __x)
{ return __builtin_round(__x); }
constexpr float
scalbln(float __x, long __ex)
{ return __builtin_scalblnf(__x, __ex); }
constexpr long double
scalbln(long double __x, long __ex)
{ return __builtin_scalblnl(__x, __ex); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
scalbln(_Tp __x, long __ex)
{ return __builtin_scalbln(__x, __ex); }
constexpr float
scalbn(float __x, int __ex)
{ return __builtin_scalbnf(__x, __ex); }
constexpr long double
scalbn(long double __x, int __ex)
{ return __builtin_scalbnl(__x, __ex); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
scalbn(_Tp __x, int __ex)
{ return __builtin_scalbn(__x, __ex); }
constexpr float
tgamma(float __x)
{ return __builtin_tgammaf(__x); }
constexpr long double
tgamma(long double __x)
{ return __builtin_tgammal(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
tgamma(_Tp __x)
{ return __builtin_tgamma(__x); }
constexpr float
trunc(float __x)
{ return __builtin_truncf(__x); }
constexpr long double
trunc(long double __x)
{ return __builtin_truncl(__x); }
template<typename _Tp>
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
double>::__type
trunc(_Tp __x)
{ return __builtin_trunc(__x); }
}
#define _RANDOM_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _RealType, size_t __bits,
typename _UniformRandomNumberGenerator>
_RealType
generate_canonical(_UniformRandomNumberGenerator& __g);
namespace __detail
{
template<typename _UIntType, size_t __w,
bool = __w < static_cast<size_t>
(std::numeric_limits<_UIntType>::digits)>
struct _Shift
{ static const _UIntType __value = 0; };
template<typename _UIntType, size_t __w>
struct _Shift<_UIntType, __w, true>
{ static const _UIntType __value = _UIntType(1) << __w; };
template<int __s,
int __which = ((__s <= 8 * sizeof (int))
+ (__s <= 8 * sizeof (long))
+ (__s <= 8 * sizeof (long long))
+ (__s <= 128))>
struct _Select_uint_least_t
{
static_assert(__which < 0,
"sorry, would be too much trouble for a slow result");
};
template<int __s>
struct _Select_uint_least_t<__s, 4>
{ typedef unsigned int type; };
template<int __s>
struct _Select_uint_least_t<__s, 3>
{ typedef unsigned long type; };
template<int __s>
struct _Select_uint_least_t<__s, 2>
{ typedef unsigned long long type; };
template<int __s>
struct _Select_uint_least_t<__s, 1>
{ typedef unsigned __int128 type; };
template<typename _Tp, _Tp __m, _Tp __a, _Tp __c,
bool __big_enough = (!(__m & (__m - 1))
|| (_Tp(-1) - __c) / __a >= __m - 1),
bool __schrage_ok = __m % __a < __m / __a>
struct _Mod
{
typedef typename _Select_uint_least_t<std::__lg(__a)
+ std::__lg(__m) + 2>::type _Tp2;
static _Tp
__calc(_Tp __x)
;
};
template<typename _Tp, _Tp __m, _Tp __a, _Tp __c>
struct _Mod<_Tp, __m, __a, __c, false, true>
{
static _Tp
__calc(_Tp __x);
};
template<typename _Tp, _Tp __m, _Tp __a, _Tp __c, bool __s>
struct _Mod<_Tp, __m, __a, __c, true, __s>
{
static _Tp
__calc(_Tp __x)
;
};
template<typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0>
_Tp
__mod(_Tp __x)
;
template<typename _Tp>
bool
_Power_of_2(_Tp __x)
;;
template<typename _Engine, typename _DInputType>
struct _Adaptor
{
static_assert(std::is_floating_point<_DInputType>::value,
"template argument not a floating point type");
public:
_Adaptor(_Engine& __g) ;
_DInputType
min() const
;
_DInputType
max() const
;
_DInputType
operator()()
;
private:
_Engine& _M_g;
};
}
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
class linear_congruential_engine
{
static_assert(std::is_unsigned<_UIntType>::value, "template argument "
"substituting _UIntType not an unsigned integral type");
static_assert(__m == 0u || (__a < __m && __c < __m),
"template argument substituting __m out of bounds");
public:
typedef _UIntType result_type;
static constexpr result_type multiplier = __a;
static constexpr result_type increment = __c;
static constexpr result_type modulus = __m;
static constexpr result_type default_seed = 1u;
explicit
linear_congruential_engine(result_type __s = default_seed)
;
template<typename _Sseq, typename = typename
std::enable_if<!std::is_same<_Sseq, linear_congruential_engine>::value>
::type>
explicit
linear_congruential_engine(_Sseq& __q)
;
void
seed(result_type __s = default_seed);
template<typename _Sseq>
typename std::enable_if<std::is_class<_Sseq>::value>::type
seed(_Sseq& __q);
static constexpr result_type
min()
{ return __c == 0u ? 1u : 0u; }
static constexpr result_type
max()
{ return __m - 1u; }
void
discard(unsigned long long __z)
{
for (; __z != 0ULL; --__z)
(*this)();
}
result_type
operator()()
{
_M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x);
return _M_x;
}
friend bool
operator==(const linear_congruential_engine& __lhs,
const linear_congruential_engine& __rhs)
{ return __lhs._M_x == __rhs._M_x; }
template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
_UIntType1 __m1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::linear_congruential_engine<_UIntType1,
__a1, __c1, __m1>& __lcr);
template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
_UIntType1 __m1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::linear_congruential_engine<_UIntType1, __a1,
__c1, __m1>& __lcr);
private:
_UIntType _M_x;
};
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
bool
operator!=(const std::linear_congruential_engine<_UIntType, __a,
__c, __m>& __lhs,
const std::linear_congruential_engine<_UIntType, __a,
__c, __m>& __rhs)
;
template<typename _UIntType, size_t __w,
size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t,
_UIntType __c, size_t __l, _UIntType __f>
class mersenne_twister_engine
{
static_assert(std::is_unsigned<_UIntType>::value, "template argument "
"substituting _UIntType not an unsigned integral type");
static_assert(1u <= __m && __m <= __n,
"template argument substituting __m out of bounds");
static_assert(__r <= __w, "template argument substituting "
"__r out of bound");
static_assert(__u <= __w, "template argument substituting "
"__u out of bound");
static_assert(__s <= __w, "template argument substituting "
"__s out of bound");
static_assert(__t <= __w, "template argument substituting "
"__t out of bound");
static_assert(__l <= __w, "template argument substituting "
"__l out of bound");
static_assert(__w <= std::numeric_limits<_UIntType>::digits,
"template argument substituting __w out of bound");
static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1),
"template argument substituting __a out of bound");
static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1),
"template argument substituting __b out of bound");
static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1),
"template argument substituting __c out of bound");
static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1),
"template argument substituting __d out of bound");
static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1),
"template argument substituting __f out of bound");
public:
typedef _UIntType result_type;
static constexpr size_t word_size = __w;
static constexpr size_t state_size = __n;
static constexpr size_t shift_size = __m;
static constexpr size_t mask_bits = __r;
static constexpr result_type xor_mask = __a;
static constexpr size_t tempering_u = __u;
static constexpr result_type tempering_d = __d;
static constexpr size_t tempering_s = __s;
static constexpr result_type tempering_b = __b;
static constexpr size_t tempering_t = __t;
static constexpr result_type tempering_c = __c;
static constexpr size_t tempering_l = __l;
static constexpr result_type initialization_multiplier = __f;
static constexpr result_type default_seed = 5489u;
explicit
mersenne_twister_engine(result_type __sd = default_seed)
;
template<typename _Sseq, typename = typename
std::enable_if<!std::is_same<_Sseq, mersenne_twister_engine>::value>
::type>
explicit
mersenne_twister_engine(_Sseq& __q)
;
void
seed(result_type __sd = default_seed);
template<typename _Sseq>
typename std::enable_if<std::is_class<_Sseq>::value>::type
seed(_Sseq& __q);
static constexpr result_type
min()
{ return 0; };
static constexpr result_type
max()
{ return __detail::_Shift<_UIntType, __w>::__value - 1; }
void
discard(unsigned long long __z);
result_type
operator()();
friend bool
operator==(const mersenne_twister_engine& __lhs,
const mersenne_twister_engine& __rhs)
;
template<typename _UIntType1,
size_t __w1, size_t __n1,
size_t __m1, size_t __r1,
_UIntType1 __a1, size_t __u1,
_UIntType1 __d1, size_t __s1,
_UIntType1 __b1, size_t __t1,
_UIntType1 __c1, size_t __l1, _UIntType1 __f1,
typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::mersenne_twister_engine<_UIntType1, __w1, __n1,
__m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
__l1, __f1>& __x);
template<typename _UIntType1,
size_t __w1, size_t __n1,
size_t __m1, size_t __r1,
_UIntType1 __a1, size_t __u1,
_UIntType1 __d1, size_t __s1,
_UIntType1 __b1, size_t __t1,
_UIntType1 __c1, size_t __l1, _UIntType1 __f1,
typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::mersenne_twister_engine<_UIntType1, __w1, __n1, __m1,
__r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
__l1, __f1>& __x);
private:
void _M_gen_rand();
_UIntType _M_x[state_size];
size_t _M_p;
};
template<typename _UIntType, size_t __w,
size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t,
_UIntType __c, size_t __l, _UIntType __f>
bool
operator!=(const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
__r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs,
const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
__r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs)
;
template<typename _UIntType, size_t __w, size_t __s, size_t __r>
class subtract_with_carry_engine
{
static_assert(std::is_unsigned<_UIntType>::value, "template argument "
"substituting _UIntType not an unsigned integral type");
static_assert(0u < __s && __s < __r,
"template argument substituting __s out of bounds");
static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
"template argument substituting __w out of bounds");
public:
typedef _UIntType result_type;
static constexpr size_t word_size = __w;
static constexpr size_t short_lag = __s;
static constexpr size_t long_lag = __r;
static constexpr result_type default_seed = 19780503u;
explicit
subtract_with_carry_engine(result_type __sd = default_seed)
;
template<typename _Sseq, typename = typename
std::enable_if<!std::is_same<_Sseq, subtract_with_carry_engine>::value>
::type>
explicit
subtract_with_carry_engine(_Sseq& __q)
;
void
seed(result_type __sd = default_seed);
template<typename _Sseq>
typename std::enable_if<std::is_class<_Sseq>::value>::type
seed(_Sseq& __q);
static constexpr result_type
min()
{ return 0; }
static constexpr result_type
max()
{ return __detail::_Shift<_UIntType, __w>::__value - 1; }
void
discard(unsigned long long __z)
{
for (; __z != 0ULL; --__z)
(*this)();
}
result_type
operator()();
friend bool
operator==(const subtract_with_carry_engine& __lhs,
const subtract_with_carry_engine& __rhs)
;
template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::subtract_with_carry_engine<_UIntType1, __w1,
__s1, __r1>& __x);
template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::subtract_with_carry_engine<_UIntType1, __w1,
__s1, __r1>& __x);
private:
_UIntType _M_x[long_lag];
_UIntType _M_carry;
size_t _M_p;
};
template<typename _UIntType, size_t __w, size_t __s, size_t __r>
bool
operator!=(const std::subtract_with_carry_engine<_UIntType, __w,
__s, __r>& __lhs,
const std::subtract_with_carry_engine<_UIntType, __w,
__s, __r>& __rhs)
;
template<typename _RandomNumberEngine, size_t __p, size_t __r>
class discard_block_engine
{
static_assert(1 <= __r && __r <= __p,
"template argument substituting __r out of bounds");
public:
typedef typename _RandomNumberEngine::result_type result_type;
static constexpr size_t block_size = __p;
static constexpr size_t used_block = __r;
discard_block_engine()
: _M_b(), _M_n(0) { }
explicit
discard_block_engine(const _RandomNumberEngine& __rng)
: _M_b(__rng), _M_n(0) { }
explicit
discard_block_engine(_RandomNumberEngine&& __rng)
: _M_b(std::move(__rng)), _M_n(0) { }
explicit
discard_block_engine(result_type __s)
: _M_b(__s), _M_n(0) { }
template<typename _Sseq, typename = typename
std::enable_if<!std::is_same<_Sseq, discard_block_engine>::value
&& !std::is_same<_Sseq, _RandomNumberEngine>::value>
::type>
explicit
discard_block_engine(_Sseq& __q)
: _M_b(__q), _M_n(0)
{ }
void
seed()
;
void
seed(result_type __s)
;
template<typename _Sseq>
void
seed(_Sseq& __q)
;
const _RandomNumberEngine&
base() const noexcept
{ return _M_b; }
static constexpr result_type
min()
{ return _RandomNumberEngine::min(); }
static constexpr result_type
max()
{ return _RandomNumberEngine::max(); }
void
discard(unsigned long long __z)
{
for (; __z != 0ULL; --__z)
(*this)();
}
result_type
operator()();
friend bool
operator==(const discard_block_engine& __lhs,
const discard_block_engine& __rhs)
;
template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::discard_block_engine<_RandomNumberEngine1,
__p1, __r1>& __x);
template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::discard_block_engine<_RandomNumberEngine1,
__p1, __r1>& __x);
private:
_RandomNumberEngine _M_b;
size_t _M_n;
};
template<typename _RandomNumberEngine, size_t __p, size_t __r>
bool
operator!=(const std::discard_block_engine<_RandomNumberEngine, __p,
__r>& __lhs,
const std::discard_block_engine<_RandomNumberEngine, __p,
__r>& __rhs)
;
template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
class independent_bits_engine
{
static_assert(std::is_unsigned<_UIntType>::value, "template argument "
"substituting _UIntType not an unsigned integral type");
static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
"template argument substituting __w out of bounds");
public:
typedef _UIntType result_type;
independent_bits_engine() ;
explicit
independent_bits_engine(const _RandomNumberEngine& __rng) ;
explicit
independent_bits_engine(_RandomNumberEngine&& __rng) ;
explicit
independent_bits_engine(result_type __s) ;
template<typename _Sseq, typename = typename
std::enable_if<!std::is_same<_Sseq, independent_bits_engine>::value
&& !std::is_same<_Sseq, _RandomNumberEngine>::value>
::type>
explicit
independent_bits_engine(_Sseq& __q)
;
void
seed()
;
void
seed(result_type __s)
;
template<typename _Sseq>
void
seed(_Sseq& __q)
;
const _RandomNumberEngine&
base() const noexcept
{ return _M_b; }
static constexpr result_type
min()
{ return 0U; }
static constexpr result_type
max()
{ return __detail::_Shift<_UIntType, __w>::__value - 1; }
void
discard(unsigned long long __z)
{
for (; __z != 0ULL; --__z)
(*this)();
}
result_type
operator()();
friend bool
operator==(const independent_bits_engine& __lhs,
const independent_bits_engine& __rhs)
;
template<typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::independent_bits_engine<_RandomNumberEngine,
__w, _UIntType>& __x)
;
private:
_RandomNumberEngine _M_b;
};
template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
bool
operator!=(const std::independent_bits_engine<_RandomNumberEngine, __w,
_UIntType>& __lhs,
const std::independent_bits_engine<_RandomNumberEngine, __w,
_UIntType>& __rhs)
;
template<typename _RandomNumberEngine, size_t __w, typename _UIntType,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::independent_bits_engine<_RandomNumberEngine,
__w, _UIntType>& __x)
;
template<typename _RandomNumberEngine, size_t __k>
class shuffle_order_engine
{
static_assert(1u <= __k, "template argument substituting "
"__k out of bound");
public:
typedef typename _RandomNumberEngine::result_type result_type;
static constexpr size_t table_size = __k;
shuffle_order_engine()
;
explicit
shuffle_order_engine(const _RandomNumberEngine& __rng)
;
explicit
shuffle_order_engine(_RandomNumberEngine&& __rng)
;
explicit
shuffle_order_engine(result_type __s)
;
template<typename _Sseq, typename = typename
std::enable_if<!std::is_same<_Sseq, shuffle_order_engine>::value
&& !std::is_same<_Sseq, _RandomNumberEngine>::value>
::type>
explicit
shuffle_order_engine(_Sseq& __q)
;
void
seed()
;
void
seed(result_type __s)
;
template<typename _Sseq>
void
seed(_Sseq& __q)
;
const _RandomNumberEngine&
base() const noexcept
{ return _M_b; }
static constexpr result_type
min()
{ return _RandomNumberEngine::min(); }
static constexpr result_type
max()
{ return _RandomNumberEngine::max(); }
void
discard(unsigned long long __z)
{
for (; __z != 0ULL; --__z)
(*this)();
}
result_type
operator()();
friend bool
operator==(const shuffle_order_engine& __lhs,
const shuffle_order_engine& __rhs)
;
template<typename _RandomNumberEngine1, size_t __k1,
typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::shuffle_order_engine<_RandomNumberEngine1,
__k1>& __x);
template<typename _RandomNumberEngine1, size_t __k1,
typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::shuffle_order_engine<_RandomNumberEngine1, __k1>& __x);
private:
void _M_initialize()
;
_RandomNumberEngine _M_b;
result_type _M_v[__k];
result_type _M_y;
};
template<typename _RandomNumberEngine, size_t __k>
bool
operator!=(const std::shuffle_order_engine<_RandomNumberEngine,
__k>& __lhs,
const std::shuffle_order_engine<_RandomNumberEngine,
__k>& __rhs)
;
typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
minstd_rand0;
typedef linear_congruential_engine<uint_fast32_t, 48271UL, 0UL, 2147483647UL>
minstd_rand;
typedef mersenne_twister_engine<
uint_fast32_t,
32, 624, 397, 31,
0x9908b0dfUL, 11,
0xffffffffUL, 7,
0x9d2c5680UL, 15,
0xefc60000UL, 18, 1812433253UL> mt19937;
typedef mersenne_twister_engine<
uint_fast64_t,
64, 312, 156, 31,
0xb5026f5aa96619e9ULL, 29,
0x5555555555555555ULL, 17,
0x71d67fffeda60000ULL, 37,
0xfff7eee000000000ULL, 43,
6364136223846793005ULL> mt19937_64;
typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>
ranlux24_base;
typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>
ranlux48_base;
typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
typedef minstd_rand0 default_random_engine;
class random_device
{
public:
typedef unsigned int result_type;
explicit
random_device(const std::string& __token = "default")
;
~random_device()
;
static constexpr result_type
min()
{ return std::numeric_limits<result_type>::min(); }
static constexpr result_type
max()
{ return std::numeric_limits<result_type>::max(); }
double
entropy() const noexcept
{ return 0.0; }
result_type
operator()()
{
return this->_M_getval();
}
random_device(const random_device&) = delete;
void operator=(const random_device&) = delete;
private:
void _M_init(const std::string& __token);
void _M_init_pretr1(const std::string& __token);
void _M_fini();
result_type _M_getval();
result_type _M_getval_pretr1();
union
{
void* _M_file;
mt19937 _M_mt;
};
};
template<typename _IntType = int>
class uniform_int_distribution
{
static_assert(std::is_integral<_IntType>::value,
"template argument not 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())
;
result_type
a() const
;
result_type
b() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_IntType _M_a;
_IntType _M_b;
};
public:
explicit
uniform_int_distribution(_IntType __a = 0,
_IntType __b = std::numeric_limits<_IntType>::max())
;
explicit
uniform_int_distribution(const param_type& __p)
;
void
reset() ;
result_type
a() const
;
result_type
b() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const uniform_int_distribution& __d1,
const uniform_int_distribution& __d2)
;
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>
bool
operator!=(const std::uniform_int_distribution<_IntType>& __d1,
const std::uniform_int_distribution<_IntType>& __d2)
;
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>&,
const std::uniform_int_distribution<_IntType>&);
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>&,
std::uniform_int_distribution<_IntType>&);
template<typename _RealType = double>
class uniform_real_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef uniform_real_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __a = _RealType(0),
_RealType __b = _RealType(1))
;
result_type
a() const
;
result_type
b() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_a;
_RealType _M_b;
};
public:
explicit
uniform_real_distribution(_RealType __a = _RealType(0),
_RealType __b = _RealType(1))
;
explicit
uniform_real_distribution(const param_type& __p)
;
void
reset() ;
result_type
a() const
;
result_type
b() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const uniform_real_distribution& __d1,
const uniform_real_distribution& __d2)
;
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>
bool
operator!=(const std::uniform_real_distribution<_IntType>& __d1,
const std::uniform_real_distribution<_IntType>& __d2)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>&,
const std::uniform_real_distribution<_RealType>&);
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>&,
std::uniform_real_distribution<_RealType>&);
template<typename _RealType = double>
class normal_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef normal_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __mean = _RealType(0),
_RealType __stddev = _RealType(1))
;
_RealType
mean() const
;
_RealType
stddev() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_mean;
_RealType _M_stddev;
};
public:
explicit
normal_distribution(result_type __mean = result_type(0),
result_type __stddev = result_type(1))
;
explicit
normal_distribution(const param_type& __p)
;
void
reset()
;
_RealType
mean() const
;
_RealType
stddev() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _RealType1>
friend bool
operator==(const std::normal_distribution<_RealType1>& __d1,
const std::normal_distribution<_RealType1>& __d2);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::normal_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::normal_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
result_type _M_saved;
bool _M_saved_available;
};
template<typename _RealType>
bool
operator!=(const std::normal_distribution<_RealType>& __d1,
const std::normal_distribution<_RealType>& __d2)
;
template<typename _RealType = double>
class lognormal_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef lognormal_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __m = _RealType(0),
_RealType __s = _RealType(1))
;
_RealType
m() const
;
_RealType
s() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_m;
_RealType _M_s;
};
explicit
lognormal_distribution(_RealType __m = _RealType(0),
_RealType __s = _RealType(1))
;
explicit
lognormal_distribution(const param_type& __p)
;
void
reset()
;
_RealType
m() const
;
_RealType
s() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const lognormal_distribution& __d1,
const lognormal_distribution& __d2)
;
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::lognormal_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::lognormal_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
std::normal_distribution<result_type> _M_nd;
};
template<typename _RealType>
bool
operator!=(const std::lognormal_distribution<_RealType>& __d1,
const std::lognormal_distribution<_RealType>& __d2)
;
template<typename _RealType = double>
class gamma_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef gamma_distribution<_RealType> distribution_type;
friend class gamma_distribution<_RealType>;
explicit
param_type(_RealType __alpha_val = _RealType(1),
_RealType __beta_val = _RealType(1))
;
_RealType
alpha() const
;
_RealType
beta() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
void
_M_initialize();
_RealType _M_alpha;
_RealType _M_beta;
_RealType _M_malpha, _M_a2;
};
public:
explicit
gamma_distribution(_RealType __alpha_val = _RealType(1),
_RealType __beta_val = _RealType(1))
;
explicit
gamma_distribution(const param_type& __p)
;
void
reset()
;
_RealType
alpha() const
;
_RealType
beta() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const gamma_distribution& __d1,
const gamma_distribution& __d2)
;
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::gamma_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::gamma_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
std::normal_distribution<result_type> _M_nd;
};
template<typename _RealType>
bool
operator!=(const std::gamma_distribution<_RealType>& __d1,
const std::gamma_distribution<_RealType>& __d2)
;
template<typename _RealType = double>
class chi_squared_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef chi_squared_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __n = _RealType(1))
;
_RealType
n() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_n;
};
explicit
chi_squared_distribution(_RealType __n = _RealType(1))
;
explicit
chi_squared_distribution(const param_type& __p)
;
void
reset()
;
_RealType
n() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const chi_squared_distribution& __d1,
const chi_squared_distribution& __d2)
;
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::chi_squared_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::chi_squared_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const typename
std::gamma_distribution<result_type>::param_type& __p);
param_type _M_param;
std::gamma_distribution<result_type> _M_gd;
};
template<typename _RealType>
bool
operator!=(const std::chi_squared_distribution<_RealType>& __d1,
const std::chi_squared_distribution<_RealType>& __d2)
;
template<typename _RealType = double>
class cauchy_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef cauchy_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __a = _RealType(0),
_RealType __b = _RealType(1))
;
_RealType
a() const
;
_RealType
b() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_a;
_RealType _M_b;
};
explicit
cauchy_distribution(_RealType __a = _RealType(0),
_RealType __b = _RealType(1))
;
explicit
cauchy_distribution(const param_type& __p)
;
void
reset()
;
_RealType
a() const
;
_RealType
b() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const cauchy_distribution& __d1,
const cauchy_distribution& __d2)
;
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
template<typename _RealType>
bool
operator!=(const std::cauchy_distribution<_RealType>& __d1,
const std::cauchy_distribution<_RealType>& __d2)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::cauchy_distribution<_RealType>& __x);
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::cauchy_distribution<_RealType>& __x);
template<typename _RealType = double>
class fisher_f_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef fisher_f_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __m = _RealType(1),
_RealType __n = _RealType(1))
;
_RealType
m() const
;
_RealType
n() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_m;
_RealType _M_n;
};
explicit
fisher_f_distribution(_RealType __m = _RealType(1),
_RealType __n = _RealType(1))
;
explicit
fisher_f_distribution(const param_type& __p)
;
void
reset()
;
_RealType
m() const
;
_RealType
n() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const fisher_f_distribution& __d1,
const fisher_f_distribution& __d2)
;
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::fisher_f_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::fisher_f_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
std::gamma_distribution<result_type> _M_gd_x, _M_gd_y;
};
template<typename _RealType>
bool
operator!=(const std::fisher_f_distribution<_RealType>& __d1,
const std::fisher_f_distribution<_RealType>& __d2)
;
template<typename _RealType = double>
class student_t_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef student_t_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __n = _RealType(1))
;
_RealType
n() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_n;
};
explicit
student_t_distribution(_RealType __n = _RealType(1))
;
explicit
student_t_distribution(const param_type& __p)
;
void
reset()
;
_RealType
n() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const student_t_distribution& __d1,
const student_t_distribution& __d2)
;
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::student_t_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::student_t_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
std::normal_distribution<result_type> _M_nd;
std::gamma_distribution<result_type> _M_gd;
};
template<typename _RealType>
bool
operator!=(const std::student_t_distribution<_RealType>& __d1,
const std::student_t_distribution<_RealType>& __d2)
;
class bernoulli_distribution
{
public:
typedef bool result_type;
struct param_type
{
typedef bernoulli_distribution distribution_type;
explicit
param_type(double __p = 0.5)
;
double
p() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
double _M_p;
};
public:
explicit
bernoulli_distribution(double __p = 0.5)
;
explicit
bernoulli_distribution(const param_type& __p)
;
void
reset() ;
double
p() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng, const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const bernoulli_distribution& __d1,
const bernoulli_distribution& __d2)
;
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
bool
operator!=(const std::bernoulli_distribution& __d1,
const std::bernoulli_distribution& __d2)
;
template<typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::bernoulli_distribution& __x);
template<typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::bernoulli_distribution& __x)
{
double __p;
__is >> __p;
__x.param(bernoulli_distribution::param_type(__p));
return __is;
}
template<typename _IntType = int>
class binomial_distribution
{
static_assert(std::is_integral<_IntType>::value,
"template argument not an integral type");
public:
typedef _IntType result_type;
struct param_type
{
typedef binomial_distribution<_IntType> distribution_type;
friend class binomial_distribution<_IntType>;
explicit
param_type(_IntType __t = _IntType(1), double __p = 0.5)
: _M_t(__t), _M_p(__p)
{
;
_M_initialize();
}
_IntType
t() const
{ return _M_t; }
double
p() const
{ return _M_p; }
friend bool
operator==(const param_type& __p1, const param_type& __p2)
{ return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; }
private:
void
_M_initialize();
_IntType _M_t;
double _M_p;
double _M_q;
double _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
_M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
bool _M_easy;
};
explicit
binomial_distribution(_IntType __t = _IntType(1),
double __p = 0.5)
: _M_param(__t, __p), _M_nd()
{ }
explicit
binomial_distribution(const param_type& __p)
: _M_param(__p), _M_nd()
{ }
void
reset()
{ _M_nd.reset(); }
_IntType
t() const
{ return _M_param.t(); }
double
p() const
{ return _M_param.p(); }
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const binomial_distribution& __d1,
const binomial_distribution& __d2)
;
template<typename _IntType1,
typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::binomial_distribution<_IntType1>& __x);
template<typename _IntType1,
typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::binomial_distribution<_IntType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _UniformRandomNumberGenerator>
result_type
_M_waiting(_UniformRandomNumberGenerator& __urng,
_IntType __t, double __q);
param_type _M_param;
std::normal_distribution<double> _M_nd;
};
template<typename _IntType>
bool
operator!=(const std::binomial_distribution<_IntType>& __d1,
const std::binomial_distribution<_IntType>& __d2)
;
template<typename _IntType = int>
class geometric_distribution
{
static_assert(std::is_integral<_IntType>::value,
"template argument not an integral type");
public:
typedef _IntType result_type;
struct param_type
{
typedef geometric_distribution<_IntType> distribution_type;
friend class geometric_distribution<_IntType>;
explicit
param_type(double __p = 0.5)
;
double
p() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
void
_M_initialize()
;
double _M_p;
double _M_log_1_p;
};
explicit
geometric_distribution(double __p = 0.5)
;
explicit
geometric_distribution(const param_type& __p)
;
void
reset() ;
double
p() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const geometric_distribution& __d1,
const geometric_distribution& __d2)
;
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>
bool
operator!=(const std::geometric_distribution<_IntType>& __d1,
const std::geometric_distribution<_IntType>& __d2)
;
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::geometric_distribution<_IntType>& __x);
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::geometric_distribution<_IntType>& __x);
template<typename _IntType = int>
class negative_binomial_distribution
{
static_assert(std::is_integral<_IntType>::value,
"template argument not an integral type");
public:
typedef _IntType result_type;
struct param_type
{
typedef negative_binomial_distribution<_IntType> distribution_type;
explicit
param_type(_IntType __k = 1, double __p = 0.5)
;
_IntType
k() const
;
double
p() const
{ return _M_p; }
friend bool
operator==(const param_type& __p1, const param_type& __p2)
{ return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; }
private:
_IntType _M_k;
double _M_p;
};
explicit
negative_binomial_distribution(_IntType __k = 1, double __p = 0.5)
: _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p)
{ }
explicit
negative_binomial_distribution(const param_type& __p)
: _M_param(__p), _M_gd(__p.k(), (1.0 - __p.p()) / __p.p())
{ }
void
reset()
;
_IntType
k() const
;
double
p() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng);
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const negative_binomial_distribution& __d1,
const negative_binomial_distribution& __d2)
;
template<typename _IntType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::negative_binomial_distribution<_IntType1>& __x);
template<typename _IntType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::negative_binomial_distribution<_IntType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
std::gamma_distribution<double> _M_gd;
};
template<typename _IntType>
bool
operator!=(const std::negative_binomial_distribution<_IntType>& __d1,
const std::negative_binomial_distribution<_IntType>& __d2)
;
template<typename _IntType = int>
class poisson_distribution
{
static_assert(std::is_integral<_IntType>::value,
"template argument not an integral type");
public:
typedef _IntType result_type;
struct param_type
{
typedef poisson_distribution<_IntType> distribution_type;
friend class poisson_distribution<_IntType>;
explicit
param_type(double __mean = 1.0)
;
double
mean() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
void
_M_initialize();
double _M_mean;
double _M_lm_thr;
double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
};
explicit
poisson_distribution(double __mean = 1.0)
: _M_param(__mean), _M_nd()
{ }
explicit
poisson_distribution(const param_type& __p)
: _M_param(__p), _M_nd()
{ }
void
reset()
{ _M_nd.reset(); }
double
mean() const
{ return _M_param.mean(); }
param_type
param() const
{ return _M_param; }
void
param(const param_type& __param)
{ _M_param = __param; }
result_type
min() const
{ return 0; }
result_type
max() const
{ return std::numeric_limits<result_type>::max(); }
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
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)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const poisson_distribution& __d1,
const poisson_distribution& __d2)
;
template<typename _IntType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::poisson_distribution<_IntType1>& __x);
template<typename _IntType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::poisson_distribution<_IntType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
std::normal_distribution<double> _M_nd;
};
template<typename _IntType>
bool
operator!=(const std::poisson_distribution<_IntType>& __d1,
const std::poisson_distribution<_IntType>& __d2)
;
template<typename _RealType = double>
class exponential_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef exponential_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __lambda = _RealType(1))
;
_RealType
lambda() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_lambda;
};
public:
explicit
exponential_distribution(const result_type& __lambda = result_type(1))
;
explicit
exponential_distribution(const param_type& __p)
;
void
reset() ;
_RealType
lambda() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const exponential_distribution& __d1,
const exponential_distribution& __d2)
;
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
template<typename _RealType>
bool
operator!=(const std::exponential_distribution<_RealType>& __d1,
const std::exponential_distribution<_RealType>& __d2)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::exponential_distribution<_RealType>& __x);
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::exponential_distribution<_RealType>& __x);
template<typename _RealType = double>
class weibull_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef weibull_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __a = _RealType(1),
_RealType __b = _RealType(1))
;
_RealType
a() const
;
_RealType
b() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_a;
_RealType _M_b;
};
explicit
weibull_distribution(_RealType __a = _RealType(1),
_RealType __b = _RealType(1))
;
explicit
weibull_distribution(const param_type& __p)
;
void
reset()
;
_RealType
a() const
;
_RealType
b() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const weibull_distribution& __d1,
const weibull_distribution& __d2)
;
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
template<typename _RealType>
bool
operator!=(const std::weibull_distribution<_RealType>& __d1,
const std::weibull_distribution<_RealType>& __d2)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::weibull_distribution<_RealType>& __x);
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::weibull_distribution<_RealType>& __x);
template<typename _RealType = double>
class extreme_value_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef extreme_value_distribution<_RealType> distribution_type;
explicit
param_type(_RealType __a = _RealType(0),
_RealType __b = _RealType(1))
;
_RealType
a() const
;
_RealType
b() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
_RealType _M_a;
_RealType _M_b;
};
explicit
extreme_value_distribution(_RealType __a = _RealType(0),
_RealType __b = _RealType(1))
;
explicit
extreme_value_distribution(const param_type& __p)
;
void
reset()
;
_RealType
a() const
;
_RealType
b() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
friend bool
operator==(const extreme_value_distribution& __d1,
const extreme_value_distribution& __d2)
{ return __d1._M_param == __d2._M_param; }
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
template<typename _RealType>
inline bool
operator!=(const std::extreme_value_distribution<_RealType>& __d1,
const std::extreme_value_distribution<_RealType>& __d2)
{ return !(__d1 == __d2); }
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::extreme_value_distribution<_RealType>& __x);
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::extreme_value_distribution<_RealType>& __x);
template<typename _IntType = int>
class discrete_distribution
{
static_assert(std::is_integral<_IntType>::value,
"template argument not an integral type");
public:
typedef _IntType result_type;
struct param_type
{
typedef discrete_distribution<_IntType> distribution_type;
friend class discrete_distribution<_IntType>;
param_type()
: _M_prob(), _M_cp()
{ }
template<typename _InputIterator>
param_type(_InputIterator __wbegin,
_InputIterator __wend)
: _M_prob(__wbegin, __wend), _M_cp()
{ _M_initialize(); }
param_type(initializer_list<double> __wil)
: _M_prob(__wil.begin(), __wil.end()), _M_cp()
{ _M_initialize(); }
template<typename _Func>
param_type(size_t __nw, double __xmin, double __xmax,
_Func __fw);
param_type(const param_type&) = default;
param_type& operator=(const param_type&) = default;
std::vector<double>
probabilities() const
;
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
void
_M_initialize();
std::vector<double> _M_prob;
std::vector<double> _M_cp;
};
discrete_distribution()
;
template<typename _InputIterator>
discrete_distribution(_InputIterator __wbegin,
_InputIterator __wend)
;
discrete_distribution(initializer_list<double> __wl)
;
template<typename _Func>
discrete_distribution(size_t __nw, double __xmin, double __xmax,
_Func __fw)
;
explicit
discrete_distribution(const param_type& __p)
;
void
reset()
;
std::vector<double>
probabilities() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
friend bool
operator==(const discrete_distribution& __d1,
const discrete_distribution& __d2)
{ return __d1._M_param == __d2._M_param; }
template<typename _IntType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::discrete_distribution<_IntType1>& __x);
template<typename _IntType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::discrete_distribution<_IntType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
template<typename _IntType>
inline bool
operator!=(const std::discrete_distribution<_IntType>& __d1,
const std::discrete_distribution<_IntType>& __d2)
{ return !(__d1 == __d2); }
template<typename _RealType = double>
class piecewise_constant_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef piecewise_constant_distribution<_RealType> distribution_type;
friend class piecewise_constant_distribution<_RealType>;
param_type()
: _M_int(), _M_den(), _M_cp()
{ }
template<typename _InputIteratorB, typename _InputIteratorW>
param_type(_InputIteratorB __bfirst,
_InputIteratorB __bend,
_InputIteratorW __wbegin);
template<typename _Func>
param_type(initializer_list<_RealType> __bi, _Func __fw);
template<typename _Func>
param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
_Func __fw);
param_type(const param_type&) = default;
param_type& operator=(const param_type&) = default;
std::vector<_RealType>
intervals() const
{
if (_M_int.empty())
{
std::vector<_RealType> __tmp(2);
__tmp[1] = _RealType(1);
return __tmp;
}
else
return _M_int;
}
std::vector<double>
densities() const
{ return _M_den.empty() ? std::vector<double>(1, 1.0) : _M_den; }
friend bool
operator==(const param_type& __p1, const param_type& __p2)
;
private:
void
_M_initialize();
std::vector<_RealType> _M_int;
std::vector<double> _M_den;
std::vector<double> _M_cp;
};
explicit
piecewise_constant_distribution()
;
template<typename _InputIteratorB, typename _InputIteratorW>
piecewise_constant_distribution(_InputIteratorB __bfirst,
_InputIteratorB __bend,
_InputIteratorW __wbegin)
;
template<typename _Func>
piecewise_constant_distribution(initializer_list<_RealType> __bl,
_Func __fw)
;
template<typename _Func>
piecewise_constant_distribution(size_t __nw,
_RealType __xmin, _RealType __xmax,
_Func __fw)
;
explicit
piecewise_constant_distribution(const param_type& __p)
;
void
reset()
;
std::vector<_RealType>
intervals() const
;
std::vector<double>
densities() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }
friend bool
operator==(const piecewise_constant_distribution& __d1,
const piecewise_constant_distribution& __d2)
{ return __d1._M_param == __d2._M_param; }
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::piecewise_constant_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::piecewise_constant_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
template<typename _RealType>
inline bool
operator!=(const std::piecewise_constant_distribution<_RealType>& __d1,
const std::piecewise_constant_distribution<_RealType>& __d2)
{ return !(__d1 == __d2); }
template<typename _RealType = double>
class piecewise_linear_distribution
{
static_assert(std::is_floating_point<_RealType>::value,
"template argument not a floating point type");
public:
typedef _RealType result_type;
struct param_type
{
typedef piecewise_linear_distribution<_RealType> distribution_type;
friend class piecewise_linear_distribution<_RealType>;
param_type()
: _M_int(), _M_den(), _M_cp(), _M_m()
{ }
template<typename _InputIteratorB, typename _InputIteratorW>
param_type(_InputIteratorB __bfirst,
_InputIteratorB __bend,
_InputIteratorW __wbegin);
template<typename _Func>
param_type(initializer_list<_RealType> __bl, _Func __fw);
template<typename _Func>
param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
_Func __fw);
param_type(const param_type&) = default;
param_type& operator=(const param_type&) = default;
std::vector<_RealType>
intervals() const
{
if (_M_int.empty())
{
std::vector<_RealType> __tmp(2);
__tmp[1] = _RealType(1);
return __tmp;
}
else
return _M_int;
}
std::vector<double>
densities() const
{ return _M_den.empty() ? std::vector<double>(2, 1.0) : _M_den; }
friend bool
operator==(const param_type& __p1, const param_type& __p2)
{ return (__p1._M_int == __p2._M_int
&& __p1._M_den == __p2._M_den); }
private:
void
_M_initialize();
std::vector<_RealType> _M_int;
std::vector<double> _M_den;
std::vector<double> _M_cp;
std::vector<double> _M_m;
};
explicit
piecewise_linear_distribution()
;
template<typename _InputIteratorB, typename _InputIteratorW>
piecewise_linear_distribution(_InputIteratorB __bfirst,
_InputIteratorB __bend,
_InputIteratorW __wbegin)
;
template<typename _Func>
piecewise_linear_distribution(initializer_list<_RealType> __bl,
_Func __fw)
;
template<typename _Func>
piecewise_linear_distribution(size_t __nw,
_RealType __xmin, _RealType __xmax,
_Func __fw)
;
explicit
piecewise_linear_distribution(const param_type& __p)
;
void
reset()
;
std::vector<_RealType>
intervals() const
;
std::vector<double>
densities() const
;
param_type
param() const
;
void
param(const param_type& __param)
;
result_type
min() const
;
result_type
max() const
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng)
;
template<typename _UniformRandomNumberGenerator>
result_type
operator()(_UniformRandomNumberGenerator& __urng,
const param_type& __p);
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng)
;
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
template<typename _UniformRandomNumberGenerator>
void
__generate(result_type* __f, result_type* __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p)
;
friend bool
operator==(const piecewise_linear_distribution& __d1,
const piecewise_linear_distribution& __d2)
{ return __d1._M_param == __d2._M_param; }
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const std::piecewise_linear_distribution<_RealType1>& __x);
template<typename _RealType1, typename _CharT, typename _Traits>
friend std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
std::piecewise_linear_distribution<_RealType1>& __x);
private:
template<typename _ForwardIterator,
typename _UniformRandomNumberGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomNumberGenerator& __urng,
const param_type& __p);
param_type _M_param;
};
template<typename _RealType>
inline bool
operator!=(const std::piecewise_linear_distribution<_RealType>& __d1,
const std::piecewise_linear_distribution<_RealType>& __d2)
{ return !(__d1 == __d2); }
class seed_seq
{
public:
typedef uint_least32_t result_type;
seed_seq()
: _M_v()
{ }
template<typename _IntType>
seed_seq(std::initializer_list<_IntType> il);
template<typename _InputIterator>
seed_seq(_InputIterator __begin, _InputIterator __end);
template<typename _RandomAccessIterator>
void
generate(_RandomAccessIterator __begin, _RandomAccessIterator __end);
size_t size() const
{ return _M_v.size(); }
template<typename OutputIterator>
void
param(OutputIterator __dest) const
;
private:
std::vector<result_type> _M_v;
};
}
#define _BITS_OPT_RANDOM_H 1
#define _X86INTRIN_H_INCLUDED
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bsfd (int __X)
;
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bsrd (int __X)
;
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bswapd (int __X)
;
#pragma GCC push_options
#pragma GCC target("sse4.2")
#define __DISABLE_SSE4_2__
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__crc32b (unsigned int __C, unsigned char __V)
;
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__crc32w (unsigned int __C, unsigned short __V)
;
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__crc32d (unsigned int __C, unsigned int __V)
;
#undef __DISABLE_SSE4_2__
#pragma GCC pop_options
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__popcntd (unsigned int __X)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rdpmc (int __S)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rdtsc (void)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rdtscp (unsigned int *__A)
;
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rolb (unsigned char __X, int __C)
;
extern unsigned short
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rolw (unsigned short __X, int __C)
;
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rold (unsigned int __X, int __C)
;
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rorb (unsigned char __X, int __C)
;
extern unsigned short
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rorw (unsigned short __X, int __C)
;
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rord (unsigned int __X, int __C)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__pause (void)
;
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bsfq (long long __X)
;
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bsrq (long long __X)
;
extern long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bswapq (long long __X)
;
#pragma GCC push_options
#pragma GCC target("sse4.2")
#define __DISABLE_SSE4_2__
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__crc32q (unsigned long long __C, unsigned long long __V)
;
#undef __DISABLE_SSE4_2__
#pragma GCC pop_options
extern long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__popcntq (unsigned long long __X)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rolq (unsigned long long __X, int __C)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__rorq (unsigned long long __X, int __C)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__readeflags (void)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
__writeeflags (unsigned long long X)
;
#define _bswap64(a) __bswapq(a)
#define _popcnt64(a) __popcntq(a)
#define _lrotl(a,b) __rolq((a), (b))
#define _lrotr(a,b) __rorq((a), (b))
#define _bit_scan_forward(a) __bsfd(a)
#define _bit_scan_reverse(a) __bsrd(a)
#define _bswap(a) __bswapd(a)
#define _popcnt32(a) __popcntd(a)
#define _rdpmc(a) __rdpmc(a)
#define _rdtsc() __rdtsc()
#define _rdtscp(a) __rdtscp(a)
#define _rotwl(a,b) __rolw((a), (b))
#define _rotwr(a,b) __rorw((a), (b))
#define _rotl(a,b) __rold((a), (b))
#define _rotr(a,b) __rord((a), (b))
#define _MMINTRIN_H_INCLUDED
typedef int __m64 __attribute__ ((__vector_size__ (8), __may_alias__));
typedef int __v2si __attribute__ ((__vector_size__ (8)));
typedef short __v4hi __attribute__ ((__vector_size__ (8)));
typedef char __v8qi __attribute__ ((__vector_size__ (8)));
typedef long long __v1di __attribute__ ((__vector_size__ (8)));
typedef float __v2sf __attribute__ ((__vector_size__ (8)));
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_empty (void)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_empty (void)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi32_si64 (int __i)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_from_int (int __i)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_from_int64 (long long __i)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_m64 (long long __i)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64x_si64 (long long __i)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pi64x (long long __i)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_si32 (__m64 __i)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_to_int (__m64 __i)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_to_int64 (__m64 __i)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtm64_si64 (__m64 __i)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_si64x (__m64 __i)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packs_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_packsswb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packs_pi32 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_packssdw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packs_pu16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_packuswb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpckhbw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpckhwd (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_pi32 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpckhdq (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpcklbw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpcklwd (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_pi32 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpckldq (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_pi32 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddd (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_si64 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddsb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddsw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_pu8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddusb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_pu16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddusw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_pi32 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubd (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_si64 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubsb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubsw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_pu8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubusb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_pu16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubusw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_madd_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmaddwd (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mulhi_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmulhw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mullo_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmullw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_pi16 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psllw (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_pi16 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psllwi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_pi32 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pslld (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_pi32 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pslldi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_si64 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psllq (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_si64 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psllqi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sra_pi16 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psraw (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srai_pi16 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrawi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sra_pi32 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrad (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srai_pi32 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psradi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_pi16 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrlw (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_pi16 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrlwi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_pi32 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrld (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_pi32 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrldi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_si64 (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrlq (__m64 __m, __m64 __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_si64 (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrlqi (__m64 __m, int __count)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_and_si64 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pand (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_andnot_si64 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pandn (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_or_si64 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_por (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_xor_si64 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pxor (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpeqb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_pi8 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpgtb (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpeqw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_pi16 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpgtw (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_pi32 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpeqd (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_pi32 (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpgtd (__m64 __m1, __m64 __m2)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setzero_si64 (void)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pi32 (int __i1, int __i0)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pi16 (short __w3, short __w2, short __w1, short __w0)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pi8 (char __b7, char __b6, char __b5, char __b4,
char __b3, char __b2, char __b1, char __b0)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_pi32 (int __i0, int __i1)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_pi16 (short __w0, short __w1, short __w2, short __w3)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_pi8 (char __b0, char __b1, char __b2, char __b3,
char __b4, char __b5, char __b6, char __b7)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_pi32 (int __i)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_pi16 (short __w)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_pi8 (char __b)
;
#define _XMMINTRIN_H_INCLUDED
#define _MM_MALLOC_H_INCLUDED
extern "C" int posix_memalign (void **, size_t, size_t) throw ();
static void *
_mm_malloc (size_t size, size_t alignment)
;
static void
_mm_free (void * ptr)
;
enum _mm_hint
{
_MM_HINT_ET0 = 7,
_MM_HINT_ET1 = 6,
_MM_HINT_T0 = 3,
_MM_HINT_T1 = 2,
_MM_HINT_T2 = 1,
_MM_HINT_NTA = 0
};
#define _mm_prefetch(P,I) __builtin_prefetch ((P), ((I & 0x4) >> 2), (I & 0x3))
typedef float __m128 __attribute__ ((__vector_size__ (16), __may_alias__));
typedef float __v4sf __attribute__ ((__vector_size__ (16)));
#define _MM_SHUFFLE(fp3,fp2,fp1,fp0) (((fp3) << 6) | ((fp2) << 4) | ((fp1) << 2) | (fp0))
#define _MM_EXCEPT_MASK 0x003f
#define _MM_EXCEPT_INVALID 0x0001
#define _MM_EXCEPT_DENORM 0x0002
#define _MM_EXCEPT_DIV_ZERO 0x0004
#define _MM_EXCEPT_OVERFLOW 0x0008
#define _MM_EXCEPT_UNDERFLOW 0x0010
#define _MM_EXCEPT_INEXACT 0x0020
#define _MM_MASK_MASK 0x1f80
#define _MM_MASK_INVALID 0x0080
#define _MM_MASK_DENORM 0x0100
#define _MM_MASK_DIV_ZERO 0x0200
#define _MM_MASK_OVERFLOW 0x0400
#define _MM_MASK_UNDERFLOW 0x0800
#define _MM_MASK_INEXACT 0x1000
#define _MM_ROUND_MASK 0x6000
#define _MM_ROUND_NEAREST 0x0000
#define _MM_ROUND_DOWN 0x2000
#define _MM_ROUND_UP 0x4000
#define _MM_ROUND_TOWARD_ZERO 0x6000
#define _MM_FLUSH_ZERO_MASK 0x8000
#define _MM_FLUSH_ZERO_ON 0x8000
#define _MM_FLUSH_ZERO_OFF 0x0000
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_undefined_ps (void)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setzero_ps (void)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_div_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sqrt_ss (__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rcp_ss (__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rsqrt_ss (__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_div_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sqrt_ps (__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rcp_ps (__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rsqrt_ps (__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_and_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_andnot_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_or_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_xor_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmple_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpge_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpneq_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnlt_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnle_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpngt_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnge_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpord_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpunord_ss (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmple_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpge_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpneq_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnlt_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnle_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpngt_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnge_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpord_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpunord_ps (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comieq_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comilt_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comile_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comigt_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comige_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comineq_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomieq_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomilt_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomile_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomigt_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomige_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomineq_ss (__m128 __A, __m128 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_si32 (__m128 __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvt_ss2si (__m128 __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_si64 (__m128 __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_si64x (__m128 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtps_pi32 (__m128 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvt_ps2pi (__m128 __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_si32 (__m128 __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtt_ss2si (__m128 __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_si64 (__m128 __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_si64x (__m128 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttps_pi32 (__m128 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtt_ps2pi (__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi32_ss (__m128 __A, int __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvt_si2ss (__m128 __A, int __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_ss (__m128 __A, long long __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64x_ss (__m128 __A, long long __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpi32_ps (__m128 __A, __m64 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvt_pi2ps (__m128 __A, __m64 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpi16_ps (__m64 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpu16_ps (__m64 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpi8_ps (__m64 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpu8_ps(__m64 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpi32x2_ps(__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtps_pi16(__m128 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtps_pi8(__m128 __A)
;
#define _mm_shuffle_ps(A,B,MASK) ((__m128) __builtin_ia32_shufps ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(MASK)))
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadh_pi (__m128 __A, __m64 const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storeh_pi (__m64 *__P, __m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movehl_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movelh_ps (__m128 __A, __m128 __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadl_pi (__m128 __A, __m64 const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storel_pi (__m64 *__P, __m128 __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movemask_ps (__m128 __A)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_getcsr (void)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_GET_EXCEPTION_STATE (void)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_GET_EXCEPTION_MASK (void)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_GET_ROUNDING_MODE (void)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_GET_FLUSH_ZERO_MODE (void)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setcsr (unsigned int __I)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_SET_EXCEPTION_STATE(unsigned int __mask)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_SET_EXCEPTION_MASK (unsigned int __mask)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_SET_ROUNDING_MODE (unsigned int __mode)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_SET_FLUSH_ZERO_MODE (unsigned int __mode)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_ss (float __F)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_ps (float __F)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_ps1 (float __F)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_ss (float const *__P)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load1_ps (float const *__P)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_ps1 (float const *__P)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_ps (float const *__P)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadu_ps (float const *__P)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadr_ps (float const *__P)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_ps (const float __Z, const float __Y, const float __X, const float __W)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_ps (float __Z, float __Y, float __X, float __W)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_ss (float *__P, __m128 __A)
;
extern float __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_f32 (__m128 __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_ps (float *__P, __m128 __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storeu_ps (float *__P, __m128 __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store1_ps (float *__P, __m128 __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_ps1 (float *__P, __m128 __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storer_ps (float *__P, __m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_move_ss (__m128 __A, __m128 __B)
;
#define _mm_extract_pi16(A,N) ((int) __builtin_ia32_vec_ext_v4hi ((__v4hi)(__m64)(A), (int)(N)))
#define _m_pextrw(A,N) _mm_extract_pi16(A, N)
#define _mm_insert_pi16(A,D,N) ((__m64) __builtin_ia32_vec_set_v4hi ((__v4hi)(__m64)(A), (int)(D), (int)(N)))
#define _m_pinsrw(A,D,N) _mm_insert_pi16(A, D, N)
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_pi16 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmaxsw (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_pu8 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmaxub (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_pi16 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pminsw (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_pu8 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pminub (__m64 __A, __m64 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movemask_pi8 (__m64 __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmovmskb (__m64 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mulhi_pu16 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmulhuw (__m64 __A, __m64 __B)
;
#define _mm_shuffle_pi16(A,N) ((__m64) __builtin_ia32_pshufw ((__v4hi)(__m64)(A), (int)(N)))
#define _m_pshufw(A,N) _mm_shuffle_pi16 (A, N)
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskmove_si64 (__m64 __A, __m64 __N, char *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_maskmovq (__m64 __A, __m64 __N, char *__P)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_avg_pu8 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pavgb (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_avg_pu16 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pavgw (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sad_pu8 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psadbw (__m64 __A, __m64 __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_pi (__m64 *__P, __m64 __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_ps (float *__P, __m128 __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sfence (void)
;
#define _MM_TRANSPOSE4_PS(row0,row1,row2,row3) do { __v4sf __r0 = (row0), __r1 = (row1), __r2 = (row2), __r3 = (row3); __v4sf __t0 = __builtin_ia32_unpcklps (__r0, __r1); __v4sf __t1 = __builtin_ia32_unpcklps (__r2, __r3); __v4sf __t2 = __builtin_ia32_unpckhps (__r0, __r1); __v4sf __t3 = __builtin_ia32_unpckhps (__r2, __r3); (row0) = __builtin_ia32_movlhps (__t0, __t1); (row1) = __builtin_ia32_movhlps (__t1, __t0); (row2) = __builtin_ia32_movlhps (__t2, __t3); (row3) = __builtin_ia32_movhlps (__t3, __t2); } while (0)
#define _EMMINTRIN_H_INCLUDED
typedef double __v2df __attribute__ ((__vector_size__ (16)));
typedef long long __v2di __attribute__ ((__vector_size__ (16)));
typedef int __v4si __attribute__ ((__vector_size__ (16)));
typedef short __v8hi __attribute__ ((__vector_size__ (16)));
typedef char __v16qi __attribute__ ((__vector_size__ (16)));
typedef long long __m128i __attribute__ ((__vector_size__ (16), __may_alias__));
typedef double __m128d __attribute__ ((__vector_size__ (16), __may_alias__));
#define _MM_SHUFFLE2(fp1,fp0) (((fp1) << 1) | (fp0))
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_sd (double __F)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_pd (double __F)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pd1 (double __F)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pd (double __W, double __X)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_pd (double __W, double __X)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_undefined_pd (void)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setzero_pd (void)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_move_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_pd (double const *__P)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadu_pd (double const *__P)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load1_pd (double const *__P)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_sd (double const *__P)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_pd1 (double const *__P)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadr_pd (double const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_pd (double *__P, __m128d __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storeu_pd (double *__P, __m128d __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_sd (double *__P, __m128d __A)
;
extern double __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_f64 (__m128d __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storel_pd (double *__P, __m128d __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storeh_pd (double *__P, __m128d __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store1_pd (double *__P, __m128d __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_pd1 (double *__P, __m128d __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storer_pd (double *__P, __m128d __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi128_si32 (__m128i __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi128_si64 (__m128i __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi128_si64x (__m128i __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_div_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_div_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sqrt_pd (__m128d __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sqrt_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_and_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_andnot_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_or_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_xor_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmple_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpge_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpneq_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnlt_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnle_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpngt_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnge_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpord_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpunord_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmple_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpge_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpneq_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnlt_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnle_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpngt_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnge_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpord_sd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpunord_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comieq_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comilt_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comile_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comigt_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comige_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comineq_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomieq_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomilt_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomile_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomigt_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomige_sd (__m128d __A, __m128d __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomineq_sd (__m128d __A, __m128d __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_epi64x (long long __q1, long long __q0)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_epi64 (__m64 __q1, __m64 __q0)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_epi32 (int __q3, int __q2, int __q1, int __q0)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_epi16 (short __q7, short __q6, short __q5, short __q4,
short __q3, short __q2, short __q1, short __q0)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_epi8 (char __q15, char __q14, char __q13, char __q12,
char __q11, char __q10, char __q09, char __q08,
char __q07, char __q06, char __q05, char __q04,
char __q03, char __q02, char __q01, char __q00)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_epi64x (long long __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_epi64 (__m64 __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_epi32 (int __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_epi16 (short __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_epi8 (char __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_epi64 (__m64 __q0, __m64 __q1)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_epi32 (int __q0, int __q1, int __q2, int __q3)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_epi16 (short __q0, short __q1, short __q2, short __q3,
short __q4, short __q5, short __q6, short __q7)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_epi8 (char __q00, char __q01, char __q02, char __q03,
char __q04, char __q05, char __q06, char __q07,
char __q08, char __q09, char __q10, char __q11,
char __q12, char __q13, char __q14, char __q15)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_si128 (__m128i const *__P)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadu_si128 (__m128i const *__P)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadl_epi64 (__m128i const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_si128 (__m128i *__P, __m128i __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storeu_si128 (__m128i *__P, __m128i __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storel_epi64 (__m128i *__P, __m128i __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movepi64_pi64 (__m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movpi64_epi64 (__m64 __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_move_epi64 (__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_undefined_si128 (void)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setzero_si128 (void)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi32_pd (__m128i __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi32_ps (__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpd_epi32 (__m128d __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpd_pi32 (__m128d __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpd_ps (__m128d __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttpd_epi32 (__m128d __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttpd_pi32 (__m128d __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpi32_pd (__m64 __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtps_epi32 (__m128 __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttps_epi32 (__m128 __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtps_pd (__m128 __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_si32 (__m128d __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_si64 (__m128d __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_si64x (__m128d __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_si32 (__m128d __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_si64 (__m128d __A)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_si64x (__m128d __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_ss (__m128 __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi32_sd (__m128d __A, int __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_sd (__m128d __A, long long __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64x_sd (__m128d __A, long long __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_sd (__m128d __A, __m128 __B)
;
#define _mm_shuffle_pd(A,B,N) ((__m128d)__builtin_ia32_shufpd ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(N)))
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_pd (__m128d __A, __m128d __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadh_pd (__m128d __A, double const *__B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadl_pd (__m128d __A, double const *__B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movemask_pd (__m128d __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packs_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packs_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packus_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_epi64 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_epi64 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_epi64 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_epu8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_epu16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_epi64 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_epu8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_epu16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_madd_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mulhi_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mullo_epi16 (__m128i __A, __m128i __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_su32 (__m64 __A, __m64 __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_epu32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_epi16 (__m128i __A, int __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_epi32 (__m128i __A, int __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_epi64 (__m128i __A, int __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srai_epi16 (__m128i __A, int __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srai_epi32 (__m128i __A, int __B)
;
#define _mm_srli_si128(A,N) ((__m128i)__builtin_ia32_psrldqi128 ((__m128i)(A), (int)(N) * 8))
#define _mm_slli_si128(A,N) ((__m128i)__builtin_ia32_pslldqi128 ((__m128i)(A), (int)(N) * 8))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_epi16 (__m128i __A, int __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_epi32 (__m128i __A, int __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_epi64 (__m128i __A, int __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_epi64 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sra_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sra_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_epi64 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_and_si128 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_andnot_si128 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_or_si128 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_xor_si128 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_epi32 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_epi8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_epi32 (__m128i __A, __m128i __B)
;
#define _mm_extract_epi16(A,N) ((int) (unsigned short) __builtin_ia32_vec_ext_v8hi ((__v8hi)(__m128i)(A), (int)(N)))
#define _mm_insert_epi16(A,D,N) ((__m128i) __builtin_ia32_vec_set_v8hi ((__v8hi)(__m128i)(A), (int)(D), (int)(N)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_epu8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_epi16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_epu8 (__m128i __A, __m128i __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movemask_epi8 (__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mulhi_epu16 (__m128i __A, __m128i __B)
;
#define _mm_shufflehi_epi16(A,N) ((__m128i)__builtin_ia32_pshufhw ((__v8hi)(__m128i)(A), (int)(N)))
#define _mm_shufflelo_epi16(A,N) ((__m128i)__builtin_ia32_pshuflw ((__v8hi)(__m128i)(A), (int)(N)))
#define _mm_shuffle_epi32(A,N) ((__m128i)__builtin_ia32_pshufd ((__v4si)(__m128i)(A), (int)(N)))
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskmoveu_si128 (__m128i __A, __m128i __B, char *__C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_avg_epu8 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_avg_epu16 (__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sad_epu8 (__m128i __A, __m128i __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_si32 (int *__A, int __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_si64 (long long int *__A, long long int __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_si128 (__m128i *__A, __m128i __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_pd (double *__A, __m128d __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_clflush (void const *__A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_lfence (void)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mfence (void)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi32_si128 (int __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_si128 (long long __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64x_si128 (long long __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castpd_ps(__m128d __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castpd_si128(__m128d __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castps_pd(__m128 __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castps_si128(__m128 __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castsi128_ps(__m128i __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castsi128_pd(__m128i __A)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_pause (void)
;
#define _PMMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("sse3")
#define __DISABLE_SSE3__
#define _MM_DENORMALS_ZERO_MASK 0x0040
#define _MM_DENORMALS_ZERO_ON 0x0040
#define _MM_DENORMALS_ZERO_OFF 0x0000
#define _MM_SET_DENORMALS_ZERO_MODE(mode) _mm_setcsr ((_mm_getcsr () & ~_MM_DENORMALS_ZERO_MASK) | (mode))
#define _MM_GET_DENORMALS_ZERO_MODE() (_mm_getcsr() & _MM_DENORMALS_ZERO_MASK)
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_addsub_ps (__m128 __X, __m128 __Y)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadd_ps (__m128 __X, __m128 __Y)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsub_ps (__m128 __X, __m128 __Y)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movehdup_ps (__m128 __X)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_moveldup_ps (__m128 __X)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_addsub_pd (__m128d __X, __m128d __Y)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadd_pd (__m128d __X, __m128d __Y)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsub_pd (__m128d __X, __m128d __Y)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loaddup_pd (double const *__P)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movedup_pd (__m128d __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_lddqu_si128 (__m128i const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_monitor (void const * __P, unsigned int __E, unsigned int __H)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mwait (unsigned int __E, unsigned int __H)
;
#undef __DISABLE_SSE3__
#pragma GCC pop_options
#define _TMMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("ssse3")
#define __DISABLE_SSSE3__
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadd_epi16 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadd_epi32 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadds_epi16 (__m128i __X, __m128i __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadd_pi16 (__m64 __X, __m64 __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadd_pi32 (__m64 __X, __m64 __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hadds_pi16 (__m64 __X, __m64 __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsub_epi16 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsub_epi32 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsubs_epi16 (__m128i __X, __m128i __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsub_pi16 (__m64 __X, __m64 __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsub_pi32 (__m64 __X, __m64 __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsubs_pi16 (__m64 __X, __m64 __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maddubs_epi16 (__m128i __X, __m128i __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maddubs_pi16 (__m64 __X, __m64 __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mulhrs_epi16 (__m128i __X, __m128i __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mulhrs_pi16 (__m64 __X, __m64 __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shuffle_epi8 (__m128i __X, __m128i __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shuffle_pi8 (__m64 __X, __m64 __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sign_epi8 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sign_epi16 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sign_epi32 (__m128i __X, __m128i __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sign_pi8 (__m64 __X, __m64 __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sign_pi16 (__m64 __X, __m64 __Y)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sign_pi32 (__m64 __X, __m64 __Y)
;
#define _mm_alignr_epi8(X,Y,N) ((__m128i) __builtin_ia32_palignr128 ((__v2di)(__m128i)(X), (__v2di)(__m128i)(Y), (int)(N) * 8))
#define _mm_alignr_pi8(X,Y,N) ((__m64) __builtin_ia32_palignr ((__v1di)(__m64)(X), (__v1di)(__m64)(Y), (int)(N) * 8))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_abs_epi8 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_abs_epi16 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_abs_epi32 (__m128i __X)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_abs_pi8 (__m64 __X)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_abs_pi16 (__m64 __X)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_abs_pi32 (__m64 __X)
;
#undef __DISABLE_SSSE3__
#pragma GCC pop_options
#define _AMMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("sse4a")
#define __DISABLE_SSE4A__
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_sd (double * __P, __m128d __Y)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_ss (float * __P, __m128 __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_extract_si64 (__m128i __X, __m128i __Y)
;
#define _mm_extracti_si64(X,I,L) ((__m128i) __builtin_ia32_extrqi ((__v2di)(__m128i)(X), (unsigned int)(I), (unsigned int)(L)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_insert_si64 (__m128i __X,__m128i __Y)
;
#define _mm_inserti_si64(X,Y,I,L) ((__m128i) __builtin_ia32_insertqi ((__v2di)(__m128i)(X), (__v2di)(__m128i)(Y), (unsigned int)(I), (unsigned int)(L)))
#undef __DISABLE_SSE4A__
#pragma GCC pop_options
#define _SMMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("sse4.1")
#define __DISABLE_SSE4_1__
#define _MM_FROUND_TO_NEAREST_INT 0x00
#define _MM_FROUND_TO_NEG_INF 0x01
#define _MM_FROUND_TO_POS_INF 0x02
#define _MM_FROUND_TO_ZERO 0x03
#define _MM_FROUND_CUR_DIRECTION 0x04
#define _MM_FROUND_RAISE_EXC 0x00
#define _MM_FROUND_NO_EXC 0x08
#define _MM_FROUND_NINT (_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_RAISE_EXC)
#define _MM_FROUND_FLOOR (_MM_FROUND_TO_NEG_INF | _MM_FROUND_RAISE_EXC)
#define _MM_FROUND_CEIL (_MM_FROUND_TO_POS_INF | _MM_FROUND_RAISE_EXC)
#define _MM_FROUND_TRUNC (_MM_FROUND_TO_ZERO | _MM_FROUND_RAISE_EXC)
#define _MM_FROUND_RINT (_MM_FROUND_CUR_DIRECTION | _MM_FROUND_RAISE_EXC)
#define _MM_FROUND_NEARBYINT (_MM_FROUND_CUR_DIRECTION | _MM_FROUND_NO_EXC)
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testz_si128 (__m128i __M, __m128i __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testc_si128 (__m128i __M, __m128i __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testnzc_si128 (__m128i __M, __m128i __V)
;
#define _mm_test_all_zeros(M,V) _mm_testz_si128 ((M), (V))
#define _mm_test_all_ones(V) _mm_testc_si128 ((V), _mm_cmpeq_epi32 ((V), (V)))
#define _mm_test_mix_ones_zeros(M,V) _mm_testnzc_si128 ((M), (V))
#define _mm_round_pd(V,M) ((__m128d) __builtin_ia32_roundpd ((__v2df)(__m128d)(V), (int)(M)))
#define _mm_round_sd(D,V,M) ((__m128d) __builtin_ia32_roundsd ((__v2df)(__m128d)(D), (__v2df)(__m128d)(V), (int)(M)))
#define _mm_round_ps(V,M) ((__m128) __builtin_ia32_roundps ((__v4sf)(__m128)(V), (int)(M)))
#define _mm_round_ss(D,V,M) ((__m128) __builtin_ia32_roundss ((__v4sf)(__m128)(D), (__v4sf)(__m128)(V), (int)(M)))
#define _mm_ceil_pd(V) _mm_round_pd ((V), _MM_FROUND_CEIL)
#define _mm_ceil_sd(D,V) _mm_round_sd ((D), (V), _MM_FROUND_CEIL)
#define _mm_floor_pd(V) _mm_round_pd((V), _MM_FROUND_FLOOR)
#define _mm_floor_sd(D,V) _mm_round_sd ((D), (V), _MM_FROUND_FLOOR)
#define _mm_ceil_ps(V) _mm_round_ps ((V), _MM_FROUND_CEIL)
#define _mm_ceil_ss(D,V) _mm_round_ss ((D), (V), _MM_FROUND_CEIL)
#define _mm_floor_ps(V) _mm_round_ps ((V), _MM_FROUND_FLOOR)
#define _mm_floor_ss(D,V) _mm_round_ss ((D), (V), _MM_FROUND_FLOOR)
#define _mm_blend_epi16(X,Y,M) ((__m128i) __builtin_ia32_pblendw128 ((__v8hi)(__m128i)(X), (__v8hi)(__m128i)(Y), (int)(M)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_blendv_epi8 (__m128i __X, __m128i __Y, __m128i __M)
;
#define _mm_blend_ps(X,Y,M) ((__m128) __builtin_ia32_blendps ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(M)))
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_blendv_ps (__m128 __X, __m128 __Y, __m128 __M)
;
#define _mm_blend_pd(X,Y,M) ((__m128d) __builtin_ia32_blendpd ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(M)))
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_blendv_pd (__m128d __X, __m128d __Y, __m128d __M)
;
#define _mm_dp_ps(X,Y,M) ((__m128) __builtin_ia32_dpps ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(M)))
#define _mm_dp_pd(X,Y,M) ((__m128d) __builtin_ia32_dppd ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(M)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_epi64 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_epi8 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_epi8 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_epu16 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_epu16 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_epi32 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_epi32 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_epu32 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_epu32 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mullo_epi32 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_epi32 (__m128i __X, __m128i __Y)
;
#define _mm_insert_ps(D,S,N) ((__m128) __builtin_ia32_insertps128 ((__v4sf)(__m128)(D), (__v4sf)(__m128)(S), (int)(N)))
#define _MM_MK_INSERTPS_NDX(S,D,M) (((S) << 6) | ((D) << 4) | (M))
#define _mm_extract_ps(X,N) (__extension__ ({ union { int i; float f; } __tmp; __tmp.f = __builtin_ia32_vec_ext_v4sf ((__v4sf)(__m128)(X), (int)(N)); __tmp.i; }))
#define _MM_EXTRACT_FLOAT(D,S,N) { (D) = __builtin_ia32_vec_ext_v4sf ((__v4sf)(S), (N)); }
#define _MM_PICK_OUT_PS(X,N) _mm_insert_ps (_mm_setzero_ps (), (X), _MM_MK_INSERTPS_NDX ((N), 0, 0x0e))
#define _mm_insert_epi8(D,S,N) ((__m128i) __builtin_ia32_vec_set_v16qi ((__v16qi)(__m128i)(D), (int)(S), (int)(N)))
#define _mm_insert_epi32(D,S,N) ((__m128i) __builtin_ia32_vec_set_v4si ((__v4si)(__m128i)(D), (int)(S), (int)(N)))
#define _mm_insert_epi64(D,S,N) ((__m128i) __builtin_ia32_vec_set_v2di ((__v2di)(__m128i)(D), (long long)(S), (int)(N)))
#define _mm_extract_epi8(X,N) ((int) (unsigned char) __builtin_ia32_vec_ext_v16qi ((__v16qi)(__m128i)(X), (int)(N)))
#define _mm_extract_epi32(X,N) ((int) __builtin_ia32_vec_ext_v4si ((__v4si)(__m128i)(X), (int)(N)))
#define _mm_extract_epi64(X,N) ((long long) __builtin_ia32_vec_ext_v2di ((__v2di)(__m128i)(X), (int)(N)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_minpos_epu16 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi8_epi32 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi16_epi32 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi8_epi64 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi32_epi64 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi16_epi64 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi8_epi16 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepu8_epi32 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepu16_epi32 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepu8_epi64 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepu32_epi64 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepu16_epi64 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepu8_epi16 (__m128i __X)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packus_epi32 (__m128i __X, __m128i __Y)
;
#define _mm_mpsadbw_epu8(X,Y,M) ((__m128i) __builtin_ia32_mpsadbw128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_load_si128 (__m128i *__X)
;
#pragma GCC push_options
#pragma GCC target("sse4.2")
#define __DISABLE_SSE4_2__
#define _SIDD_UBYTE_OPS 0x00
#define _SIDD_UWORD_OPS 0x01
#define _SIDD_SBYTE_OPS 0x02
#define _SIDD_SWORD_OPS 0x03
#define _SIDD_CMP_EQUAL_ANY 0x00
#define _SIDD_CMP_RANGES 0x04
#define _SIDD_CMP_EQUAL_EACH 0x08
#define _SIDD_CMP_EQUAL_ORDERED 0x0c
#define _SIDD_POSITIVE_POLARITY 0x00
#define _SIDD_NEGATIVE_POLARITY 0x10
#define _SIDD_MASKED_POSITIVE_POLARITY 0x20
#define _SIDD_MASKED_NEGATIVE_POLARITY 0x30
#define _SIDD_LEAST_SIGNIFICANT 0x00
#define _SIDD_MOST_SIGNIFICANT 0x40
#define _SIDD_BIT_MASK 0x00
#define _SIDD_UNIT_MASK 0x40
#define _mm_cmpistrm(X,Y,M) ((__m128i) __builtin_ia32_pcmpistrm128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
#define _mm_cmpistri(X,Y,M) ((int) __builtin_ia32_pcmpistri128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
#define _mm_cmpestrm(X,LX,Y,LY,M) ((__m128i) __builtin_ia32_pcmpestrm128 ((__v16qi)(__m128i)(X), (int)(LX), (__v16qi)(__m128i)(Y), (int)(LY), (int)(M)))
#define _mm_cmpestri(X,LX,Y,LY,M) ((int) __builtin_ia32_pcmpestri128 ((__v16qi)(__m128i)(X), (int)(LX), (__v16qi)(__m128i)(Y), (int)(LY), (int)(M)))
#define _mm_cmpistra(X,Y,M) ((int) __builtin_ia32_pcmpistria128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
#define _mm_cmpistrc(X,Y,M) ((int) __builtin_ia32_pcmpistric128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
#define _mm_cmpistro(X,Y,M) ((int) __builtin_ia32_pcmpistrio128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
#define _mm_cmpistrs(X,Y,M) ((int) __builtin_ia32_pcmpistris128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
#define _mm_cmpistrz(X,Y,M) ((int) __builtin_ia32_pcmpistriz128 ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(M)))
#define _mm_cmpestra(X,LX,Y,LY,M) ((int) __builtin_ia32_pcmpestria128 ((__v16qi)(__m128i)(X), (int)(LX), (__v16qi)(__m128i)(Y), (int)(LY), (int)(M)))
#define _mm_cmpestrc(X,LX,Y,LY,M) ((int) __builtin_ia32_pcmpestric128 ((__v16qi)(__m128i)(X), (int)(LX), (__v16qi)(__m128i)(Y), (int)(LY), (int)(M)))
#define _mm_cmpestro(X,LX,Y,LY,M) ((int) __builtin_ia32_pcmpestrio128 ((__v16qi)(__m128i)(X), (int)(LX), (__v16qi)(__m128i)(Y), (int)(LY), (int)(M)))
#define _mm_cmpestrs(X,LX,Y,LY,M) ((int) __builtin_ia32_pcmpestris128 ((__v16qi)(__m128i)(X), (int)(LX), (__v16qi)(__m128i)(Y), (int)(LY), (int)(M)))
#define _mm_cmpestrz(X,LX,Y,LY,M) ((int) __builtin_ia32_pcmpestriz128 ((__v16qi)(__m128i)(X), (int)(LX), (__v16qi)(__m128i)(Y), (int)(LY), (int)(M)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_epi64 (__m128i __X, __m128i __Y)
;
#undef __DISABLE_SSE4_2__
#pragma GCC pop_options
#undef __DISABLE_SSE4_1__
#pragma GCC pop_options
#define _POPCNTINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("popcnt")
#define __DISABLE_POPCNT__
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_popcnt_u32 (unsigned int __X)
;
extern long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_popcnt_u64 (unsigned long long __X)
;
#undef __DISABLE_POPCNT__
#pragma GCC pop_options
#pragma GCC push_options
#pragma GCC target("sse4.1")
#define __DISABLE_SSE4_1__
#pragma GCC push_options
#pragma GCC target("sse4.2")
#define __DISABLE_SSE4_2__
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_crc32_u8 (unsigned int __C, unsigned char __V)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_crc32_u16 (unsigned int __C, unsigned short __V)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_crc32_u32 (unsigned int __C, unsigned int __V)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_crc32_u64 (unsigned long long __C, unsigned long long __V)
;
#undef __DISABLE_SSE4_2__
#pragma GCC pop_options
#undef __DISABLE_SSE4_1__
#pragma GCC pop_options
#define _WMMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("aes")
#define __DISABLE_AES__
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_aesdec_si128 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_aesdeclast_si128 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_aesenc_si128 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_aesenclast_si128 (__m128i __X, __m128i __Y)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_aesimc_si128 (__m128i __X)
;
#define _mm_aeskeygenassist_si128(X,C) ((__m128i) __builtin_ia32_aeskeygenassist128 ((__v2di)(__m128i)(X), (int)(C)))
#undef __DISABLE_AES__
#pragma GCC pop_options
#pragma GCC push_options
#pragma GCC target("pclmul")
#define __DISABLE_PCLMUL__
#define _mm_clmulepi64_si128(X,Y,I) ((__m128i) __builtin_ia32_pclmulqdq128 ((__v2di)(__m128i)(X), (__v2di)(__m128i)(Y), (int)(I)))
#undef __DISABLE_PCLMUL__
#pragma GCC pop_options
#define _IMMINTRIN_H_INCLUDED
#define _AVXINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("avx")
#define __DISABLE_AVX__
typedef double __v4df __attribute__ ((__vector_size__ (32)));
typedef float __v8sf __attribute__ ((__vector_size__ (32)));
typedef long long __v4di __attribute__ ((__vector_size__ (32)));
typedef int __v8si __attribute__ ((__vector_size__ (32)));
typedef short __v16hi __attribute__ ((__vector_size__ (32)));
typedef char __v32qi __attribute__ ((__vector_size__ (32)));
typedef float __m256 __attribute__ ((__vector_size__ (32),
__may_alias__));
typedef long long __m256i __attribute__ ((__vector_size__ (32),
__may_alias__));
typedef double __m256d __attribute__ ((__vector_size__ (32),
__may_alias__));
#define _CMP_EQ_OQ 0x00
#define _CMP_LT_OS 0x01
#define _CMP_LE_OS 0x02
#define _CMP_UNORD_Q 0x03
#define _CMP_NEQ_UQ 0x04
#define _CMP_NLT_US 0x05
#define _CMP_NLE_US 0x06
#define _CMP_ORD_Q 0x07
#define _CMP_EQ_UQ 0x08
#define _CMP_NGE_US 0x09
#define _CMP_NGT_US 0x0a
#define _CMP_FALSE_OQ 0x0b
#define _CMP_NEQ_OQ 0x0c
#define _CMP_GE_OS 0x0d
#define _CMP_GT_OS 0x0e
#define _CMP_TRUE_UQ 0x0f
#define _CMP_EQ_OS 0x10
#define _CMP_LT_OQ 0x11
#define _CMP_LE_OQ 0x12
#define _CMP_UNORD_S 0x13
#define _CMP_NEQ_US 0x14
#define _CMP_NLT_UQ 0x15
#define _CMP_NLE_UQ 0x16
#define _CMP_ORD_S 0x17
#define _CMP_EQ_US 0x18
#define _CMP_NGE_UQ 0x19
#define _CMP_NGT_UQ 0x1a
#define _CMP_FALSE_OS 0x1b
#define _CMP_NEQ_OS 0x1c
#define _CMP_GE_OQ 0x1d
#define _CMP_GT_OQ 0x1e
#define _CMP_TRUE_US 0x1f
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_add_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_add_ps (__m256 __A, __m256 __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_addsub_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_addsub_ps (__m256 __A, __m256 __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_and_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_and_ps (__m256 __A, __m256 __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_andnot_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_andnot_ps (__m256 __A, __m256 __B)
;
#define _mm256_blend_pd(X,Y,M) ((__m256d) __builtin_ia32_blendpd256 ((__v4df)(__m256d)(X), (__v4df)(__m256d)(Y), (int)(M)))
#define _mm256_blend_ps(X,Y,M) ((__m256) __builtin_ia32_blendps256 ((__v8sf)(__m256)(X), (__v8sf)(__m256)(Y), (int)(M)))
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_blendv_pd (__m256d __X, __m256d __Y, __m256d __M)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_blendv_ps (__m256 __X, __m256 __Y, __m256 __M)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_div_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_div_ps (__m256 __A, __m256 __B)
;
#define _mm256_dp_ps(X,Y,M) ((__m256) __builtin_ia32_dpps256 ((__v8sf)(__m256)(X), (__v8sf)(__m256)(Y), (int)(M)))
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hadd_pd (__m256d __X, __m256d __Y)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hadd_ps (__m256 __X, __m256 __Y)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hsub_pd (__m256d __X, __m256d __Y)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hsub_ps (__m256 __X, __m256 __Y)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_ps (__m256 __A, __m256 __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_ps (__m256 __A, __m256 __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mul_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mul_ps (__m256 __A, __m256 __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_or_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_or_ps (__m256 __A, __m256 __B)
;
#define _mm256_shuffle_pd(A,B,N) ((__m256d)__builtin_ia32_shufpd256 ((__v4df)(__m256d)(A), (__v4df)(__m256d)(B), (int)(N)))
#define _mm256_shuffle_ps(A,B,N) ((__m256) __builtin_ia32_shufps256 ((__v8sf)(__m256)(A), (__v8sf)(__m256)(B), (int)(N)))
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sub_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sub_ps (__m256 __A, __m256 __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_xor_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_xor_ps (__m256 __A, __m256 __B)
;
#define _mm_cmp_pd(X,Y,P) ((__m128d) __builtin_ia32_cmppd ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P)))
#define _mm_cmp_ps(X,Y,P) ((__m128) __builtin_ia32_cmpps ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P)))
#define _mm256_cmp_pd(X,Y,P) ((__m256d) __builtin_ia32_cmppd256 ((__v4df)(__m256d)(X), (__v4df)(__m256d)(Y), (int)(P)))
#define _mm256_cmp_ps(X,Y,P) ((__m256) __builtin_ia32_cmpps256 ((__v8sf)(__m256)(X), (__v8sf)(__m256)(Y), (int)(P)))
#define _mm_cmp_sd(X,Y,P) ((__m128d) __builtin_ia32_cmpsd ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P)))
#define _mm_cmp_ss(X,Y,P) ((__m128) __builtin_ia32_cmpss ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P)))
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi32_pd (__m128i __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi32_ps (__m256i __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtpd_ps (__m256d __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtps_epi32 (__m256 __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtps_pd (__m128 __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvttpd_epi32 (__m256d __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtpd_epi32 (__m256d __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvttps_epi32 (__m256 __A)
;
#define _mm256_extractf128_pd(X,N) ((__m128d) __builtin_ia32_vextractf128_pd256 ((__v4df)(__m256d)(X), (int)(N)))
#define _mm256_extractf128_ps(X,N) ((__m128) __builtin_ia32_vextractf128_ps256 ((__v8sf)(__m256)(X), (int)(N)))
#define _mm256_extractf128_si256(X,N) ((__m128i) __builtin_ia32_vextractf128_si256 ((__v8si)(__m256i)(X), (int)(N)))
#define _mm256_extract_epi32(X,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 2); _mm_extract_epi32 (__Y, (N) % 4); }))
#define _mm256_extract_epi16(X,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 3); _mm_extract_epi16 (__Y, (N) % 8); }))
#define _mm256_extract_epi8(X,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 4); _mm_extract_epi8 (__Y, (N) % 16); }))
#define _mm256_extract_epi64(X,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 1); _mm_extract_epi64 (__Y, (N) % 2); }))
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_zeroall (void)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_zeroupper (void)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_permutevar_pd (__m128d __A, __m128i __C)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_permutevar_pd (__m256d __A, __m256i __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_permutevar_ps (__m128 __A, __m128i __C)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_permutevar_ps (__m256 __A, __m256i __C)
;
#define _mm_permute_pd(X,C) ((__m128d) __builtin_ia32_vpermilpd ((__v2df)(__m128d)(X), (int)(C)))
#define _mm256_permute_pd(X,C) ((__m256d) __builtin_ia32_vpermilpd256 ((__v4df)(__m256d)(X), (int)(C)))
#define _mm_permute_ps(X,C) ((__m128) __builtin_ia32_vpermilps ((__v4sf)(__m128)(X), (int)(C)))
#define _mm256_permute_ps(X,C) ((__m256) __builtin_ia32_vpermilps256 ((__v8sf)(__m256)(X), (int)(C)))
#define _mm256_permute2f128_pd(X,Y,C) ((__m256d) __builtin_ia32_vperm2f128_pd256 ((__v4df)(__m256d)(X), (__v4df)(__m256d)(Y), (int)(C)))
#define _mm256_permute2f128_ps(X,Y,C) ((__m256) __builtin_ia32_vperm2f128_ps256 ((__v8sf)(__m256)(X), (__v8sf)(__m256)(Y), (int)(C)))
#define _mm256_permute2f128_si256(X,Y,C) ((__m256i) __builtin_ia32_vperm2f128_si256 ((__v8si)(__m256i)(X), (__v8si)(__m256i)(Y), (int)(C)))
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_broadcast_ss (float const *__X)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcast_sd (double const *__X)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcast_ss (float const *__X)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcast_pd (__m128d const *__X)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcast_ps (__m128 const *__X)
;
#define _mm256_insertf128_pd(X,Y,O) ((__m256d) __builtin_ia32_vinsertf128_pd256 ((__v4df)(__m256d)(X), (__v2df)(__m128d)(Y), (int)(O)))
#define _mm256_insertf128_ps(X,Y,O) ((__m256) __builtin_ia32_vinsertf128_ps256 ((__v8sf)(__m256)(X), (__v4sf)(__m128)(Y), (int)(O)))
#define _mm256_insertf128_si256(X,Y,O) ((__m256i) __builtin_ia32_vinsertf128_si256 ((__v8si)(__m256i)(X), (__v4si)(__m128i)(Y), (int)(O)))
#define _mm256_insert_epi32(X,D,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 2); __Y = _mm_insert_epi32 (__Y, (D), (N) % 4); _mm256_insertf128_si256 ((X), __Y, (N) >> 2); }))
#define _mm256_insert_epi16(X,D,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 3); __Y = _mm_insert_epi16 (__Y, (D), (N) % 8); _mm256_insertf128_si256 ((X), __Y, (N) >> 3); }))
#define _mm256_insert_epi8(X,D,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 4); __Y = _mm_insert_epi8 (__Y, (D), (N) % 16); _mm256_insertf128_si256 ((X), __Y, (N) >> 4); }))
#define _mm256_insert_epi64(X,D,N) (__extension__ ({ __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 1); __Y = _mm_insert_epi64 (__Y, (D), (N) % 2); _mm256_insertf128_si256 ((X), __Y, (N) >> 1); }))
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_load_pd (double const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_store_pd (double *__P, __m256d __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_load_ps (float const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_store_ps (float *__P, __m256 __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_loadu_pd (double const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_storeu_pd (double *__P, __m256d __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_loadu_ps (float const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_storeu_ps (float *__P, __m256 __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_load_si256 (__m256i const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_store_si256 (__m256i *__P, __m256i __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_loadu_si256 (__m256i const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_storeu_si256 (__m256i *__P, __m256i __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskload_pd (double const *__P, __m128i __M)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskstore_pd (double *__P, __m128i __M, __m128d __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskload_pd (double const *__P, __m256i __M)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskstore_pd (double *__P, __m256i __M, __m256d __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskload_ps (float const *__P, __m128i __M)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskstore_ps (float *__P, __m128i __M, __m128 __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskload_ps (float const *__P, __m256i __M)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskstore_ps (float *__P, __m256i __M, __m256 __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_movehdup_ps (__m256 __X)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_moveldup_ps (__m256 __X)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_movedup_pd (__m256d __X)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_lddqu_si256 (__m256i const *__P)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_stream_si256 (__m256i *__A, __m256i __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_stream_pd (double *__A, __m256d __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_stream_ps (float *__P, __m256 __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_rcp_ps (__m256 __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_rsqrt_ps (__m256 __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sqrt_pd (__m256d __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sqrt_ps (__m256 __A)
;
#define _mm256_round_pd(V,M) ((__m256d) __builtin_ia32_roundpd256 ((__v4df)(__m256d)(V), (int)(M)))
#define _mm256_round_ps(V,M) ((__m256) __builtin_ia32_roundps256 ((__v8sf)(__m256)(V), (int)(M)))
#define _mm256_ceil_pd(V) _mm256_round_pd ((V), _MM_FROUND_CEIL)
#define _mm256_floor_pd(V) _mm256_round_pd ((V), _MM_FROUND_FLOOR)
#define _mm256_ceil_ps(V) _mm256_round_ps ((V), _MM_FROUND_CEIL)
#define _mm256_floor_ps(V) _mm256_round_ps ((V), _MM_FROUND_FLOOR)
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpackhi_pd (__m256d __A, __m256d __B)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpacklo_pd (__m256d __A, __m256d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpackhi_ps (__m256 __A, __m256 __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpacklo_ps (__m256 __A, __m256 __B)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testz_pd (__m128d __M, __m128d __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testc_pd (__m128d __M, __m128d __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testnzc_pd (__m128d __M, __m128d __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testz_ps (__m128 __M, __m128 __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testc_ps (__m128 __M, __m128 __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_testnzc_ps (__m128 __M, __m128 __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testz_pd (__m256d __M, __m256d __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testc_pd (__m256d __M, __m256d __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testnzc_pd (__m256d __M, __m256d __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testz_ps (__m256 __M, __m256 __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testc_ps (__m256 __M, __m256 __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testnzc_ps (__m256 __M, __m256 __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testz_si256 (__m256i __M, __m256i __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testc_si256 (__m256i __M, __m256i __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_testnzc_si256 (__m256i __M, __m256i __V)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_movemask_pd (__m256d __A)
;
extern int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_movemask_ps (__m256 __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_undefined_pd (void)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_undefined_ps (void)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_undefined_si256 (void)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setzero_pd (void)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setzero_ps (void)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setzero_si256 (void)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set_pd (double __A, double __B, double __C, double __D)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set_ps (float __A, float __B, float __C, float __D,
float __E, float __F, float __G, float __H)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set_epi32 (int __A, int __B, int __C, int __D,
int __E, int __F, int __G, int __H)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set_epi16 (short __q15, short __q14, short __q13, short __q12,
short __q11, short __q10, short __q09, short __q08,
short __q07, short __q06, short __q05, short __q04,
short __q03, short __q02, short __q01, short __q00)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set_epi8 (char __q31, char __q30, char __q29, char __q28,
char __q27, char __q26, char __q25, char __q24,
char __q23, char __q22, char __q21, char __q20,
char __q19, char __q18, char __q17, char __q16,
char __q15, char __q14, char __q13, char __q12,
char __q11, char __q10, char __q09, char __q08,
char __q07, char __q06, char __q05, char __q04,
char __q03, char __q02, char __q01, char __q00)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set_epi64x (long long __A, long long __B, long long __C,
long long __D)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set1_pd (double __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set1_ps (float __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set1_epi32 (int __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set1_epi16 (short __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set1_epi8 (char __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_set1_epi64x (long long __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setr_pd (double __A, double __B, double __C, double __D)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setr_ps (float __A, float __B, float __C, float __D,
float __E, float __F, float __G, float __H)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setr_epi32 (int __A, int __B, int __C, int __D,
int __E, int __F, int __G, int __H)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setr_epi16 (short __q15, short __q14, short __q13, short __q12,
short __q11, short __q10, short __q09, short __q08,
short __q07, short __q06, short __q05, short __q04,
short __q03, short __q02, short __q01, short __q00)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setr_epi8 (char __q31, char __q30, char __q29, char __q28,
char __q27, char __q26, char __q25, char __q24,
char __q23, char __q22, char __q21, char __q20,
char __q19, char __q18, char __q17, char __q16,
char __q15, char __q14, char __q13, char __q12,
char __q11, char __q10, char __q09, char __q08,
char __q07, char __q06, char __q05, char __q04,
char __q03, char __q02, char __q01, char __q00)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_setr_epi64x (long long __A, long long __B, long long __C,
long long __D)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castpd_ps (__m256d __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castpd_si256 (__m256d __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castps_pd (__m256 __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castps_si256(__m256 __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castsi256_ps (__m256i __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castsi256_pd (__m256i __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castpd256_pd128 (__m256d __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castps256_ps128 (__m256 __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castsi256_si128 (__m256i __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castpd128_pd256 (__m128d __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castps128_ps256 (__m128 __A)
;
extern __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_castsi128_si256 (__m128i __A)
;
#undef __DISABLE_AVX__
#pragma GCC pop_options
#define _AVX2INTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("avx2")
#define __DISABLE_AVX2__
#define _mm256_mpsadbw_epu8(X,Y,M) ((__m256i) __builtin_ia32_mpsadbw256 ((__v32qi)(__m256i)(X), (__v32qi)(__m256i)(Y), (int)(M)))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_abs_epi8 (__m256i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_abs_epi16 (__m256i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_abs_epi32 (__m256i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_packs_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_packs_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_packus_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_packus_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_add_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_add_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_add_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_add_epi64 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_adds_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_adds_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_adds_epu8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_adds_epu16 (__m256i __A, __m256i __B)
;
#define _mm256_alignr_epi8(A,B,N) ((__m256i) __builtin_ia32_palignr256 ((__v4di)(__m256i)(A), (__v4di)(__m256i)(B), (int)(N) * 8))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_and_si256 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_andnot_si256 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_avg_epu8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_avg_epu16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_blendv_epi8 (__m256i __X, __m256i __Y, __m256i __M)
;
#define _mm256_blend_epi16(X,Y,M) ((__m256i) __builtin_ia32_pblendw256 ((__v16hi)(__m256i)(X), (__v16hi)(__m256i)(Y), (int)(M)))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpeq_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpeq_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpeq_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpeq_epi64 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpgt_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpgt_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpgt_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cmpgt_epi64 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hadd_epi16 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hadd_epi32 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hadds_epi16 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hsub_epi16 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hsub_epi32 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_hsubs_epi16 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maddubs_epi16 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_madd_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_epu8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_epu16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_max_epu32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_epu8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_epu16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_min_epu32 (__m256i __A, __m256i __B)
;
extern int
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_movemask_epi8 (__m256i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi8_epi16 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi8_epi32 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi8_epi64 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi16_epi32 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi16_epi64 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepi32_epi64 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepu8_epi16 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepu8_epi32 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepu8_epi64 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepu16_epi32 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepu16_epi64 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtepu32_epi64 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mul_epi32 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mulhrs_epi16 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mulhi_epu16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mulhi_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mullo_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mullo_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_mul_epu32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_or_si256 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sad_epu8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_shuffle_epi8 (__m256i __X, __m256i __Y)
;
#define _mm256_shuffle_epi32(A,N) ((__m256i)__builtin_ia32_pshufd256 ((__v8si)(__m256i)(A), (int)(N)))
#define _mm256_shufflehi_epi16(A,N) ((__m256i)__builtin_ia32_pshufhw256 ((__v16hi)(__m256i)(A), (int)(N)))
#define _mm256_shufflelo_epi16(A,N) ((__m256i)__builtin_ia32_pshuflw256 ((__v16hi)(__m256i)(A), (int)(N)))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sign_epi8 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sign_epi16 (__m256i __X, __m256i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sign_epi32 (__m256i __X, __m256i __Y)
;
#define _mm256_slli_si256(A,N) ((__m256i)__builtin_ia32_pslldqi256 ((__m256i)(A), (int)(N) * 8))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_slli_epi16 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sll_epi16 (__m256i __A, __m128i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_slli_epi32 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sll_epi32 (__m256i __A, __m128i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_slli_epi64 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sll_epi64 (__m256i __A, __m128i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srai_epi16 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sra_epi16 (__m256i __A, __m128i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srai_epi32 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sra_epi32 (__m256i __A, __m128i __B)
;
#define _mm256_srli_si256(A,N) ((__m256i)__builtin_ia32_psrldqi256 ((__m256i)(A), (int)(N) * 8))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srli_epi16 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srl_epi16 (__m256i __A, __m128i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srli_epi32 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srl_epi32 (__m256i __A, __m128i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srli_epi64 (__m256i __A, int __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srl_epi64 (__m256i __A, __m128i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sub_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sub_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sub_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sub_epi64 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_subs_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_subs_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_subs_epu8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_subs_epu16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpackhi_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpackhi_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpackhi_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpackhi_epi64 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpacklo_epi8 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpacklo_epi16 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpacklo_epi32 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_unpacklo_epi64 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_xor_si256 (__m256i __A, __m256i __B)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_stream_load_si256 (__m256i const *__X)
;
extern __m128
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_broadcastss_ps (__m128 __X)
;
extern __m256
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcastss_ps (__m128 __X)
;
extern __m256d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcastsd_pd (__m128d __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcastsi128_si256 (__m128i __X)
;
#define _mm_blend_epi32(X,Y,M) ((__m128i) __builtin_ia32_pblendd128 ((__v4si)(__m128i)(X), (__v4si)(__m128i)(Y), (int)(M)))
#define _mm256_blend_epi32(X,Y,M) ((__m256i) __builtin_ia32_pblendd256 ((__v8si)(__m256i)(X), (__v8si)(__m256i)(Y), (int)(M)))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcastb_epi8 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcastw_epi16 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcastd_epi32 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_broadcastq_epi64 (__m128i __X)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_broadcastb_epi8 (__m128i __X)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_broadcastw_epi16 (__m128i __X)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_broadcastd_epi32 (__m128i __X)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_broadcastq_epi64 (__m128i __X)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_permutevar8x32_epi32 (__m256i __X, __m256i __Y)
;
#define _mm256_permute4x64_pd(X,M) ((__m256d) __builtin_ia32_permdf256 ((__v4df)(__m256d)(X), (int)(M)))
extern __m256
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_permutevar8x32_ps (__m256 __X, __m256i __Y)
;
#define _mm256_permute4x64_epi64(X,M) ((__m256i) __builtin_ia32_permdi256 ((__v4di)(__m256i)(X), (int)(M)))
#define _mm256_permute2x128_si256(X,Y,M) ((__m256i) __builtin_ia32_permti256 ((__v4di)(__m256i)(X), (__v4di)(__m256i)(Y), (int)(M)))
#define _mm256_extracti128_si256(X,M) ((__m128i) __builtin_ia32_extract128i256 ((__v4di)(__m256i)(X), (int)(M)))
#define _mm256_inserti128_si256(X,Y,M) ((__m256i) __builtin_ia32_insert128i256 ((__v4di)(__m256i)(X), (__v2di)(__m128i)(Y), (int)(M)))
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskload_epi32 (int const *__X, __m256i __M )
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskload_epi64 (long long const *__X, __m256i __M )
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskload_epi32 (int const *__X, __m128i __M )
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskload_epi64 (long long const *__X, __m128i __M )
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskstore_epi32 (int *__X, __m256i __M, __m256i __Y )
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maskstore_epi64 (long long *__X, __m256i __M, __m256i __Y )
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskstore_epi32 (int *__X, __m128i __M, __m128i __Y )
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskstore_epi64 (long long *__X, __m128i __M, __m128i __Y )
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sllv_epi32 (__m256i __X, __m256i __Y)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sllv_epi32 (__m128i __X, __m128i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_sllv_epi64 (__m256i __X, __m256i __Y)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sllv_epi64 (__m128i __X, __m128i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srav_epi32 (__m256i __X, __m256i __Y)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_srav_epi32 (__m128i __X, __m128i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srlv_epi32 (__m256i __X, __m256i __Y)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_srlv_epi32 (__m128i __X, __m128i __Y)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm256_srlv_epi64 (__m256i __X, __m256i __Y)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_srlv_epi64 (__m128i __X, __m128i __Y)
;
#define _mm_i32gather_pd(BASE,INDEX,SCALE) (__m128d) __builtin_ia32_gathersiv2df ((__v2df) _mm_setzero_pd (), (double const *)BASE, (__v4si)(__m128i)INDEX, (__v2df)_mm_set1_pd( (double)(long long int) -1), (int)SCALE)
#define _mm_mask_i32gather_pd(SRC,BASE,INDEX,MASK,SCALE) (__m128d) __builtin_ia32_gathersiv2df ((__v2df)(__m128d)SRC, (double const *)BASE, (__v4si)(__m128i)INDEX, (__v2df)(__m128d)MASK, (int)SCALE)
#define _mm256_i32gather_pd(BASE,INDEX,SCALE) (__m256d) __builtin_ia32_gathersiv4df ((__v4df) _mm256_setzero_pd (), (double const *)BASE, (__v4si)(__m128i)INDEX, (__v4df)_mm256_set1_pd( (double)(long long int) -1), (int)SCALE)
#define _mm256_mask_i32gather_pd(SRC,BASE,INDEX,MASK,SCALE) (__m256d) __builtin_ia32_gathersiv4df ((__v4df)(__m256d)SRC, (double const *)BASE, (__v4si)(__m128i)INDEX, (__v4df)(__m256d)MASK, (int)SCALE)
#define _mm_i64gather_pd(BASE,INDEX,SCALE) (__m128d) __builtin_ia32_gatherdiv2df ((__v2df) _mm_setzero_pd (), (double const *)BASE, (__v2di)(__m128i)INDEX, (__v2df)_mm_set1_pd( (double)(long long int) -1), (int)SCALE)
#define _mm_mask_i64gather_pd(SRC,BASE,INDEX,MASK,SCALE) (__m128d) __builtin_ia32_gatherdiv2df ((__v2df)(__m128d)SRC, (double const *)BASE, (__v2di)(__m128i)INDEX, (__v2df)(__m128d)MASK, (int)SCALE)
#define _mm256_i64gather_pd(BASE,INDEX,SCALE) (__m256d) __builtin_ia32_gatherdiv4df ((__v4df) _mm256_setzero_pd (), (double const *)BASE, (__v4di)(__m256i)INDEX, (__v4df)_mm256_set1_pd( (double)(long long int) -1), (int)SCALE)
#define _mm256_mask_i64gather_pd(SRC,BASE,INDEX,MASK,SCALE) (__m256d) __builtin_ia32_gatherdiv4df ((__v4df)(__m256d)SRC, (double const *)BASE, (__v4di)(__m256i)INDEX, (__v4df)(__m256d)MASK, (int)SCALE)
#define _mm_i32gather_ps(BASE,INDEX,SCALE) (__m128) __builtin_ia32_gathersiv4sf ((__v4sf) _mm_setzero_ps (), (float const *)BASE, (__v4si)(__m128i)INDEX, _mm_set1_ps ((float)(int) -1), (int)SCALE)
#define _mm_mask_i32gather_ps(SRC,BASE,INDEX,MASK,SCALE) (__m128) __builtin_ia32_gathersiv4sf ((__v4sf)(__m128d)SRC, (float const *)BASE, (__v4si)(__m128i)INDEX, (__v4sf)(__m128d)MASK, (int)SCALE)
#define _mm256_i32gather_ps(BASE,INDEX,SCALE) (__m256) __builtin_ia32_gathersiv8sf ((__v8sf) _mm256_setzero_ps (), (float const *)BASE, (__v8si)(__m256i)INDEX, (__v8sf)_mm256_set1_ps ( (float)(int) -1), (int)SCALE)
#define _mm256_mask_i32gather_ps(SRC,BASE,INDEX,MASK,SCALE) (__m256) __builtin_ia32_gathersiv8sf ((__v8sf)(__m256)SRC, (float const *)BASE, (__v8si)(__m256i)INDEX, (__v8sf)(__m256d)MASK, (int)SCALE)
#define _mm_i64gather_ps(BASE,INDEX,SCALE) (__m128) __builtin_ia32_gatherdiv4sf ((__v4sf) _mm_setzero_pd (), (float const *)BASE, (__v2di)(__m128i)INDEX, (__v4sf)_mm_set1_ps ( (float)(int) -1), (int)SCALE)
#define _mm_mask_i64gather_ps(SRC,BASE,INDEX,MASK,SCALE) (__m128) __builtin_ia32_gatherdiv4sf ((__v4sf)(__m128)SRC, (float const *)BASE, (__v2di)(__m128i)INDEX, (__v4sf)(__m128d)MASK, (int)SCALE)
#define _mm256_i64gather_ps(BASE,INDEX,SCALE) (__m128) __builtin_ia32_gatherdiv4sf256 ((__v4sf) _mm_setzero_ps (), (float const *)BASE, (__v4di)(__m256i)INDEX, (__v4sf)_mm_set1_ps( (float)(int) -1), (int)SCALE)
#define _mm256_mask_i64gather_ps(SRC,BASE,INDEX,MASK,SCALE) (__m128) __builtin_ia32_gatherdiv4sf256 ((__v4sf)(__m128)SRC, (float const *)BASE, (__v4di)(__m256i)INDEX, (__v4sf)(__m128)MASK, (int)SCALE)
#define _mm_i32gather_epi64(BASE,INDEX,SCALE) (__m128i) __builtin_ia32_gathersiv2di ((__v2di) _mm_setzero_si128 (), (long long const *)BASE, (__v4si)(__m128i)INDEX, (__v2di)_mm_set1_epi64x (-1), (int)SCALE)
#define _mm_mask_i32gather_epi64(SRC,BASE,INDEX,MASK,SCALE) (__m128i) __builtin_ia32_gathersiv2di ((__v2di)(__m128i)SRC, (long long const *)BASE, (__v4si)(__m128i)INDEX, (__v2di)(__m128i)MASK, (int)SCALE)
#define _mm256_i32gather_epi64(BASE,INDEX,SCALE) (__m256i) __builtin_ia32_gathersiv4di ((__v4di) _mm256_setzero_si256 (), (long long const *)BASE, (__v4si)(__m128i)INDEX, (__v4di)_mm256_set1_epi64x (-1), (int)SCALE)
#define _mm256_mask_i32gather_epi64(SRC,BASE,INDEX,MASK,SCALE) (__m256i) __builtin_ia32_gathersiv4di ((__v4di)(__m256i)SRC, (long long const *)BASE, (__v4si)(__m128i)INDEX, (__v4di)(__m256i)MASK, (int)SCALE)
#define _mm_i64gather_epi64(BASE,INDEX,SCALE) (__m128i) __builtin_ia32_gatherdiv2di ((__v2di) _mm_setzero_si128 (), (long long const *)BASE, (__v2di)(__m128i)INDEX, (__v2di)_mm_set1_epi64x (-1), (int)SCALE)
#define _mm_mask_i64gather_epi64(SRC,BASE,INDEX,MASK,SCALE) (__m128i) __builtin_ia32_gatherdiv2di ((__v2di)(__m128i)SRC, (long long const *)BASE, (__v2di)(__m128i)INDEX, (__v2di)(__m128i)MASK, (int)SCALE)
#define _mm256_i64gather_epi64(BASE,INDEX,SCALE) (__m256i) __builtin_ia32_gatherdiv4di ((__v4di) _mm256_setzero_si256 (), (long long const *)BASE, (__v4di)(__m256i)INDEX, (__v4di)_mm256_set1_epi64x (-1), (int)SCALE)
#define _mm256_mask_i64gather_epi64(SRC,BASE,INDEX,MASK,SCALE) (__m256i) __builtin_ia32_gatherdiv4di ((__v4di)(__m256i)SRC, (long long const *)BASE, (__v4di)(__m256i)INDEX, (__v4di)(__m256i)MASK, (int)SCALE)
#define _mm_i32gather_epi32(BASE,INDEX,SCALE) (__m128i) __builtin_ia32_gathersiv4si ((__v4si) _mm_setzero_si128 (), (int const *)BASE, (__v4si)(__m128i)INDEX, (__v4si)_mm_set1_epi32 (-1), (int)SCALE)
#define _mm_mask_i32gather_epi32(SRC,BASE,INDEX,MASK,SCALE) (__m128i) __builtin_ia32_gathersiv4si ((__v4si)(__m128i)SRC, (int const *)BASE, (__v4si)(__m128i)INDEX, (__v4si)(__m128i)MASK, (int)SCALE)
#define _mm256_i32gather_epi32(BASE,INDEX,SCALE) (__m256i) __builtin_ia32_gathersiv8si ((__v8si) _mm256_setzero_si256 (), (int const *)BASE, (__v8si)(__m256i)INDEX, (__v8si)_mm256_set1_epi32 (-1), (int)SCALE)
#define _mm256_mask_i32gather_epi32(SRC,BASE,INDEX,MASK,SCALE) (__m256i) __builtin_ia32_gathersiv8si ((__v8si)(__m256i)SRC, (int const *)BASE, (__v8si)(__m256i)INDEX, (__v8si)(__m256i)MASK, (int)SCALE)
#define _mm_i64gather_epi32(BASE,INDEX,SCALE) (__m128i) __builtin_ia32_gatherdiv4si ((__v4si) _mm_setzero_si128 (), (int const *)BASE, (__v2di)(__m128i)INDEX, (__v4si)_mm_set1_epi32 (-1), (int)SCALE)
#define _mm_mask_i64gather_epi32(SRC,BASE,INDEX,MASK,SCALE) (__m128i) __builtin_ia32_gatherdiv4si ((__v4si)(__m128i)SRC, (int const *)BASE, (__v2di)(__m128i)INDEX, (__v4si)(__m128i)MASK, (int)SCALE)
#define _mm256_i64gather_epi32(BASE,INDEX,SCALE) (__m128i) __builtin_ia32_gatherdiv4si256 ((__v4si) _mm_setzero_si128 (), (int const *)BASE, (__v4di)(__m256i)INDEX, (__v4si)_mm_set1_epi32(-1), (int)SCALE)
#define _mm256_mask_i64gather_epi32(SRC,BASE,INDEX,MASK,SCALE) (__m128i) __builtin_ia32_gatherdiv4si256 ((__v4si)(__m128i)SRC, (int const *)BASE, (__v4di)(__m256i)INDEX, (__v4si)(__m128i)MASK, (int)SCALE)
#undef __DISABLE_AVX2__
#pragma GCC pop_options
#define _AVX512FINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("avx512f")
#define __DISABLE_AVX512F__
typedef double __v8df __attribute__ ((__vector_size__ (64)));
typedef float __v16sf __attribute__ ((__vector_size__ (64)));
typedef long long __v8di __attribute__ ((__vector_size__ (64)));
typedef int __v16si __attribute__ ((__vector_size__ (64)));
typedef short __v32hi __attribute__ ((__vector_size__ (64)));
typedef char __v64qi __attribute__ ((__vector_size__ (64)));
typedef float __m512 __attribute__ ((__vector_size__ (64), __may_alias__));
typedef long long __m512i __attribute__ ((__vector_size__ (64), __may_alias__));
typedef double __m512d __attribute__ ((__vector_size__ (64), __may_alias__));
typedef unsigned char __mmask8;
typedef unsigned short __mmask16;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set_epi64 (long long __A, long long __B, long long __C,
long long __D, long long __E, long long __F,
long long __G, long long __H)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set_epi32 (int __A, int __B, int __C, int __D,
int __E, int __F, int __G, int __H,
int __I, int __J, int __K, int __L,
int __M, int __N, int __O, int __P)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set_pd (double __A, double __B, double __C, double __D,
double __E, double __F, double __G, double __H)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set_ps (float __A, float __B, float __C, float __D,
float __E, float __F, float __G, float __H,
float __I, float __J, float __K, float __L,
float __M, float __N, float __O, float __P)
;
#define _mm512_setr_epi64(e0,e1,e2,e3,e4,e5,e6,e7) _mm512_set_epi64(e7,e6,e5,e4,e3,e2,e1,e0)
#define _mm512_setr_epi32(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15) _mm512_set_epi32(e15,e14,e13,e12,e11,e10,e9,e8,e7,e6,e5,e4,e3,e2,e1,e0)
#define _mm512_setr_pd(e0,e1,e2,e3,e4,e5,e6,e7) _mm512_set_pd(e7,e6,e5,e4,e3,e2,e1,e0)
#define _mm512_setr_ps(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15) _mm512_set_ps(e15,e14,e13,e12,e11,e10,e9,e8,e7,e6,e5,e4,e3,e2,e1,e0)
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_undefined_ps (void)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_undefined_pd (void)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_undefined_si512 (void)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set1_epi8 (char __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set1_epi16 (short __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set1_pd (double __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set1_ps (float __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set4_epi32 (int __A, int __B, int __C, int __D)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set4_epi64 (long long __A, long long __B, long long __C,
long long __D)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set4_pd (double __A, double __B, double __C, double __D)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set4_ps (float __A, float __B, float __C, float __D)
;
#define _mm512_setr4_epi64(e0,e1,e2,e3) _mm512_set4_epi64(e3,e2,e1,e0)
#define _mm512_setr4_epi32(e0,e1,e2,e3) _mm512_set4_epi32(e3,e2,e1,e0)
#define _mm512_setr4_pd(e0,e1,e2,e3) _mm512_set4_pd(e3,e2,e1,e0)
#define _mm512_setr4_ps(e0,e1,e2,e3) _mm512_set4_ps(e3,e2,e1,e0)
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_setzero_ps (void)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_setzero_pd (void)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_setzero_epi32 (void)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_setzero_si512 (void)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mov_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mov_pd (__mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mov_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mov_ps (__mmask16 __U, __m512 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_load_pd (void const *__P)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_load_pd (__m512d __W, __mmask8 __U, void const *__P)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_load_pd (__mmask8 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_store_pd (void *__P, __m512d __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_store_pd (void *__P, __mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_load_ps (void const *__P)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_load_ps (__m512 __W, __mmask16 __U, void const *__P)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_load_ps (__mmask16 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_store_ps (void *__P, __m512 __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_store_ps (void *__P, __mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mov_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mov_epi64 (__mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_load_epi64 (void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_load_epi64 (__m512i __W, __mmask8 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_load_epi64 (__mmask8 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_store_epi64 (void *__P, __m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_store_epi64 (void *__P, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mov_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mov_epi32 (__mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_load_si512 (void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_load_epi32 (void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_load_epi32 (__m512i __W, __mmask16 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_load_epi32 (__mmask16 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_store_si512 (void *__P, __m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_store_epi32 (void *__P, __m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_store_epi32 (void *__P, __mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mullo_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mullo_epi32 (__mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mullo_epi32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sllv_epi32 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sllv_epi32 (__m512i __W, __mmask16 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sllv_epi32 (__mmask16 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_srav_epi32 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_srav_epi32 (__m512i __W, __mmask16 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_srav_epi32 (__mmask16 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_srlv_epi32 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_srlv_epi32 (__m512i __W, __mmask16 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_srlv_epi32 (__mmask16 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_add_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_add_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_add_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sub_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sub_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sub_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sllv_epi64 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sllv_epi64 (__m512i __W, __mmask8 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sllv_epi64 (__mmask8 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_srav_epi64 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_srav_epi64 (__m512i __W, __mmask8 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_srav_epi64 (__mmask8 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_srlv_epi64 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_srlv_epi64 (__m512i __W, __mmask8 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_srlv_epi64 (__mmask8 __U, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_add_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_add_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_add_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mul_epi32 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mul_epi32 (__m512i __W, __mmask8 __M, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mul_epi32 (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sub_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sub_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sub_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mul_epu32 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mul_epu32 (__m512i __W, __mmask8 __M, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mul_epu32 (__mmask8 __M, __m512i __X, __m512i __Y)
;
#define _mm512_slli_epi64(X,C) ((__m512i) __builtin_ia32_psllqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_undefined_si512 (), (__mmask8)-1))
#define _mm512_mask_slli_epi64(W,U,X,C) ((__m512i) __builtin_ia32_psllqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_slli_epi64(U,X,C) ((__m512i) __builtin_ia32_psllqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_setzero_si512 (), (__mmask8)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sll_epi64 (__m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sll_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sll_epi64 (__mmask8 __U, __m512i __A, __m128i __B)
;
#define _mm512_srli_epi64(X,C) ((__m512i) __builtin_ia32_psrlqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_undefined_si512 (), (__mmask8)-1))
#define _mm512_mask_srli_epi64(W,U,X,C) ((__m512i) __builtin_ia32_psrlqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_srli_epi64(U,X,C) ((__m512i) __builtin_ia32_psrlqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_setzero_si512 (), (__mmask8)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_srl_epi64 (__m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_srl_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_srl_epi64 (__mmask8 __U, __m512i __A, __m128i __B)
;
#define _mm512_srai_epi64(X,C) ((__m512i) __builtin_ia32_psraqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_undefined_si512 (), (__mmask8)-1))
#define _mm512_mask_srai_epi64(W,U,X,C) ((__m512i) __builtin_ia32_psraqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_srai_epi64(U,X,C) ((__m512i) __builtin_ia32_psraqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_setzero_si512 (), (__mmask8)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sra_epi64 (__m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sra_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sra_epi64 (__mmask8 __U, __m512i __A, __m128i __B)
;
#define _mm512_slli_epi32(X,C) ((__m512i) __builtin_ia32_pslldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_undefined_si512 (), (__mmask16)-1))
#define _mm512_mask_slli_epi32(W,U,X,C) ((__m512i) __builtin_ia32_pslldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_slli_epi32(U,X,C) ((__m512i) __builtin_ia32_pslldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sll_epi32 (__m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sll_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sll_epi32 (__mmask16 __U, __m512i __A, __m128i __B)
;
#define _mm512_srli_epi32(X,C) ((__m512i) __builtin_ia32_psrldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_undefined_si512 (), (__mmask16)-1))
#define _mm512_mask_srli_epi32(W,U,X,C) ((__m512i) __builtin_ia32_psrldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_srli_epi32(U,X,C) ((__m512i) __builtin_ia32_psrldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_srl_epi32 (__m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_srl_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_srl_epi32 (__mmask16 __U, __m512i __A, __m128i __B)
;
#define _mm512_srai_epi32(X,C) ((__m512i) __builtin_ia32_psradi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_undefined_si512 (), (__mmask16)-1))
#define _mm512_mask_srai_epi32(W,U,X,C) ((__m512i) __builtin_ia32_psradi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_srai_epi32(U,X,C) ((__m512i) __builtin_ia32_psradi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sra_epi32 (__m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sra_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m128i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sra_epi32 (__mmask16 __U, __m512i __A, __m128i __B)
;
#define _mm_add_round_sd(A,B,C) (__m128d)__builtin_ia32_addsd_round(A, B, C)
#define _mm_add_round_ss(A,B,C) (__m128)__builtin_ia32_addss_round(A, B, C)
#define _mm_sub_round_sd(A,B,C) (__m128d)__builtin_ia32_subsd_round(A, B, C)
#define _mm_sub_round_ss(A,B,C) (__m128)__builtin_ia32_subss_round(A, B, C)
#define _mm512_ternarylogic_epi64(A,B,C,I) ((__m512i) __builtin_ia32_pternlogq512_mask ((__v8di)(__m512i)(A), (__v8di)(__m512i)(B), (__v8di)(__m512i)(C), (int)(I), (__mmask8)-1))
#define _mm512_mask_ternarylogic_epi64(A,U,B,C,I) ((__m512i) __builtin_ia32_pternlogq512_mask ((__v8di)(__m512i)(A), (__v8di)(__m512i)(B), (__v8di)(__m512i)(C), (int)(I), (__mmask8)(U)))
#define _mm512_maskz_ternarylogic_epi64(U,A,B,C,I) ((__m512i) __builtin_ia32_pternlogq512_maskz ((__v8di)(__m512i)(A), (__v8di)(__m512i)(B), (__v8di)(__m512i)(C), (int)(I), (__mmask8)(U)))
#define _mm512_ternarylogic_epi32(A,B,C,I) ((__m512i) __builtin_ia32_pternlogd512_mask ((__v16si)(__m512i)(A), (__v16si)(__m512i)(B), (__v16si)(__m512i)(C), (int)(I), (__mmask16)-1))
#define _mm512_mask_ternarylogic_epi32(A,U,B,C,I) ((__m512i) __builtin_ia32_pternlogd512_mask ((__v16si)(__m512i)(A), (__v16si)(__m512i)(B), (__v16si)(__m512i)(C), (int)(I), (__mmask16)(U)))
#define _mm512_maskz_ternarylogic_epi32(U,A,B,C,I) ((__m512i) __builtin_ia32_pternlogd512_maskz ((__v16si)(__m512i)(A), (__v16si)(__m512i)(B), (__v16si)(__m512i)(C), (int)(I), (__mmask16)(U)))
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rcp14_pd (__m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rcp14_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rcp14_pd (__mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rcp14_ps (__m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rcp14_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rcp14_ps (__mmask16 __U, __m512 __A)
;
extern __m128d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_rcp14_sd (__m128d __A, __m128d __B)
;
extern __m128
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_rcp14_ss (__m128 __A, __m128 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rsqrt14_pd (__m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rsqrt14_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rsqrt14_pd (__mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rsqrt14_ps (__m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rsqrt14_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rsqrt14_ps (__mmask16 __U, __m512 __A)
;
extern __m128d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_rsqrt14_sd (__m128d __A, __m128d __B)
;
extern __m128
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_rsqrt14_ss (__m128 __A, __m128 __B)
;
#define _mm512_sqrt_round_pd(A,C) (__m512d)__builtin_ia32_sqrtpd512_mask(A, (__v8df)_mm512_undefined_pd(), -1, C)
#define _mm512_mask_sqrt_round_pd(W,U,A,C) (__m512d)__builtin_ia32_sqrtpd512_mask(A, W, U, C)
#define _mm512_maskz_sqrt_round_pd(U,A,C) (__m512d)__builtin_ia32_sqrtpd512_mask(A, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_sqrt_round_ps(A,C) (__m512)__builtin_ia32_sqrtps512_mask(A, (__v16sf)_mm512_undefined_ps(), -1, C)
#define _mm512_mask_sqrt_round_ps(W,U,A,C) (__m512)__builtin_ia32_sqrtps512_mask(A, W, U, C)
#define _mm512_maskz_sqrt_round_ps(U,A,C) (__m512)__builtin_ia32_sqrtps512_mask(A, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm_sqrt_round_sd(A,B,C) (__m128d)__builtin_ia32_sqrtsd_round(A, B, C)
#define _mm_sqrt_round_ss(A,B,C) (__m128)__builtin_ia32_sqrtss_round(A, B, C)
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi8_epi32 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi8_epi32 (__m512i __W, __mmask16 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi8_epi32 (__mmask16 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi8_epi64 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi8_epi64 (__m512i __W, __mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi8_epi64 (__mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi16_epi32 (__m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi16_epi32 (__m512i __W, __mmask16 __U, __m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi16_epi32 (__mmask16 __U, __m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi16_epi64 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi16_epi64 (__m512i __W, __mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi16_epi64 (__mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi32_epi64 (__m256i __X)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi32_epi64 (__m512i __W, __mmask8 __U, __m256i __X)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi32_epi64 (__mmask8 __U, __m256i __X)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepu8_epi32 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepu8_epi32 (__m512i __W, __mmask16 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepu8_epi32 (__mmask16 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepu8_epi64 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepu8_epi64 (__m512i __W, __mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepu8_epi64 (__mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepu16_epi32 (__m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepu16_epi32 (__m512i __W, __mmask16 __U, __m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepu16_epi32 (__mmask16 __U, __m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepu16_epi64 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepu16_epi64 (__m512i __W, __mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepu16_epi64 (__mmask8 __U, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepu32_epi64 (__m256i __X)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepu32_epi64 (__m512i __W, __mmask8 __U, __m256i __X)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepu32_epi64 (__mmask8 __U, __m256i __X)
;
#define _mm512_add_round_pd(A,B,C) (__m512d)__builtin_ia32_addpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, C)
#define _mm512_mask_add_round_pd(W,U,A,B,C) (__m512d)__builtin_ia32_addpd512_mask(A, B, W, U, C)
#define _mm512_maskz_add_round_pd(U,A,B,C) (__m512d)__builtin_ia32_addpd512_mask(A, B, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_add_round_ps(A,B,C) (__m512)__builtin_ia32_addps512_mask(A, B, (__v16sf)_mm512_undefined_ps(), -1, C)
#define _mm512_mask_add_round_ps(W,U,A,B,C) (__m512)__builtin_ia32_addps512_mask(A, B, W, U, C)
#define _mm512_maskz_add_round_ps(U,A,B,C) (__m512)__builtin_ia32_addps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm512_sub_round_pd(A,B,C) (__m512d)__builtin_ia32_subpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, C)
#define _mm512_mask_sub_round_pd(W,U,A,B,C) (__m512d)__builtin_ia32_subpd512_mask(A, B, W, U, C)
#define _mm512_maskz_sub_round_pd(U,A,B,C) (__m512d)__builtin_ia32_subpd512_mask(A, B, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_sub_round_ps(A,B,C) (__m512)__builtin_ia32_subps512_mask(A, B, (__v16sf)_mm512_undefined_ps(), -1, C)
#define _mm512_mask_sub_round_ps(W,U,A,B,C) (__m512)__builtin_ia32_subps512_mask(A, B, W, U, C)
#define _mm512_maskz_sub_round_ps(U,A,B,C) (__m512)__builtin_ia32_subps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm512_mul_round_pd(A,B,C) (__m512d)__builtin_ia32_mulpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, C)
#define _mm512_mask_mul_round_pd(W,U,A,B,C) (__m512d)__builtin_ia32_mulpd512_mask(A, B, W, U, C)
#define _mm512_maskz_mul_round_pd(U,A,B,C) (__m512d)__builtin_ia32_mulpd512_mask(A, B, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_mul_round_ps(A,B,C) (__m512)__builtin_ia32_mulps512_mask(A, B, (__v16sf)_mm512_undefined_ps(), -1, C)
#define _mm512_mask_mul_round_ps(W,U,A,B,C) (__m512)__builtin_ia32_mulps512_mask(A, B, W, U, C)
#define _mm512_maskz_mul_round_ps(U,A,B,C) (__m512)__builtin_ia32_mulps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm512_div_round_pd(A,B,C) (__m512d)__builtin_ia32_divpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, C)
#define _mm512_mask_div_round_pd(W,U,A,B,C) (__m512d)__builtin_ia32_divpd512_mask(A, B, W, U, C)
#define _mm512_maskz_div_round_pd(U,A,B,C) (__m512d)__builtin_ia32_divpd512_mask(A, B, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_div_round_ps(A,B,C) (__m512)__builtin_ia32_divps512_mask(A, B, (__v16sf)_mm512_undefined_ps(), -1, C)
#define _mm512_mask_div_round_ps(W,U,A,B,C) (__m512)__builtin_ia32_divps512_mask(A, B, W, U, C)
#define _mm512_maskz_div_round_ps(U,A,B,C) (__m512)__builtin_ia32_divps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm_mul_round_sd(A,B,C) (__m128d)__builtin_ia32_mulsd_round(A, B, C)
#define _mm_mul_round_ss(A,B,C) (__m128)__builtin_ia32_mulss_round(A, B, C)
#define _mm_div_round_sd(A,B,C) (__m128d)__builtin_ia32_divsd_round(A, B, C)
#define _mm_div_round_ss(A,B,C) (__m128)__builtin_ia32_divss_round(A, B, C)
#define _mm512_max_round_pd(A,B,R) (__m512d)__builtin_ia32_maxpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, R)
#define _mm512_mask_max_round_pd(W,U,A,B,R) (__m512d)__builtin_ia32_maxpd512_mask(A, B, W, U, R)
#define _mm512_maskz_max_round_pd(U,A,B,R) (__m512d)__builtin_ia32_maxpd512_mask(A, B, (__v8df)_mm512_setzero_pd(), U, R)
#define _mm512_max_round_ps(A,B,R) (__m512)__builtin_ia32_maxps512_mask(A, B, (__v16sf)_mm512_undefined_pd(), -1, R)
#define _mm512_mask_max_round_ps(W,U,A,B,R) (__m512)__builtin_ia32_maxps512_mask(A, B, W, U, R)
#define _mm512_maskz_max_round_ps(U,A,B,R) (__m512)__builtin_ia32_maxps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, R)
#define _mm512_min_round_pd(A,B,R) (__m512d)__builtin_ia32_minpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, R)
#define _mm512_mask_min_round_pd(W,U,A,B,R) (__m512d)__builtin_ia32_minpd512_mask(A, B, W, U, R)
#define _mm512_maskz_min_round_pd(U,A,B,R) (__m512d)__builtin_ia32_minpd512_mask(A, B, (__v8df)_mm512_setzero_pd(), U, R)
#define _mm512_min_round_ps(A,B,R) (__m512)__builtin_ia32_minps512_mask(A, B, (__v16sf)_mm512_undefined_ps(), -1, R)
#define _mm512_mask_min_round_ps(W,U,A,B,R) (__m512)__builtin_ia32_minps512_mask(A, B, W, U, R)
#define _mm512_maskz_min_round_ps(U,A,B,R) (__m512)__builtin_ia32_minps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, R)
#define _mm512_scalef_round_pd(A,B,C) (__m512d)__builtin_ia32_scalefpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, C)
#define _mm512_mask_scalef_round_pd(W,U,A,B,C) (__m512d)__builtin_ia32_scalefpd512_mask(A, B, W, U, C)
#define _mm512_maskz_scalef_round_pd(U,A,B,C) (__m512d)__builtin_ia32_scalefpd512_mask(A, B, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_scalef_round_ps(A,B,C) (__m512)__builtin_ia32_scalefps512_mask(A, B, (__v16sf)_mm512_undefined_ps(), -1, C)
#define _mm512_mask_scalef_round_ps(W,U,A,B,C) (__m512)__builtin_ia32_scalefps512_mask(A, B, W, U, C)
#define _mm512_maskz_scalef_round_ps(U,A,B,C) (__m512)__builtin_ia32_scalefps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm_scalef_round_sd(A,B,C) (__m128d)__builtin_ia32_scalefsd_round(A, B, C)
#define _mm_scalef_round_ss(A,B,C) (__m128)__builtin_ia32_scalefss_round(A, B, C)
#define _mm512_fmadd_round_pd(A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_mask(A, B, C, -1, R)
#define _mm512_mask_fmadd_round_pd(A,U,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_mask(A, B, C, U, R)
#define _mm512_mask3_fmadd_round_pd(A,B,C,U,R) (__m512d)__builtin_ia32_vfmaddpd512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmadd_round_pd(U,A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_maskz(A, B, C, U, R)
#define _mm512_fmadd_round_ps(A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_mask(A, B, C, -1, R)
#define _mm512_mask_fmadd_round_ps(A,U,B,C,R) (__m512)__builtin_ia32_vfmaddps512_mask(A, B, C, U, R)
#define _mm512_mask3_fmadd_round_ps(A,B,C,U,R) (__m512)__builtin_ia32_vfmaddps512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmadd_round_ps(U,A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_maskz(A, B, C, U, R)
#define _mm512_fmsub_round_pd(A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_mask(A, B, -(C), -1, R)
#define _mm512_mask_fmsub_round_pd(A,U,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_mask(A, B, -(C), U, R)
#define _mm512_mask3_fmsub_round_pd(A,B,C,U,R) (__m512d)__builtin_ia32_vfmsubpd512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmsub_round_pd(U,A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_maskz(A, B, -(C), U, R)
#define _mm512_fmsub_round_ps(A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_mask(A, B, -(C), -1, R)
#define _mm512_mask_fmsub_round_ps(A,U,B,C,R) (__m512)__builtin_ia32_vfmaddps512_mask(A, B, -(C), U, R)
#define _mm512_mask3_fmsub_round_ps(A,B,C,U,R) (__m512)__builtin_ia32_vfmsubps512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmsub_round_ps(U,A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_maskz(A, B, -(C), U, R)
#define _mm512_fmaddsub_round_pd(A,B,C,R) (__m512d)__builtin_ia32_vfmaddsubpd512_mask(A, B, C, -1, R)
#define _mm512_mask_fmaddsub_round_pd(A,U,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_mask(A, B, C, U, R)
#define _mm512_mask3_fmaddsub_round_pd(A,B,C,U,R) (__m512d)__builtin_ia32_vfmaddsubpd512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmaddsub_round_pd(U,A,B,C,R) (__m512d)__builtin_ia32_vfmaddsubpd512_maskz(A, B, C, U, R)
#define _mm512_fmaddsub_round_ps(A,B,C,R) (__m512)__builtin_ia32_vfmaddsubps512_mask(A, B, C, -1, R)
#define _mm512_mask_fmaddsub_round_ps(A,U,B,C,R) (__m512)__builtin_ia32_vfmaddsubps512_mask(A, B, C, U, R)
#define _mm512_mask3_fmaddsub_round_ps(A,B,C,U,R) (__m512)__builtin_ia32_vfmaddsubps512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmaddsub_round_ps(U,A,B,C,R) (__m512)__builtin_ia32_vfmaddsubps512_maskz(A, B, C, U, R)
#define _mm512_fmsubadd_round_pd(A,B,C,R) (__m512d)__builtin_ia32_vfmaddsubpd512_mask(A, B, -(C), -1, R)
#define _mm512_mask_fmsubadd_round_pd(A,U,B,C,R) (__m512d)__builtin_ia32_vfmaddsubpd512_mask(A, B, -(C), U, R)
#define _mm512_mask3_fmsubadd_round_pd(A,B,C,U,R) (__m512d)__builtin_ia32_vfmsubaddpd512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmsubadd_round_pd(U,A,B,C,R) (__m512d)__builtin_ia32_vfmaddsubpd512_maskz(A, B, -(C), U, R)
#define _mm512_fmsubadd_round_ps(A,B,C,R) (__m512)__builtin_ia32_vfmaddsubps512_mask(A, B, -(C), -1, R)
#define _mm512_mask_fmsubadd_round_ps(A,U,B,C,R) (__m512)__builtin_ia32_vfmaddsubps512_mask(A, B, -(C), U, R)
#define _mm512_mask3_fmsubadd_round_ps(A,B,C,U,R) (__m512)__builtin_ia32_vfmsubaddps512_mask3(A, B, C, U, R)
#define _mm512_maskz_fmsubadd_round_ps(U,A,B,C,R) (__m512)__builtin_ia32_vfmaddsubps512_maskz(A, B, -(C), U, R)
#define _mm512_fnmadd_round_pd(A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_mask(-(A), B, C, -1, R)
#define _mm512_mask_fnmadd_round_pd(A,U,B,C,R) (__m512d)__builtin_ia32_vfnmaddpd512_mask(-(A), B, C, U, R)
#define _mm512_mask3_fnmadd_round_pd(A,B,C,U,R) (__m512d)__builtin_ia32_vfmaddpd512_mask3(-(A), B, C, U, R)
#define _mm512_maskz_fnmadd_round_pd(U,A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_maskz(-(A), B, C, U, R)
#define _mm512_fnmadd_round_ps(A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_mask(-(A), B, C, -1, R)
#define _mm512_mask_fnmadd_round_ps(A,U,B,C,R) (__m512)__builtin_ia32_vfnmaddps512_mask(-(A), B, C, U, R)
#define _mm512_mask3_fnmadd_round_ps(A,B,C,U,R) (__m512)__builtin_ia32_vfmaddps512_mask3(-(A), B, C, U, R)
#define _mm512_maskz_fnmadd_round_ps(U,A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_maskz(-(A), B, C, U, R)
#define _mm512_fnmsub_round_pd(A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_mask(-(A), B, -(C), -1, R)
#define _mm512_mask_fnmsub_round_pd(A,U,B,C,R) (__m512d)__builtin_ia32_vfnmsubpd512_mask(A, B, C, U, R)
#define _mm512_mask3_fnmsub_round_pd(A,B,C,U,R) (__m512d)__builtin_ia32_vfnmsubpd512_mask3(A, B, C, U, R)
#define _mm512_maskz_fnmsub_round_pd(U,A,B,C,R) (__m512d)__builtin_ia32_vfmaddpd512_maskz(-(A), B, -(C), U, R)
#define _mm512_fnmsub_round_ps(A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_mask(-(A), B, -(C), -1, R)
#define _mm512_mask_fnmsub_round_ps(A,U,B,C,R) (__m512)__builtin_ia32_vfnmsubps512_mask(A, B, C, U, R)
#define _mm512_mask3_fnmsub_round_ps(A,B,C,U,R) (__m512)__builtin_ia32_vfnmsubps512_mask3(A, B, C, U, R)
#define _mm512_maskz_fnmsub_round_ps(U,A,B,C,R) (__m512)__builtin_ia32_vfmaddps512_maskz(-(A), B, -(C), U, R)
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_abs_epi64 (__m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_abs_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_abs_epi64 (__mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_abs_epi32 (__m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_abs_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_abs_epi32 (__mmask16 __U, __m512i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcastss_ps (__m128 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcastss_ps (__m512 __O, __mmask16 __M, __m128 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcastss_ps (__mmask16 __M, __m128 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcastsd_pd (__m128d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcastsd_pd (__m512d __O, __mmask8 __M, __m128d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcastsd_pd (__mmask8 __M, __m128d __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcastd_epi32 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcastd_epi32 (__m512i __O, __mmask16 __M, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcastd_epi32 (__mmask16 __M, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set1_epi32 (int __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_set1_epi32 (__m512i __O, __mmask16 __M, int __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_set1_epi32 (__mmask16 __M, int __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcastq_epi64 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcastq_epi64 (__m512i __O, __mmask8 __M, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcastq_epi64 (__mmask8 __M, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_set1_epi64 (long long __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_set1_epi64 (__m512i __O, __mmask8 __M, long long __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_set1_epi64 (__mmask8 __M, long long __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcast_f32x4 (__m128 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcast_f32x4 (__m512 __O, __mmask16 __M, __m128 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcast_f32x4 (__mmask16 __M, __m128 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcast_i32x4 (__m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcast_i32x4 (__m512i __O, __mmask16 __M, __m128i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcast_i32x4 (__mmask16 __M, __m128i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcast_f64x4 (__m256d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcast_f64x4 (__m512d __O, __mmask8 __M, __m256d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcast_f64x4 (__mmask8 __M, __m256d __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcast_i64x4 (__m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_broadcast_i64x4 (__m512i __O, __mmask8 __M, __m256i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_broadcast_i64x4 (__mmask8 __M, __m256i __A)
;
typedef enum
{
_MM_PERM_AAAA = 0x00, _MM_PERM_AAAB = 0x01, _MM_PERM_AAAC = 0x02,
_MM_PERM_AAAD = 0x03, _MM_PERM_AABA = 0x04, _MM_PERM_AABB = 0x05,
_MM_PERM_AABC = 0x06, _MM_PERM_AABD = 0x07, _MM_PERM_AACA = 0x08,
_MM_PERM_AACB = 0x09, _MM_PERM_AACC = 0x0A, _MM_PERM_AACD = 0x0B,
_MM_PERM_AADA = 0x0C, _MM_PERM_AADB = 0x0D, _MM_PERM_AADC = 0x0E,
_MM_PERM_AADD = 0x0F, _MM_PERM_ABAA = 0x10, _MM_PERM_ABAB = 0x11,
_MM_PERM_ABAC = 0x12, _MM_PERM_ABAD = 0x13, _MM_PERM_ABBA = 0x14,
_MM_PERM_ABBB = 0x15, _MM_PERM_ABBC = 0x16, _MM_PERM_ABBD = 0x17,
_MM_PERM_ABCA = 0x18, _MM_PERM_ABCB = 0x19, _MM_PERM_ABCC = 0x1A,
_MM_PERM_ABCD = 0x1B, _MM_PERM_ABDA = 0x1C, _MM_PERM_ABDB = 0x1D,
_MM_PERM_ABDC = 0x1E, _MM_PERM_ABDD = 0x1F, _MM_PERM_ACAA = 0x20,
_MM_PERM_ACAB = 0x21, _MM_PERM_ACAC = 0x22, _MM_PERM_ACAD = 0x23,
_MM_PERM_ACBA = 0x24, _MM_PERM_ACBB = 0x25, _MM_PERM_ACBC = 0x26,
_MM_PERM_ACBD = 0x27, _MM_PERM_ACCA = 0x28, _MM_PERM_ACCB = 0x29,
_MM_PERM_ACCC = 0x2A, _MM_PERM_ACCD = 0x2B, _MM_PERM_ACDA = 0x2C,
_MM_PERM_ACDB = 0x2D, _MM_PERM_ACDC = 0x2E, _MM_PERM_ACDD = 0x2F,
_MM_PERM_ADAA = 0x30, _MM_PERM_ADAB = 0x31, _MM_PERM_ADAC = 0x32,
_MM_PERM_ADAD = 0x33, _MM_PERM_ADBA = 0x34, _MM_PERM_ADBB = 0x35,
_MM_PERM_ADBC = 0x36, _MM_PERM_ADBD = 0x37, _MM_PERM_ADCA = 0x38,
_MM_PERM_ADCB = 0x39, _MM_PERM_ADCC = 0x3A, _MM_PERM_ADCD = 0x3B,
_MM_PERM_ADDA = 0x3C, _MM_PERM_ADDB = 0x3D, _MM_PERM_ADDC = 0x3E,
_MM_PERM_ADDD = 0x3F, _MM_PERM_BAAA = 0x40, _MM_PERM_BAAB = 0x41,
_MM_PERM_BAAC = 0x42, _MM_PERM_BAAD = 0x43, _MM_PERM_BABA = 0x44,
_MM_PERM_BABB = 0x45, _MM_PERM_BABC = 0x46, _MM_PERM_BABD = 0x47,
_MM_PERM_BACA = 0x48, _MM_PERM_BACB = 0x49, _MM_PERM_BACC = 0x4A,
_MM_PERM_BACD = 0x4B, _MM_PERM_BADA = 0x4C, _MM_PERM_BADB = 0x4D,
_MM_PERM_BADC = 0x4E, _MM_PERM_BADD = 0x4F, _MM_PERM_BBAA = 0x50,
_MM_PERM_BBAB = 0x51, _MM_PERM_BBAC = 0x52, _MM_PERM_BBAD = 0x53,
_MM_PERM_BBBA = 0x54, _MM_PERM_BBBB = 0x55, _MM_PERM_BBBC = 0x56,
_MM_PERM_BBBD = 0x57, _MM_PERM_BBCA = 0x58, _MM_PERM_BBCB = 0x59,
_MM_PERM_BBCC = 0x5A, _MM_PERM_BBCD = 0x5B, _MM_PERM_BBDA = 0x5C,
_MM_PERM_BBDB = 0x5D, _MM_PERM_BBDC = 0x5E, _MM_PERM_BBDD = 0x5F,
_MM_PERM_BCAA = 0x60, _MM_PERM_BCAB = 0x61, _MM_PERM_BCAC = 0x62,
_MM_PERM_BCAD = 0x63, _MM_PERM_BCBA = 0x64, _MM_PERM_BCBB = 0x65,
_MM_PERM_BCBC = 0x66, _MM_PERM_BCBD = 0x67, _MM_PERM_BCCA = 0x68,
_MM_PERM_BCCB = 0x69, _MM_PERM_BCCC = 0x6A, _MM_PERM_BCCD = 0x6B,
_MM_PERM_BCDA = 0x6C, _MM_PERM_BCDB = 0x6D, _MM_PERM_BCDC = 0x6E,
_MM_PERM_BCDD = 0x6F, _MM_PERM_BDAA = 0x70, _MM_PERM_BDAB = 0x71,
_MM_PERM_BDAC = 0x72, _MM_PERM_BDAD = 0x73, _MM_PERM_BDBA = 0x74,
_MM_PERM_BDBB = 0x75, _MM_PERM_BDBC = 0x76, _MM_PERM_BDBD = 0x77,
_MM_PERM_BDCA = 0x78, _MM_PERM_BDCB = 0x79, _MM_PERM_BDCC = 0x7A,
_MM_PERM_BDCD = 0x7B, _MM_PERM_BDDA = 0x7C, _MM_PERM_BDDB = 0x7D,
_MM_PERM_BDDC = 0x7E, _MM_PERM_BDDD = 0x7F, _MM_PERM_CAAA = 0x80,
_MM_PERM_CAAB = 0x81, _MM_PERM_CAAC = 0x82, _MM_PERM_CAAD = 0x83,
_MM_PERM_CABA = 0x84, _MM_PERM_CABB = 0x85, _MM_PERM_CABC = 0x86,
_MM_PERM_CABD = 0x87, _MM_PERM_CACA = 0x88, _MM_PERM_CACB = 0x89,
_MM_PERM_CACC = 0x8A, _MM_PERM_CACD = 0x8B, _MM_PERM_CADA = 0x8C,
_MM_PERM_CADB = 0x8D, _MM_PERM_CADC = 0x8E, _MM_PERM_CADD = 0x8F,
_MM_PERM_CBAA = 0x90, _MM_PERM_CBAB = 0x91, _MM_PERM_CBAC = 0x92,
_MM_PERM_CBAD = 0x93, _MM_PERM_CBBA = 0x94, _MM_PERM_CBBB = 0x95,
_MM_PERM_CBBC = 0x96, _MM_PERM_CBBD = 0x97, _MM_PERM_CBCA = 0x98,
_MM_PERM_CBCB = 0x99, _MM_PERM_CBCC = 0x9A, _MM_PERM_CBCD = 0x9B,
_MM_PERM_CBDA = 0x9C, _MM_PERM_CBDB = 0x9D, _MM_PERM_CBDC = 0x9E,
_MM_PERM_CBDD = 0x9F, _MM_PERM_CCAA = 0xA0, _MM_PERM_CCAB = 0xA1,
_MM_PERM_CCAC = 0xA2, _MM_PERM_CCAD = 0xA3, _MM_PERM_CCBA = 0xA4,
_MM_PERM_CCBB = 0xA5, _MM_PERM_CCBC = 0xA6, _MM_PERM_CCBD = 0xA7,
_MM_PERM_CCCA = 0xA8, _MM_PERM_CCCB = 0xA9, _MM_PERM_CCCC = 0xAA,
_MM_PERM_CCCD = 0xAB, _MM_PERM_CCDA = 0xAC, _MM_PERM_CCDB = 0xAD,
_MM_PERM_CCDC = 0xAE, _MM_PERM_CCDD = 0xAF, _MM_PERM_CDAA = 0xB0,
_MM_PERM_CDAB = 0xB1, _MM_PERM_CDAC = 0xB2, _MM_PERM_CDAD = 0xB3,
_MM_PERM_CDBA = 0xB4, _MM_PERM_CDBB = 0xB5, _MM_PERM_CDBC = 0xB6,
_MM_PERM_CDBD = 0xB7, _MM_PERM_CDCA = 0xB8, _MM_PERM_CDCB = 0xB9,
_MM_PERM_CDCC = 0xBA, _MM_PERM_CDCD = 0xBB, _MM_PERM_CDDA = 0xBC,
_MM_PERM_CDDB = 0xBD, _MM_PERM_CDDC = 0xBE, _MM_PERM_CDDD = 0xBF,
_MM_PERM_DAAA = 0xC0, _MM_PERM_DAAB = 0xC1, _MM_PERM_DAAC = 0xC2,
_MM_PERM_DAAD = 0xC3, _MM_PERM_DABA = 0xC4, _MM_PERM_DABB = 0xC5,
_MM_PERM_DABC = 0xC6, _MM_PERM_DABD = 0xC7, _MM_PERM_DACA = 0xC8,
_MM_PERM_DACB = 0xC9, _MM_PERM_DACC = 0xCA, _MM_PERM_DACD = 0xCB,
_MM_PERM_DADA = 0xCC, _MM_PERM_DADB = 0xCD, _MM_PERM_DADC = 0xCE,
_MM_PERM_DADD = 0xCF, _MM_PERM_DBAA = 0xD0, _MM_PERM_DBAB = 0xD1,
_MM_PERM_DBAC = 0xD2, _MM_PERM_DBAD = 0xD3, _MM_PERM_DBBA = 0xD4,
_MM_PERM_DBBB = 0xD5, _MM_PERM_DBBC = 0xD6, _MM_PERM_DBBD = 0xD7,
_MM_PERM_DBCA = 0xD8, _MM_PERM_DBCB = 0xD9, _MM_PERM_DBCC = 0xDA,
_MM_PERM_DBCD = 0xDB, _MM_PERM_DBDA = 0xDC, _MM_PERM_DBDB = 0xDD,
_MM_PERM_DBDC = 0xDE, _MM_PERM_DBDD = 0xDF, _MM_PERM_DCAA = 0xE0,
_MM_PERM_DCAB = 0xE1, _MM_PERM_DCAC = 0xE2, _MM_PERM_DCAD = 0xE3,
_MM_PERM_DCBA = 0xE4, _MM_PERM_DCBB = 0xE5, _MM_PERM_DCBC = 0xE6,
_MM_PERM_DCBD = 0xE7, _MM_PERM_DCCA = 0xE8, _MM_PERM_DCCB = 0xE9,
_MM_PERM_DCCC = 0xEA, _MM_PERM_DCCD = 0xEB, _MM_PERM_DCDA = 0xEC,
_MM_PERM_DCDB = 0xED, _MM_PERM_DCDC = 0xEE, _MM_PERM_DCDD = 0xEF,
_MM_PERM_DDAA = 0xF0, _MM_PERM_DDAB = 0xF1, _MM_PERM_DDAC = 0xF2,
_MM_PERM_DDAD = 0xF3, _MM_PERM_DDBA = 0xF4, _MM_PERM_DDBB = 0xF5,
_MM_PERM_DDBC = 0xF6, _MM_PERM_DDBD = 0xF7, _MM_PERM_DDCA = 0xF8,
_MM_PERM_DDCB = 0xF9, _MM_PERM_DDCC = 0xFA, _MM_PERM_DDCD = 0xFB,
_MM_PERM_DDDA = 0xFC, _MM_PERM_DDDB = 0xFD, _MM_PERM_DDDC = 0xFE,
_MM_PERM_DDDD = 0xFF
} _MM_PERM_ENUM;
#define _mm512_shuffle_epi32(X,C) ((__m512i) __builtin_ia32_pshufd512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_undefined_si512 (), (__mmask16)-1))
#define _mm512_mask_shuffle_epi32(W,U,X,C) ((__m512i) __builtin_ia32_pshufd512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_shuffle_epi32(U,X,C) ((__m512i) __builtin_ia32_pshufd512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)(U)))
#define _mm512_shuffle_i64x2(X,Y,C) ((__m512i) __builtin_ia32_shuf_i64x2_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(C), (__v8di)(__m512i)_mm512_undefined_si512 (), (__mmask8)-1))
#define _mm512_mask_shuffle_i64x2(W,U,X,Y,C) ((__m512i) __builtin_ia32_shuf_i64x2_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(C), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_shuffle_i64x2(U,X,Y,C) ((__m512i) __builtin_ia32_shuf_i64x2_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(C), (__v8di)(__m512i)_mm512_setzero_si512 (), (__mmask8)(U)))
#define _mm512_shuffle_i32x4(X,Y,C) ((__m512i) __builtin_ia32_shuf_i32x4_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(C), (__v16si)(__m512i)_mm512_undefined_si512 (), (__mmask16)-1))
#define _mm512_mask_shuffle_i32x4(W,U,X,Y,C) ((__m512i) __builtin_ia32_shuf_i32x4_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_shuffle_i32x4(U,X,Y,C) ((__m512i) __builtin_ia32_shuf_i32x4_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)(U)))
#define _mm512_shuffle_f64x2(X,Y,C) ((__m512d) __builtin_ia32_shuf_f64x2_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(C), (__v8df)(__m512d)_mm512_undefined_pd(), (__mmask8)-1))
#define _mm512_mask_shuffle_f64x2(W,U,X,Y,C) ((__m512d) __builtin_ia32_shuf_f64x2_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(C), (__v8df)(__m512d)(W), (__mmask8)(U)))
#define _mm512_maskz_shuffle_f64x2(U,X,Y,C) ((__m512d) __builtin_ia32_shuf_f64x2_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(C), (__v8df)(__m512d)_mm512_setzero_pd(), (__mmask8)(U)))
#define _mm512_shuffle_f32x4(X,Y,C) ((__m512) __builtin_ia32_shuf_f32x4_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(C), (__v16sf)(__m512)_mm512_undefined_ps(), (__mmask16)-1))
#define _mm512_mask_shuffle_f32x4(W,U,X,Y,C) ((__m512) __builtin_ia32_shuf_f32x4_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(C), (__v16sf)(__m512)(W), (__mmask16)(U)))
#define _mm512_maskz_shuffle_f32x4(U,X,Y,C) ((__m512) __builtin_ia32_shuf_f32x4_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(C), (__v16sf)(__m512)_mm512_setzero_ps(), (__mmask16)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rolv_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rolv_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rolv_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rorv_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rorv_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rorv_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rolv_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rolv_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rolv_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_rorv_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_rorv_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_rorv_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
#define _mm512_cvtt_roundpd_epi32(A,B) ((__m256i)__builtin_ia32_cvttpd2dq512_mask(A, (__v8si)_mm256_undefined_si256(), -1, B))
#define _mm512_mask_cvtt_roundpd_epi32(W,U,A,B) ((__m256i)__builtin_ia32_cvttpd2dq512_mask(A, (__v8si)(W), U, B))
#define _mm512_maskz_cvtt_roundpd_epi32(U,A,B) ((__m256i)__builtin_ia32_cvttpd2dq512_mask(A, (__v8si)_mm256_setzero_si256(), U, B))
#define _mm512_cvtt_roundpd_epu32(A,B) ((__m256i)__builtin_ia32_cvttpd2udq512_mask(A, (__v8si)_mm256_undefined_si256(), -1, B))
#define _mm512_mask_cvtt_roundpd_epu32(W,U,A,B) ((__m256i)__builtin_ia32_cvttpd2udq512_mask(A, (__v8si)(W), U, B))
#define _mm512_maskz_cvtt_roundpd_epu32(U,A,B) ((__m256i)__builtin_ia32_cvttpd2udq512_mask(A, (__v8si)_mm256_setzero_si256(), U, B))
#define _mm512_cvt_roundpd_epi32(A,B) ((__m256i)__builtin_ia32_cvtpd2dq512_mask(A, (__v8si)_mm256_undefined_si256(), -1, B))
#define _mm512_mask_cvt_roundpd_epi32(W,U,A,B) ((__m256i)__builtin_ia32_cvtpd2dq512_mask(A, (__v8si)(W), U, B))
#define _mm512_maskz_cvt_roundpd_epi32(U,A,B) ((__m256i)__builtin_ia32_cvtpd2dq512_mask(A, (__v8si)_mm256_setzero_si256(), U, B))
#define _mm512_cvt_roundpd_epu32(A,B) ((__m256i)__builtin_ia32_cvtpd2udq512_mask(A, (__v8si)_mm256_undefined_si256(), -1, B))
#define _mm512_mask_cvt_roundpd_epu32(W,U,A,B) ((__m256i)__builtin_ia32_cvtpd2udq512_mask(A, (__v8si)(W), U, B))
#define _mm512_maskz_cvt_roundpd_epu32(U,A,B) ((__m256i)__builtin_ia32_cvtpd2udq512_mask(A, (__v8si)_mm256_setzero_si256(), U, B))
#define _mm512_cvtt_roundps_epi32(A,B) ((__m512i)__builtin_ia32_cvttps2dq512_mask(A, (__v16si)_mm512_undefined_si512 (), -1, B))
#define _mm512_mask_cvtt_roundps_epi32(W,U,A,B) ((__m512i)__builtin_ia32_cvttps2dq512_mask(A, (__v16si)(W), U, B))
#define _mm512_maskz_cvtt_roundps_epi32(U,A,B) ((__m512i)__builtin_ia32_cvttps2dq512_mask(A, (__v16si)_mm512_setzero_si512 (), U, B))
#define _mm512_cvtt_roundps_epu32(A,B) ((__m512i)__builtin_ia32_cvttps2udq512_mask(A, (__v16si)_mm512_undefined_si512 (), -1, B))
#define _mm512_mask_cvtt_roundps_epu32(W,U,A,B) ((__m512i)__builtin_ia32_cvttps2udq512_mask(A, (__v16si)(W), U, B))
#define _mm512_maskz_cvtt_roundps_epu32(U,A,B) ((__m512i)__builtin_ia32_cvttps2udq512_mask(A, (__v16si)_mm512_setzero_si512 (), U, B))
#define _mm512_cvt_roundps_epi32(A,B) ((__m512i)__builtin_ia32_cvtps2dq512_mask(A, (__v16si)_mm512_undefined_si512 (), -1, B))
#define _mm512_mask_cvt_roundps_epi32(W,U,A,B) ((__m512i)__builtin_ia32_cvtps2dq512_mask(A, (__v16si)(W), U, B))
#define _mm512_maskz_cvt_roundps_epi32(U,A,B) ((__m512i)__builtin_ia32_cvtps2dq512_mask(A, (__v16si)_mm512_setzero_si512 (), U, B))
#define _mm512_cvt_roundps_epu32(A,B) ((__m512i)__builtin_ia32_cvtps2udq512_mask(A, (__v16si)_mm512_undefined_si512 (), -1, B))
#define _mm512_mask_cvt_roundps_epu32(W,U,A,B) ((__m512i)__builtin_ia32_cvtps2udq512_mask(A, (__v16si)(W), U, B))
#define _mm512_maskz_cvt_roundps_epu32(U,A,B) ((__m512i)__builtin_ia32_cvtps2udq512_mask(A, (__v16si)_mm512_setzero_si512 (), U, B))
extern __m128d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtu32_sd (__m128d __A, unsigned __B)
;
#define _mm_cvt_roundu64_sd(A,B,C) (__m128d)__builtin_ia32_cvtusi2sd64(A, B, C)
#define _mm_cvt_roundi64_sd(A,B,C) (__m128d)__builtin_ia32_cvtsi2sd64(A, B, C)
#define _mm_cvt_roundsi64_sd(A,B,C) (__m128d)__builtin_ia32_cvtsi2sd64(A, B, C)
#define _mm_cvt_roundu32_ss(A,B,C) (__m128)__builtin_ia32_cvtusi2ss32(A, B, C)
#define _mm_cvt_roundi32_ss(A,B,C) (__m128)__builtin_ia32_cvtsi2ss32(A, B, C)
#define _mm_cvt_roundsi32_ss(A,B,C) (__m128)__builtin_ia32_cvtsi2ss32(A, B, C)
#define _mm_cvt_roundu64_ss(A,B,C) (__m128)__builtin_ia32_cvtusi2ss64(A, B, C)
#define _mm_cvt_roundi64_ss(A,B,C) (__m128)__builtin_ia32_cvtsi2ss64(A, B, C)
#define _mm_cvt_roundsi64_ss(A,B,C) (__m128)__builtin_ia32_cvtsi2ss64(A, B, C)
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi32_epi8 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi32_storeu_epi8 (void * __P, __mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi32_epi8 (__m128i __O, __mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi32_epi8 (__mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtsepi32_epi8 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi32_storeu_epi8 (void * __P, __mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi32_epi8 (__m128i __O, __mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtsepi32_epi8 (__mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtusepi32_epi8 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi32_storeu_epi8 (void * __P, __mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi32_epi8 (__m128i __O, __mmask16 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtusepi32_epi8 (__mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi32_epi16 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi32_storeu_epi16 (void * __P, __mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi32_epi16 (__m256i __O, __mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi32_epi16 (__mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtsepi32_epi16 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi32_storeu_epi16 (void *__P, __mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi32_epi16 (__m256i __O, __mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtsepi32_epi16 (__mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtusepi32_epi16 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi32_storeu_epi16 (void *__P, __mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi32_epi16 (__m256i __O, __mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtusepi32_epi16 (__mmask16 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi64_epi32 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi64_storeu_epi32 (void* __P, __mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi64_epi32 (__m256i __O, __mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi64_epi32 (__mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtsepi64_epi32 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi64_storeu_epi32 (void *__P, __mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi64_epi32 (__m256i __O, __mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtsepi64_epi32 (__mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtusepi64_epi32 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi64_storeu_epi32 (void* __P, __mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi64_epi32 (__m256i __O, __mmask8 __M, __m512i __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtusepi64_epi32 (__mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi64_epi16 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi64_storeu_epi16 (void *__P, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi64_epi16 (__m128i __O, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi64_epi16 (__mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtsepi64_epi16 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi64_storeu_epi16 (void * __P, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi64_epi16 (__m128i __O, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtsepi64_epi16 (__mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtusepi64_epi16 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi64_storeu_epi16 (void *__P, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi64_epi16 (__m128i __O, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtusepi64_epi16 (__mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi64_epi8 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi64_storeu_epi8 (void * __P, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi64_epi8 (__m128i __O, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi64_epi8 (__mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtsepi64_epi8 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi64_storeu_epi8 (void * __P, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtsepi64_epi8 (__m128i __O, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtsepi64_epi8 (__mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtusepi64_epi8 (__m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi64_storeu_epi8 (void * __P, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtusepi64_epi8 (__m128i __O, __mmask8 __M, __m512i __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtusepi64_epi8 (__mmask8 __M, __m512i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi32_pd (__m256i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi32_pd (__m512d __W, __mmask8 __U, __m256i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi32_pd (__mmask8 __U, __m256i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepu32_pd (__m256i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepu32_pd (__m512d __W, __mmask8 __U, __m256i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepu32_pd (__mmask8 __U, __m256i __A)
;
#define _mm512_cvt_roundepi32_ps(A,B) (__m512)__builtin_ia32_cvtdq2ps512_mask((__v16si)(A), (__v16sf)_mm512_undefined_ps(), -1, B)
#define _mm512_mask_cvt_roundepi32_ps(W,U,A,B) (__m512)__builtin_ia32_cvtdq2ps512_mask((__v16si)(A), W, U, B)
#define _mm512_maskz_cvt_roundepi32_ps(U,A,B) (__m512)__builtin_ia32_cvtdq2ps512_mask((__v16si)(A), (__v16sf)_mm512_setzero_ps(), U, B)
#define _mm512_cvt_roundepu32_ps(A,B) (__m512)__builtin_ia32_cvtudq2ps512_mask((__v16si)(A), (__v16sf)_mm512_undefined_ps(), -1, B)
#define _mm512_mask_cvt_roundepu32_ps(W,U,A,B) (__m512)__builtin_ia32_cvtudq2ps512_mask((__v16si)(A), W, U, B)
#define _mm512_maskz_cvt_roundepu32_ps(U,A,B) (__m512)__builtin_ia32_cvtudq2ps512_mask((__v16si)(A), (__v16sf)_mm512_setzero_ps(), U, B)
#define _mm512_extractf64x4_pd(X,C) ((__m256d) __builtin_ia32_extractf64x4_mask ((__v8df)(__m512d) (X), (int) (C), (__v4df)(__m256d)_mm256_undefined_pd(), (__mmask8)-1))
#define _mm512_mask_extractf64x4_pd(W,U,X,C) ((__m256d) __builtin_ia32_extractf64x4_mask ((__v8df)(__m512d) (X), (int) (C), (__v4df)(__m256d)(W), (__mmask8)(U)))
#define _mm512_maskz_extractf64x4_pd(U,X,C) ((__m256d) __builtin_ia32_extractf64x4_mask ((__v8df)(__m512d) (X), (int) (C), (__v4df)(__m256d)_mm256_setzero_pd(), (__mmask8)(U)))
#define _mm512_extractf32x4_ps(X,C) ((__m128) __builtin_ia32_extractf32x4_mask ((__v16sf)(__m512) (X), (int) (C), (__v4sf)(__m128)_mm_undefined_ps(), (__mmask8)-1))
#define _mm512_mask_extractf32x4_ps(W,U,X,C) ((__m128) __builtin_ia32_extractf32x4_mask ((__v16sf)(__m512) (X), (int) (C), (__v4sf)(__m128)(W), (__mmask8)(U)))
#define _mm512_maskz_extractf32x4_ps(U,X,C) ((__m128) __builtin_ia32_extractf32x4_mask ((__v16sf)(__m512) (X), (int) (C), (__v4sf)(__m128)_mm_setzero_ps(), (__mmask8)(U)))
#define _mm512_extracti64x4_epi64(X,C) ((__m256i) __builtin_ia32_extracti64x4_mask ((__v8di)(__m512i) (X), (int) (C), (__v4di)(__m256i)_mm256_undefined_si256 (), (__mmask8)-1))
#define _mm512_mask_extracti64x4_epi64(W,U,X,C) ((__m256i) __builtin_ia32_extracti64x4_mask ((__v8di)(__m512i) (X), (int) (C), (__v4di)(__m256i)(W), (__mmask8)(U)))
#define _mm512_maskz_extracti64x4_epi64(U,X,C) ((__m256i) __builtin_ia32_extracti64x4_mask ((__v8di)(__m512i) (X), (int) (C), (__v4di)(__m256i)_mm256_setzero_si256 (), (__mmask8)(U)))
#define _mm512_extracti32x4_epi32(X,C) ((__m128i) __builtin_ia32_extracti32x4_mask ((__v16si)(__m512i) (X), (int) (C), (__v4si)(__m128i)_mm_undefined_si128 (), (__mmask8)-1))
#define _mm512_mask_extracti32x4_epi32(W,U,X,C) ((__m128i) __builtin_ia32_extracti32x4_mask ((__v16si)(__m512i) (X), (int) (C), (__v4si)(__m128i)(W), (__mmask8)(U)))
#define _mm512_maskz_extracti32x4_epi32(U,X,C) ((__m128i) __builtin_ia32_extracti32x4_mask ((__v16si)(__m512i) (X), (int) (C), (__v4si)(__m128i)_mm_setzero_si128 (), (__mmask8)(U)))
#define _mm512_insertf32x4(X,Y,C) ((__m512) __builtin_ia32_insertf32x4_mask ((__v16sf)(__m512) (X), (__v4sf)(__m128) (Y), (int) (C), (__v16sf)(__m512) (X), (__mmask16)(-1)))
#define _mm512_inserti32x4(X,Y,C) ((__m512i) __builtin_ia32_inserti32x4_mask ((__v16si)(__m512i) (X), (__v4si)(__m128i) (Y), (int) (C), (__v16si)(__m512i) (X), (__mmask16)(-1)))
#define _mm512_insertf64x4(X,Y,C) ((__m512d) __builtin_ia32_insertf64x4_mask ((__v8df)(__m512d) (X), (__v4df)(__m256d) (Y), (int) (C), (__v8df)(__m512d)_mm512_undefined_pd(), (__mmask8)-1))
#define _mm512_mask_insertf64x4(W,U,X,Y,C) ((__m512d) __builtin_ia32_insertf64x4_mask ((__v8df)(__m512d) (X), (__v4df)(__m256d) (Y), (int) (C), (__v8df)(__m512d)(W), (__mmask8)(U)))
#define _mm512_maskz_insertf64x4(U,X,Y,C) ((__m512d) __builtin_ia32_insertf64x4_mask ((__v8df)(__m512d) (X), (__v4df)(__m256d) (Y), (int) (C), (__v8df)(__m512d)_mm512_setzero_pd(), (__mmask8)(U)))
#define _mm512_inserti64x4(X,Y,C) ((__m512i) __builtin_ia32_inserti64x4_mask ((__v8di)(__m512i) (X), (__v4di)(__m256i) (Y), (int) (C), (__v8di)(__m512i)_mm512_undefined_si512 (), (__mmask8)-1))
#define _mm512_mask_inserti64x4(W,U,X,Y,C) ((__m512i) __builtin_ia32_inserti64x4_mask ((__v8di)(__m512i) (X), (__v4di)(__m256i) (Y), (int) (C), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_inserti64x4(U,X,Y,C) ((__m512i) __builtin_ia32_inserti64x4_mask ((__v8di)(__m512i) (X), (__v4di)(__m256i) (Y), (int) (C), (__v8di)(__m512i)_mm512_setzero_si512 (), (__mmask8)(U)))
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_loadu_pd (void const *__P)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_loadu_pd (__m512d __W, __mmask8 __U, void const *__P)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_loadu_pd (__mmask8 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_storeu_pd (void *__P, __m512d __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_storeu_pd (void *__P, __mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_loadu_ps (void const *__P)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_loadu_ps (__m512 __W, __mmask16 __U, void const *__P)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_loadu_ps (__mmask16 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_storeu_ps (void *__P, __m512 __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_storeu_ps (void *__P, __mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_loadu_epi64 (__m512i __W, __mmask8 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_loadu_epi64 (__mmask8 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_storeu_epi64 (void *__P, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_loadu_si512 (void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_loadu_epi32 (__m512i __W, __mmask16 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_loadu_epi32 (__mmask16 __U, void const *__P)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_storeu_si512 (void *__P, __m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_storeu_epi32 (void *__P, __mmask16 __U, __m512i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutevar_pd (__m512d __A, __m512i __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutevar_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512i __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutevar_pd (__mmask8 __U, __m512d __A, __m512i __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutevar_ps (__m512 __A, __m512i __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutevar_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512i __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutevar_ps (__mmask16 __U, __m512 __A, __m512i __C)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutex2var_epi64 (__m512i __A, __m512i __I, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutex2var_epi64 (__m512i __A, __mmask8 __U, __m512i __I,
__m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask2_permutex2var_epi64 (__m512i __A, __m512i __I,
__mmask8 __U, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutex2var_epi64 (__mmask8 __U, __m512i __A,
__m512i __I, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutex2var_epi32 (__m512i __A, __m512i __I, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutex2var_epi32 (__m512i __A, __mmask16 __U,
__m512i __I, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask2_permutex2var_epi32 (__m512i __A, __m512i __I,
__mmask16 __U, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutex2var_epi32 (__mmask16 __U, __m512i __A,
__m512i __I, __m512i __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutex2var_pd (__m512d __A, __m512i __I, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutex2var_pd (__m512d __A, __mmask8 __U, __m512i __I,
__m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask2_permutex2var_pd (__m512d __A, __m512i __I, __mmask8 __U,
__m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutex2var_pd (__mmask8 __U, __m512d __A, __m512i __I,
__m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutex2var_ps (__m512 __A, __m512i __I, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutex2var_ps (__m512 __A, __mmask16 __U, __m512i __I, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask2_permutex2var_ps (__m512 __A, __m512i __I, __mmask16 __U,
__m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutex2var_ps (__mmask16 __U, __m512 __A, __m512i __I,
__m512 __B)
;
#define _mm512_permute_pd(X,C) ((__m512d) __builtin_ia32_vpermilpd512_mask ((__v8df)(__m512d)(X), (int)(C), (__v8df)(__m512d)_mm512_undefined_pd(), (__mmask8)(-1)))
#define _mm512_mask_permute_pd(W,U,X,C) ((__m512d) __builtin_ia32_vpermilpd512_mask ((__v8df)(__m512d)(X), (int)(C), (__v8df)(__m512d)(W), (__mmask8)(U)))
#define _mm512_maskz_permute_pd(U,X,C) ((__m512d) __builtin_ia32_vpermilpd512_mask ((__v8df)(__m512d)(X), (int)(C), (__v8df)(__m512d)_mm512_setzero_pd(), (__mmask8)(U)))
#define _mm512_permute_ps(X,C) ((__m512) __builtin_ia32_vpermilps512_mask ((__v16sf)(__m512)(X), (int)(C), (__v16sf)(__m512)_mm512_undefined_ps(), (__mmask16)(-1)))
#define _mm512_mask_permute_ps(W,U,X,C) ((__m512) __builtin_ia32_vpermilps512_mask ((__v16sf)(__m512)(X), (int)(C), (__v16sf)(__m512)(W), (__mmask16)(U)))
#define _mm512_maskz_permute_ps(U,X,C) ((__m512) __builtin_ia32_vpermilps512_mask ((__v16sf)(__m512)(X), (int)(C), (__v16sf)(__m512)_mm512_setzero_ps(), (__mmask16)(U)))
#define _mm512_permutex_pd(X,M) ((__m512d) __builtin_ia32_permdf512_mask ((__v8df)(__m512d)(X), (int)(M), (__v8df)(__m512d)_mm512_undefined_pd(), (__mmask8)-1))
#define _mm512_mask_permutex_pd(W,U,X,M) ((__m512d) __builtin_ia32_permdf512_mask ((__v8df)(__m512d)(X), (int)(M), (__v8df)(__m512d)(W), (__mmask8)(U)))
#define _mm512_maskz_permutex_pd(U,X,M) ((__m512d) __builtin_ia32_permdf512_mask ((__v8df)(__m512d)(X), (int)(M), (__v8df)(__m512d)_mm512_setzero_pd(), (__mmask8)(U)))
#define _mm512_permutex_epi64(X,I) ((__m512i) __builtin_ia32_permdi512_mask ((__v8di)(__m512i)(X), (int)(I), (__v8di)(__m512i) (_mm512_undefined_si512 ()), (__mmask8)(-1)))
#define _mm512_maskz_permutex_epi64(M,X,I) ((__m512i) __builtin_ia32_permdi512_mask ((__v8di)(__m512i)(X), (int)(I), (__v8di)(__m512i) (_mm512_setzero_si512 ()), (__mmask8)(M)))
#define _mm512_mask_permutex_epi64(W,M,X,I) ((__m512i) __builtin_ia32_permdi512_mask ((__v8di)(__m512i)(X), (int)(I), (__v8di)(__m512i)(W), (__mmask8)(M)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutexvar_epi64 (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutexvar_epi64 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutexvar_epi64 (__m512i __W, __mmask8 __M, __m512i __X,
__m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutexvar_epi32 (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutexvar_epi32 (__m512i __X, __m512i __Y)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutexvar_epi32 (__m512i __W, __mmask16 __M, __m512i __X,
__m512i __Y)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutexvar_pd (__m512i __X, __m512d __Y)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutexvar_pd (__m512d __W, __mmask8 __U, __m512i __X, __m512d __Y)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutexvar_pd (__mmask8 __U, __m512i __X, __m512d __Y)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_permutexvar_ps (__m512i __X, __m512 __Y)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_permutexvar_ps (__m512 __W, __mmask16 __U, __m512i __X, __m512 __Y)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_permutexvar_ps (__mmask16 __U, __m512i __X, __m512 __Y)
;
#define _mm512_shuffle_pd(X,Y,C) ((__m512d)__builtin_ia32_shufpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(C), (__v8df)(__m512d)_mm512_undefined_pd(), (__mmask8)-1))
#define _mm512_mask_shuffle_pd(W,U,X,Y,C) ((__m512d)__builtin_ia32_shufpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(C), (__v8df)(__m512d)(W), (__mmask8)(U)))
#define _mm512_maskz_shuffle_pd(U,X,Y,C) ((__m512d)__builtin_ia32_shufpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(C), (__v8df)(__m512d)_mm512_setzero_pd(), (__mmask8)(U)))
#define _mm512_shuffle_ps(X,Y,C) ((__m512)__builtin_ia32_shufps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(C), (__v16sf)(__m512)_mm512_undefined_ps(), (__mmask16)-1))
#define _mm512_mask_shuffle_ps(W,U,X,Y,C) ((__m512)__builtin_ia32_shufps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(C), (__v16sf)(__m512)(W), (__mmask16)(U)))
#define _mm512_maskz_shuffle_ps(U,X,Y,C) ((__m512)__builtin_ia32_shufps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(C), (__v16sf)(__m512)_mm512_setzero_ps(), (__mmask16)(U)))
#define _mm512_fixupimm_round_pd(X,Y,Z,C,R) ((__m512d)__builtin_ia32_fixupimmpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (__v8di)(__m512i)(Z), (int)(C), (__mmask8)(-1), (R)))
#define _mm512_mask_fixupimm_round_pd(X,U,Y,Z,C,R) ((__m512d)__builtin_ia32_fixupimmpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (__v8di)(__m512i)(Z), (int)(C), (__mmask8)(U), (R)))
#define _mm512_maskz_fixupimm_round_pd(U,X,Y,Z,C,R) ((__m512d)__builtin_ia32_fixupimmpd512_maskz ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (__v8di)(__m512i)(Z), (int)(C), (__mmask8)(U), (R)))
#define _mm512_fixupimm_round_ps(X,Y,Z,C,R) ((__m512)__builtin_ia32_fixupimmps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(-1), (R)))
#define _mm512_mask_fixupimm_round_ps(X,U,Y,Z,C,R) ((__m512)__builtin_ia32_fixupimmps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(U), (R)))
#define _mm512_maskz_fixupimm_round_ps(U,X,Y,Z,C,R) ((__m512)__builtin_ia32_fixupimmps512_maskz ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(U), (R)))
#define _mm_fixupimm_round_sd(X,Y,Z,C,R) ((__m128d)__builtin_ia32_fixupimmsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(-1), (R)))
#define _mm_mask_fixupimm_round_sd(X,U,Y,Z,C,R) ((__m128d)__builtin_ia32_fixupimmsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(U), (R)))
#define _mm_maskz_fixupimm_round_sd(U,X,Y,Z,C,R) ((__m128d)__builtin_ia32_fixupimmsd_maskz ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(U), (R)))
#define _mm_fixupimm_round_ss(X,Y,Z,C,R) ((__m128)__builtin_ia32_fixupimmss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(-1), (R)))
#define _mm_mask_fixupimm_round_ss(X,U,Y,Z,C,R) ((__m128)__builtin_ia32_fixupimmss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(U), (R)))
#define _mm_maskz_fixupimm_round_ss(U,X,Y,Z,C,R) ((__m128)__builtin_ia32_fixupimmss_maskz ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(U), (R)))
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_movehdup_ps (__m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_movehdup_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_movehdup_ps (__mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_moveldup_ps (__m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_moveldup_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_moveldup_ps (__mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_or_si512 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_or_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_or_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_or_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_or_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_or_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_or_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_xor_si512 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_xor_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_xor_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_xor_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_xor_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_xor_epi64 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_xor_epi64 (__mmask16 __U, __m512i __A, __m512i __B)
;
#define _mm512_rol_epi32(A,B) ((__m512i)__builtin_ia32_prold512_mask ((__v16si)(__m512i)(A), (int)(B), (__v16si)_mm512_undefined_si512 (), (__mmask16)(-1)))
#define _mm512_mask_rol_epi32(W,U,A,B) ((__m512i)__builtin_ia32_prold512_mask ((__v16si)(__m512i)(A), (int)(B), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_rol_epi32(U,A,B) ((__m512i)__builtin_ia32_prold512_mask ((__v16si)(__m512i)(A), (int)(B), (__v16si)_mm512_setzero_si512 (), (__mmask16)(U)))
#define _mm512_ror_epi32(A,B) ((__m512i)__builtin_ia32_prord512_mask ((__v16si)(__m512i)(A), (int)(B), (__v16si)_mm512_undefined_si512 (), (__mmask16)(-1)))
#define _mm512_mask_ror_epi32(W,U,A,B) ((__m512i)__builtin_ia32_prord512_mask ((__v16si)(__m512i)(A), (int)(B), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_ror_epi32(U,A,B) ((__m512i)__builtin_ia32_prord512_mask ((__v16si)(__m512i)(A), (int)(B), (__v16si)_mm512_setzero_si512 (), (__mmask16)(U)))
#define _mm512_rol_epi64(A,B) ((__m512i)__builtin_ia32_prolq512_mask ((__v8di)(__m512i)(A), (int)(B), (__v8di)_mm512_undefined_si512 (), (__mmask8)(-1)))
#define _mm512_mask_rol_epi64(W,U,A,B) ((__m512i)__builtin_ia32_prolq512_mask ((__v8di)(__m512i)(A), (int)(B), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_rol_epi64(U,A,B) ((__m512i)__builtin_ia32_prolq512_mask ((__v8di)(__m512i)(A), (int)(B), (__v8di)_mm512_setzero_si512 (), (__mmask8)(U)))
#define _mm512_ror_epi64(A,B) ((__m512i)__builtin_ia32_prorq512_mask ((__v8di)(__m512i)(A), (int)(B), (__v8di)_mm512_undefined_si512 (), (__mmask8)(-1)))
#define _mm512_mask_ror_epi64(W,U,A,B) ((__m512i)__builtin_ia32_prorq512_mask ((__v8di)(__m512i)(A), (int)(B), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_ror_epi64(U,A,B) ((__m512i)__builtin_ia32_prorq512_mask ((__v8di)(__m512i)(A), (int)(B), (__v8di)_mm512_setzero_si512 (), (__mmask8)(U)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_and_si512 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_and_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_and_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_and_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_and_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_and_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_and_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_andnot_si512 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_andnot_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_andnot_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_andnot_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_andnot_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_andnot_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_andnot_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_test_epi32_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_test_epi32_mask (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_test_epi64_mask (__m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_test_epi64_mask (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_testn_epi32_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_testn_epi32_mask (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_testn_epi64_mask (__m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_testn_epi64_mask (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpackhi_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpackhi_epi32 (__m512i __W, __mmask16 __U, __m512i __A,
__m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpackhi_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpackhi_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpackhi_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpackhi_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpacklo_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpacklo_epi32 (__m512i __W, __mmask16 __U, __m512i __A,
__m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpacklo_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpacklo_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpacklo_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpacklo_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
;
#define _mm_cvt_roundss_u64(A,B) ((unsigned long long)__builtin_ia32_vcvtss2usi64(A, B))
#define _mm_cvt_roundss_si64(A,B) ((long long)__builtin_ia32_vcvtss2si64(A, B))
#define _mm_cvt_roundss_i64(A,B) ((long long)__builtin_ia32_vcvtss2si64(A, B))
#define _mm_cvtt_roundss_u64(A,B) ((unsigned long long)__builtin_ia32_vcvttss2usi64(A, B))
#define _mm_cvtt_roundss_i64(A,B) ((long long)__builtin_ia32_vcvttss2si64(A, B))
#define _mm_cvtt_roundss_si64(A,B) ((long long)__builtin_ia32_vcvttss2si64(A, B))
#define _mm_cvt_roundss_u32(A,B) ((unsigned)__builtin_ia32_vcvtss2usi32(A, B))
#define _mm_cvt_roundss_si32(A,B) ((int)__builtin_ia32_vcvtss2si32(A, B))
#define _mm_cvt_roundss_i32(A,B) ((int)__builtin_ia32_vcvtss2si32(A, B))
#define _mm_cvtt_roundss_u32(A,B) ((unsigned)__builtin_ia32_vcvttss2usi32(A, B))
#define _mm_cvtt_roundss_si32(A,B) ((int)__builtin_ia32_vcvttss2si32(A, B))
#define _mm_cvtt_roundss_i32(A,B) ((int)__builtin_ia32_vcvttss2si32(A, B))
#define _mm_cvt_roundsd_u64(A,B) ((unsigned long long)__builtin_ia32_vcvtsd2usi64(A, B))
#define _mm_cvt_roundsd_si64(A,B) ((long long)__builtin_ia32_vcvtsd2si64(A, B))
#define _mm_cvt_roundsd_i64(A,B) ((long long)__builtin_ia32_vcvtsd2si64(A, B))
#define _mm_cvtt_roundsd_u64(A,B) ((unsigned long long)__builtin_ia32_vcvttsd2usi64(A, B))
#define _mm_cvtt_roundsd_si64(A,B) ((long long)__builtin_ia32_vcvttsd2si64(A, B))
#define _mm_cvtt_roundsd_i64(A,B) ((long long)__builtin_ia32_vcvttsd2si64(A, B))
#define _mm_cvt_roundsd_u32(A,B) ((unsigned)__builtin_ia32_vcvtsd2usi32(A, B))
#define _mm_cvt_roundsd_si32(A,B) ((int)__builtin_ia32_vcvtsd2si32(A, B))
#define _mm_cvt_roundsd_i32(A,B) ((int)__builtin_ia32_vcvtsd2si32(A, B))
#define _mm_cvtt_roundsd_u32(A,B) ((unsigned)__builtin_ia32_vcvttsd2usi32(A, B))
#define _mm_cvtt_roundsd_si32(A,B) ((int)__builtin_ia32_vcvttsd2si32(A, B))
#define _mm_cvtt_roundsd_i32(A,B) ((int)__builtin_ia32_vcvttsd2si32(A, B))
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_movedup_pd (__m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_movedup_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_movedup_pd (__mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpacklo_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpacklo_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpacklo_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpackhi_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpackhi_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpackhi_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpackhi_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpackhi_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpackhi_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
#define _mm512_cvt_roundps_pd(A,B) (__m512d)__builtin_ia32_cvtps2pd512_mask(A, (__v8df)_mm512_undefined_pd(), -1, B)
#define _mm512_mask_cvt_roundps_pd(W,U,A,B) (__m512d)__builtin_ia32_cvtps2pd512_mask(A, (__v8df)(W), U, B)
#define _mm512_maskz_cvt_roundps_pd(U,A,B) (__m512d)__builtin_ia32_cvtps2pd512_mask(A, (__v8df)_mm512_setzero_pd(), U, B)
#define _mm512_cvt_roundph_ps(A,B) (__m512)__builtin_ia32_vcvtph2ps512_mask((__v16hi)(A), (__v16sf)_mm512_undefined_ps(), -1, B)
#define _mm512_mask_cvt_roundph_ps(W,U,A,B) (__m512)__builtin_ia32_vcvtph2ps512_mask((__v16hi)(A), (__v16sf)(W), U, B)
#define _mm512_maskz_cvt_roundph_ps(U,A,B) (__m512)__builtin_ia32_vcvtph2ps512_mask((__v16hi)(A), (__v16sf)_mm512_setzero_ps(), U, B)
#define _mm512_cvt_roundps_ph(A,I) ((__m256i) __builtin_ia32_vcvtps2ph512_mask ((__v16sf)(__m512) A, (int) (I), (__v16hi)_mm256_undefined_si256 (), -1))
#define _mm512_cvtps_ph(A,I) ((__m256i) __builtin_ia32_vcvtps2ph512_mask ((__v16sf)(__m512) A, (int) (I), (__v16hi)_mm256_undefined_si256 (), -1))
#define _mm512_mask_cvt_roundps_ph(U,W,A,I) ((__m256i) __builtin_ia32_vcvtps2ph512_mask ((__v16sf)(__m512) A, (int) (I), (__v16hi)(__m256i)(U), (__mmask16) (W)))
#define _mm512_mask_cvtps_ph(U,W,A,I) ((__m256i) __builtin_ia32_vcvtps2ph512_mask ((__v16sf)(__m512) A, (int) (I), (__v16hi)(__m256i)(U), (__mmask16) (W)))
#define _mm512_maskz_cvt_roundps_ph(W,A,I) ((__m256i) __builtin_ia32_vcvtps2ph512_mask ((__v16sf)(__m512) A, (int) (I), (__v16hi)_mm256_setzero_si256 (), (__mmask16) (W)))
#define _mm512_maskz_cvtps_ph(W,A,I) ((__m256i) __builtin_ia32_vcvtps2ph512_mask ((__v16sf)(__m512) A, (int) (I), (__v16hi)_mm256_setzero_si256 (), (__mmask16) (W)))
#define _mm512_cvt_roundpd_ps(A,B) (__m256)__builtin_ia32_cvtpd2ps512_mask(A, (__v8sf)_mm256_undefined_ps(), -1, B)
#define _mm512_mask_cvt_roundpd_ps(W,U,A,B) (__m256)__builtin_ia32_cvtpd2ps512_mask(A, (__v8sf)(W), U, B)
#define _mm512_maskz_cvt_roundpd_ps(U,A,B) (__m256)__builtin_ia32_cvtpd2ps512_mask(A, (__v8sf)_mm256_setzero_ps(), U, B)
#define _mm_cvt_roundsd_ss(A,B,C) (__m128)__builtin_ia32_cvtsd2ss_round(A, B, C)
#define _mm_cvt_roundss_sd(A,B,C) (__m128d)__builtin_ia32_cvtss2sd_round(A, B, C)
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_stream_si512 (__m512i * __P, __m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_stream_ps (float *__P, __m512 __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_stream_pd (double *__P, __m512d __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_stream_load_si512 (void *__P)
;
typedef enum
{
_MM_MANT_NORM_1_2,
_MM_MANT_NORM_p5_2,
_MM_MANT_NORM_p5_1,
_MM_MANT_NORM_p75_1p5
} _MM_MANTISSA_NORM_ENUM;
typedef enum
{
_MM_MANT_SIGN_src,
_MM_MANT_SIGN_zero,
_MM_MANT_SIGN_nan
} _MM_MANTISSA_SIGN_ENUM;
#define _mm512_getmant_round_pd(X,B,C,R) ((__m512d)__builtin_ia32_getmantpd512_mask ((__v8df)(__m512d)(X), (int)(((C)<<2) | (B)), (__v8df)(__m512d)_mm512_undefined_pd(), (__mmask8)-1, (R)))
#define _mm512_mask_getmant_round_pd(W,U,X,B,C,R) ((__m512d)__builtin_ia32_getmantpd512_mask ((__v8df)(__m512d)(X), (int)(((C)<<2) | (B)), (__v8df)(__m512d)(W), (__mmask8)(U), (R)))
#define _mm512_maskz_getmant_round_pd(U,X,B,C,R) ((__m512d)__builtin_ia32_getmantpd512_mask ((__v8df)(__m512d)(X), (int)(((C)<<2) | (B)), (__v8df)(__m512d)_mm512_setzero_pd(), (__mmask8)(U), (R)))
#define _mm512_getmant_round_ps(X,B,C,R) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)(__m512)_mm512_undefined_ps(), (__mmask16)-1, (R)))
#define _mm512_mask_getmant_round_ps(W,U,X,B,C,R) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)(__m512)(W), (__mmask16)(U), (R)))
#define _mm512_maskz_getmant_round_ps(U,X,B,C,R) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)(__m512)_mm512_setzero_ps(), (__mmask16)(U), (R)))
#define _mm_getmant_round_sd(X,Y,C,D,R) ((__m128d)__builtin_ia32_getmantsd_round ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(((D)<<2) | (C)), (R)))
#define _mm_getmant_round_ss(X,Y,C,D,R) ((__m128)__builtin_ia32_getmantss_round ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(((D)<<2) | (C)), (R)))
#define _mm_getexp_round_ss(A,B,R) ((__m128)__builtin_ia32_getexpss128_round((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), R))
#define _mm_getexp_round_sd(A,B,R) ((__m128d)__builtin_ia32_getexpsd128_round((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), R))
#define _mm512_getexp_round_ps(A,R) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)_mm512_undefined_ps(), (__mmask16)-1, R))
#define _mm512_mask_getexp_round_ps(W,U,A,R) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)(__m512)(W), (__mmask16)(U), R))
#define _mm512_maskz_getexp_round_ps(U,A,R) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)_mm512_setzero_ps(), (__mmask16)(U), R))
#define _mm512_getexp_round_pd(A,R) ((__m512d)__builtin_ia32_getexppd512_mask((__v8df)(__m512d)(A), (__v8df)_mm512_undefined_pd(), (__mmask8)-1, R))
#define _mm512_mask_getexp_round_pd(W,U,A,R) ((__m512d)__builtin_ia32_getexppd512_mask((__v8df)(__m512d)(A), (__v8df)(__m512d)(W), (__mmask8)(U), R))
#define _mm512_maskz_getexp_round_pd(U,A,R) ((__m512d)__builtin_ia32_getexppd512_mask((__v8df)(__m512d)(A), (__v8df)_mm512_setzero_pd(), (__mmask8)(U), R))
#define _mm512_roundscale_round_ps(A,B,R) ((__m512) __builtin_ia32_rndscaleps_mask ((__v16sf)(__m512)(A), (int)(B), (__v16sf)_mm512_undefined_ps(), (__mmask16)(-1), R))
#define _mm512_mask_roundscale_round_ps(A,B,C,D,R) ((__m512) __builtin_ia32_rndscaleps_mask ((__v16sf)(__m512)(C), (int)(D), (__v16sf)(__m512)(A), (__mmask16)(B), R))
#define _mm512_maskz_roundscale_round_ps(A,B,C,R) ((__m512) __builtin_ia32_rndscaleps_mask ((__v16sf)(__m512)(B), (int)(C), (__v16sf)_mm512_setzero_ps(), (__mmask16)(A), R))
#define _mm512_roundscale_round_pd(A,B,R) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(A), (int)(B), (__v8df)_mm512_undefined_pd(), (__mmask8)(-1), R))
#define _mm512_mask_roundscale_round_pd(A,B,C,D,R) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(C), (int)(D), (__v8df)(__m512d)(A), (__mmask8)(B), R))
#define _mm512_maskz_roundscale_round_pd(A,B,C,R) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(B), (int)(C), (__v8df)_mm512_setzero_pd(), (__mmask8)(A), R))
#define _mm_roundscale_round_ss(A,B,C,R) ((__m128) __builtin_ia32_rndscaless_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), R))
#define _mm_roundscale_round_sd(A,B,C,R) ((__m128d) __builtin_ia32_rndscalesd_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), R))
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_floor_ps (__m512 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_floor_pd (__m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_ceil_ps (__m512 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_ceil_pd (__m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_floor_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_floor_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_ceil_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_ceil_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
#define _mm512_alignr_epi32(X,Y,C) ((__m512i)__builtin_ia32_alignd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(C), (__v16si)_mm512_undefined_si512 (), (__mmask16)-1))
#define _mm512_mask_alignr_epi32(W,U,X,Y,C) ((__m512i)__builtin_ia32_alignd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
#define _mm512_maskz_alignr_epi32(U,X,Y,C) ((__m512i)__builtin_ia32_alignd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(C), (__v16si)_mm512_setzero_si512 (), (__mmask16)(U)))
#define _mm512_alignr_epi64(X,Y,C) ((__m512i)__builtin_ia32_alignq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(C), (__v8di)_mm512_undefined_si512 (), (__mmask8)-1))
#define _mm512_mask_alignr_epi64(W,U,X,Y,C) ((__m512i)__builtin_ia32_alignq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(C), (__v8di)(__m512i)(W), (__mmask8)(U)))
#define _mm512_maskz_alignr_epi64(U,X,Y,C) ((__m512i)__builtin_ia32_alignq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(C), (__v8di)_mm512_setzero_si512 (), (__mmask8)(U)))
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpeq_epi32_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpeq_epi32_mask (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpeq_epi64_mask (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpeq_epi64_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpgt_epi32_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpgt_epi32_mask (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpgt_epi64_mask (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpgt_epi64_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpge_epi32_mask (__m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpge_epi32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpge_epu32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpge_epu32_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpge_epi64_mask (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpge_epi64_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpge_epu64_mask (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpge_epu64_mask (__m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmple_epi32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmple_epi32_mask (__m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmple_epu32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmple_epu32_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmple_epi64_mask (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmple_epi64_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmple_epu64_mask (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmple_epu64_mask (__m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmplt_epi32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmplt_epi32_mask (__m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmplt_epu32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmplt_epu32_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmplt_epi64_mask (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmplt_epi64_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmplt_epu64_mask (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmplt_epu64_mask (__m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpneq_epi32_mask (__m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpneq_epi32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpneq_epu32_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpneq_epu32_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpneq_epi64_mask (__mmask16 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpneq_epi64_mask (__m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpneq_epu64_mask (__mmask8 __M, __m512i __X, __m512i __Y)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpneq_epu64_mask (__m512i __X, __m512i __Y)
;
#define _MM_CMPINT_EQ 0x0
#define _MM_CMPINT_LT 0x1
#define _MM_CMPINT_LE 0x2
#define _MM_CMPINT_UNUSED 0x3
#define _MM_CMPINT_NE 0x4
#define _MM_CMPINT_NLT 0x5
#define _MM_CMPINT_GE 0x5
#define _MM_CMPINT_NLE 0x6
#define _MM_CMPINT_GT 0x6
#define _mm512_cmp_epi64_mask(X,Y,P) ((__mmask8) __builtin_ia32_cmpq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(P), (__mmask8)-1))
#define _mm512_cmp_epi32_mask(X,Y,P) ((__mmask8) __builtin_ia32_cmpd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(P), (__mmask16)-1))
#define _mm512_cmp_epu64_mask(X,Y,P) ((__mmask8) __builtin_ia32_ucmpq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(P), (__mmask8)-1))
#define _mm512_cmp_epu32_mask(X,Y,P) ((__mmask8) __builtin_ia32_ucmpd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(P), (__mmask16)-1))
#define _mm512_cmp_round_pd_mask(X,Y,P,R) ((__mmask8) __builtin_ia32_cmppd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(P), (__mmask8)-1, R))
#define _mm512_cmp_round_ps_mask(X,Y,P,R) ((__mmask16) __builtin_ia32_cmpps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(P), (__mmask16)-1, R))
#define _mm512_mask_cmp_epi64_mask(M,X,Y,P) ((__mmask8) __builtin_ia32_cmpq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(P), (__mmask8)M))
#define _mm512_mask_cmp_epi32_mask(M,X,Y,P) ((__mmask8) __builtin_ia32_cmpd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(P), (__mmask16)M))
#define _mm512_mask_cmp_epu64_mask(M,X,Y,P) ((__mmask8) __builtin_ia32_ucmpq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(P), (__mmask8)M))
#define _mm512_mask_cmp_epu32_mask(M,X,Y,P) ((__mmask8) __builtin_ia32_ucmpd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(P), (__mmask16)M))
#define _mm512_mask_cmp_round_pd_mask(M,X,Y,P,R) ((__mmask8) __builtin_ia32_cmppd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(P), (__mmask8)M, R))
#define _mm512_mask_cmp_round_ps_mask(M,X,Y,P,R) ((__mmask16) __builtin_ia32_cmpps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(P), (__mmask16)M, R))
#define _mm_cmp_round_sd_mask(X,Y,P,R) ((__mmask8) __builtin_ia32_cmpsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P), (__mmask8)-1, R))
#define _mm_mask_cmp_round_sd_mask(M,X,Y,P,R) ((__mmask8) __builtin_ia32_cmpsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P), (M), R))
#define _mm_cmp_round_ss_mask(X,Y,P,R) ((__mmask8) __builtin_ia32_cmpss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P), (__mmask8)-1, R))
#define _mm_mask_cmp_round_ss_mask(M,X,Y,P,R) ((__mmask8) __builtin_ia32_cmpss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P), (M), R))
#define _mm512_i32gather_ps(INDEX,ADDR,SCALE) (__m512) __builtin_ia32_gathersiv16sf ((__v16sf)_mm512_undefined_ps(), (float const *)ADDR, (__v16si)(__m512i)INDEX, (__mmask16)0xFFFF, (int)SCALE)
#define _mm512_mask_i32gather_ps(V1OLD,MASK,INDEX,ADDR,SCALE) (__m512) __builtin_ia32_gathersiv16sf ((__v16sf)(__m512)V1OLD, (float const *)ADDR, (__v16si)(__m512i)INDEX, (__mmask16)MASK, (int)SCALE)
#define _mm512_i32gather_pd(INDEX,ADDR,SCALE) (__m512d) __builtin_ia32_gathersiv8df ((__v8df)_mm512_undefined_pd(), (double const *)ADDR, (__v8si)(__m256i)INDEX, (__mmask8)0xFF, (int)SCALE)
#define _mm512_mask_i32gather_pd(V1OLD,MASK,INDEX,ADDR,SCALE) (__m512d) __builtin_ia32_gathersiv8df ((__v8df)(__m512d)V1OLD, (double const *)ADDR, (__v8si)(__m256i)INDEX, (__mmask8)MASK, (int)SCALE)
#define _mm512_i64gather_ps(INDEX,ADDR,SCALE) (__m256) __builtin_ia32_gatherdiv16sf ((__v8sf)_mm256_undefined_ps(), (float const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)0xFF, (int)SCALE)
#define _mm512_mask_i64gather_ps(V1OLD,MASK,INDEX,ADDR,SCALE) (__m256) __builtin_ia32_gatherdiv16sf ((__v8sf)(__m256)V1OLD, (float const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)MASK, (int)SCALE)
#define _mm512_i64gather_pd(INDEX,ADDR,SCALE) (__m512d) __builtin_ia32_gatherdiv8df ((__v8df)_mm512_undefined_pd(), (double const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)0xFF, (int)SCALE)
#define _mm512_mask_i64gather_pd(V1OLD,MASK,INDEX,ADDR,SCALE) (__m512d) __builtin_ia32_gatherdiv8df ((__v8df)(__m512d)V1OLD, (double const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)MASK, (int)SCALE)
#define _mm512_i32gather_epi32(INDEX,ADDR,SCALE) (__m512i) __builtin_ia32_gathersiv16si ((__v16si)_mm512_undefined_si512 (), (int const *)ADDR, (__v16si)(__m512i)INDEX, (__mmask16)0xFFFF, (int)SCALE)
#define _mm512_mask_i32gather_epi32(V1OLD,MASK,INDEX,ADDR,SCALE) (__m512i) __builtin_ia32_gathersiv16si ((__v16si)(__m512i)V1OLD, (int const *)ADDR, (__v16si)(__m512i)INDEX, (__mmask16)MASK, (int)SCALE)
#define _mm512_i32gather_epi64(INDEX,ADDR,SCALE) (__m512i) __builtin_ia32_gathersiv8di ((__v8di)_mm512_undefined_si512 (), (long long const *)ADDR, (__v8si)(__m256i)INDEX, (__mmask8)0xFF, (int)SCALE)
#define _mm512_mask_i32gather_epi64(V1OLD,MASK,INDEX,ADDR,SCALE) (__m512i) __builtin_ia32_gathersiv8di ((__v8di)(__m512i)V1OLD, (long long const *)ADDR, (__v8si)(__m256i)INDEX, (__mmask8)MASK, (int)SCALE)
#define _mm512_i64gather_epi32(INDEX,ADDR,SCALE) (__m256i) __builtin_ia32_gatherdiv16si ((__v8si)_mm256_undefined_si256(), (int const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)0xFF, (int)SCALE)
#define _mm512_mask_i64gather_epi32(V1OLD,MASK,INDEX,ADDR,SCALE) (__m256i) __builtin_ia32_gatherdiv16si ((__v8si)(__m256i)V1OLD, (int const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)MASK, (int)SCALE)
#define _mm512_i64gather_epi64(INDEX,ADDR,SCALE) (__m512i) __builtin_ia32_gatherdiv8di ((__v8di)_mm512_undefined_si512 (), (long long const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)0xFF, (int)SCALE)
#define _mm512_mask_i64gather_epi64(V1OLD,MASK,INDEX,ADDR,SCALE) (__m512i) __builtin_ia32_gatherdiv8di ((__v8di)(__m512i)V1OLD, (long long const *)ADDR, (__v8di)(__m512i)INDEX, (__mmask8)MASK, (int)SCALE)
#define _mm512_i32scatter_ps(ADDR,INDEX,V1,SCALE) __builtin_ia32_scattersiv16sf ((float *)ADDR, (__mmask16)0xFFFF, (__v16si)(__m512i)INDEX, (__v16sf)(__m512)V1, (int)SCALE)
#define _mm512_mask_i32scatter_ps(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scattersiv16sf ((float *)ADDR, (__mmask16)MASK, (__v16si)(__m512i)INDEX, (__v16sf)(__m512)V1, (int)SCALE)
#define _mm512_i32scatter_pd(ADDR,INDEX,V1,SCALE) __builtin_ia32_scattersiv8df ((double *)ADDR, (__mmask8)0xFF, (__v8si)(__m256i)INDEX, (__v8df)(__m512d)V1, (int)SCALE)
#define _mm512_mask_i32scatter_pd(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scattersiv8df ((double *)ADDR, (__mmask8)MASK, (__v8si)(__m256i)INDEX, (__v8df)(__m512d)V1, (int)SCALE)
#define _mm512_i64scatter_ps(ADDR,INDEX,V1,SCALE) __builtin_ia32_scatterdiv16sf ((float *)ADDR, (__mmask8)0xFF, (__v8di)(__m512i)INDEX, (__v8sf)(__m256)V1, (int)SCALE)
#define _mm512_mask_i64scatter_ps(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scatterdiv16sf ((float *)ADDR, (__mmask16)MASK, (__v8di)(__m512i)INDEX, (__v8sf)(__m256)V1, (int)SCALE)
#define _mm512_i64scatter_pd(ADDR,INDEX,V1,SCALE) __builtin_ia32_scatterdiv8df ((double *)ADDR, (__mmask8)0xFF, (__v8di)(__m512i)INDEX, (__v8df)(__m512d)V1, (int)SCALE)
#define _mm512_mask_i64scatter_pd(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scatterdiv8df ((double *)ADDR, (__mmask8)MASK, (__v8di)(__m512i)INDEX, (__v8df)(__m512d)V1, (int)SCALE)
#define _mm512_i32scatter_epi32(ADDR,INDEX,V1,SCALE) __builtin_ia32_scattersiv16si ((int *)ADDR, (__mmask16)0xFFFF, (__v16si)(__m512i)INDEX, (__v16si)(__m512i)V1, (int)SCALE)
#define _mm512_mask_i32scatter_epi32(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scattersiv16si ((int *)ADDR, (__mmask16)MASK, (__v16si)(__m512i)INDEX, (__v16si)(__m512i)V1, (int)SCALE)
#define _mm512_i32scatter_epi64(ADDR,INDEX,V1,SCALE) __builtin_ia32_scattersiv8di ((long long *)ADDR, (__mmask8)0xFF, (__v8si)(__m256i)INDEX, (__v8di)(__m512i)V1, (int)SCALE)
#define _mm512_mask_i32scatter_epi64(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scattersiv8di ((long long *)ADDR, (__mmask8)MASK, (__v8si)(__m256i)INDEX, (__v8di)(__m512i)V1, (int)SCALE)
#define _mm512_i64scatter_epi32(ADDR,INDEX,V1,SCALE) __builtin_ia32_scatterdiv16si ((int *)ADDR, (__mmask8)0xFF, (__v8di)(__m512i)INDEX, (__v8si)(__m256i)V1, (int)SCALE)
#define _mm512_mask_i64scatter_epi32(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scatterdiv16si ((int *)ADDR, (__mmask8)MASK, (__v8di)(__m512i)INDEX, (__v8si)(__m256i)V1, (int)SCALE)
#define _mm512_i64scatter_epi64(ADDR,INDEX,V1,SCALE) __builtin_ia32_scatterdiv8di ((long long *)ADDR, (__mmask8)0xFF, (__v8di)(__m512i)INDEX, (__v8di)(__m512i)V1, (int)SCALE)
#define _mm512_mask_i64scatter_epi64(ADDR,MASK,INDEX,V1,SCALE) __builtin_ia32_scatterdiv8di ((long long *)ADDR, (__mmask8)MASK, (__v8di)(__m512i)INDEX, (__v8di)(__m512i)V1, (int)SCALE)
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compress_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_compress_pd (__mmask8 __U, __m512d __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compressstoreu_pd (void *__P, __mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compress_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_compress_ps (__mmask16 __U, __m512 __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compressstoreu_ps (void *__P, __mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compress_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_compress_epi64 (__mmask8 __U, __m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compressstoreu_epi64 (void *__P, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compress_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_compress_epi32 (__mmask16 __U, __m512i __A)
;
extern void
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_compressstoreu_epi32 (void *__P, __mmask16 __U, __m512i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expand_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expand_pd (__mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expandloadu_pd (__m512d __W, __mmask8 __U, void const *__P)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expandloadu_pd (__mmask8 __U, void const *__P)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expand_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expand_ps (__mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expandloadu_ps (__m512 __W, __mmask16 __U, void const *__P)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expandloadu_ps (__mmask16 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expand_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expand_epi64 (__mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expandloadu_epi64 (__m512i __W, __mmask8 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expandloadu_epi64 (__mmask8 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expand_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expand_epi32 (__mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_expandloadu_epi32 (__m512i __W, __mmask16 __U, void const *__P)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_expandloadu_epi32 (__mmask16 __U, void const *__P)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kand (__mmask16 __A, __mmask16 __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kandn (__mmask16 __A, __mmask16 __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kor (__mmask16 __A, __mmask16 __B)
;
extern int
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kortestz (__mmask16 __A, __mmask16 __B)
;
extern int
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kortestc (__mmask16 __A, __mmask16 __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kxnor (__mmask16 __A, __mmask16 __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kxor (__mmask16 __A, __mmask16 __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_knot (__mmask16 __A)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kunpackb (__mmask16 __A, __mmask16 __B)
;
#define _mm512_maskz_insertf32x4(A,X,Y,C) ((__m512) __builtin_ia32_insertf32x4_mask ((__v16sf)(__m512) (X), (__v4sf)(__m128) (Y), (int) (C), (__v16sf)_mm512_setzero_ps(), (__mmask8)(A)))
#define _mm512_maskz_inserti32x4(A,X,Y,C) ((__m512i) __builtin_ia32_inserti32x4_mask ((__v16si)(__m512i) (X), (__v4si)(__m128i) (Y), (int) (C), (__v16si)_mm512_setzero_si512 (), (__mmask8)(A)))
#define _mm512_mask_insertf32x4(A,B,X,Y,C) ((__m512) __builtin_ia32_insertf32x4_mask ((__v16sf)(__m512) (X), (__v4sf)(__m128) (Y), (int) (C), (__v16sf)(__m512) (A), (__mmask8)(B)))
#define _mm512_mask_inserti32x4(A,B,X,Y,C) ((__m512i) __builtin_ia32_inserti32x4_mask ((__v16si)(__m512i) (X), (__v4si)(__m128i) (Y), (int) (C), (__v16si)(__m512i) (A), (__mmask8)(B)))
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_max_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_max_epi64 (__mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_max_epi64 (__m512i __W, __mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_min_epi64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_min_epi64 (__m512i __W, __mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_min_epi64 (__mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_max_epu64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_max_epu64 (__mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_max_epu64 (__m512i __W, __mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_min_epu64 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_min_epu64 (__m512i __W, __mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_min_epu64 (__mmask8 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_max_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_max_epi32 (__mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_max_epi32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_min_epi32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_min_epi32 (__mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_min_epi32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_max_epu32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_max_epu32 (__mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_max_epu32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_min_epu32 (__m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_min_epu32 (__mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_min_epu32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_unpacklo_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_unpacklo_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_unpacklo_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
#define _mm_max_round_sd(A,B,C) (__m128d)__builtin_ia32_addsd_round(A, B, C)
#define _mm_max_round_ss(A,B,C) (__m128)__builtin_ia32_addss_round(A, B, C)
#define _mm_min_round_sd(A,B,C) (__m128d)__builtin_ia32_subsd_round(A, B, C)
#define _mm_min_round_ss(A,B,C) (__m128)__builtin_ia32_subss_round(A, B, C)
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_blend_pd (__mmask8 __U, __m512d __A, __m512d __W)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_blend_ps (__mmask16 __U, __m512 __A, __m512 __W)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_blend_epi64 (__mmask8 __U, __m512i __A, __m512i __W)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_blend_epi32 (__mmask16 __U, __m512i __A, __m512i __W)
;
#define _mm_fmadd_round_sd(A,B,C,R) (__m128d)__builtin_ia32_vfmaddsd3_round(A, B, C, R)
#define _mm_fmadd_round_ss(A,B,C,R) (__m128)__builtin_ia32_vfmaddss3_round(A, B, C, R)
#define _mm_fmsub_round_sd(A,B,C,R) (__m128d)__builtin_ia32_vfmaddsd3_round(A, B, -(C), R)
#define _mm_fmsub_round_ss(A,B,C,R) (__m128)__builtin_ia32_vfmaddss3_round(A, B, -(C), R)
#define _mm_fnmadd_round_sd(A,B,C,R) (__m128d)__builtin_ia32_vfmaddsd3_round(A, -(B), C, R)
#define _mm_fnmadd_round_ss(A,B,C,R) (__m128)__builtin_ia32_vfmaddss3_round(A, -(B), C, R)
#define _mm_fnmsub_round_sd(A,B,C,R) (__m128d)__builtin_ia32_vfmaddsd3_round(A, -(B), -(C), R)
#define _mm_fnmsub_round_ss(A,B,C,R) (__m128)__builtin_ia32_vfmaddss3_round(A, -(B), -(C), R)
#define _mm_comi_round_ss(A,B,C,D) __builtin_ia32_vcomiss(A, B, C, D)
#define _mm_comi_round_sd(A,B,C,D) __builtin_ia32_vcomisd(A, B, C, D)
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sqrt_pd (__m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sqrt_pd (__m512d __W, __mmask8 __U, __m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sqrt_pd (__mmask8 __U, __m512d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sqrt_ps (__m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sqrt_ps (__m512 __W, __mmask16 __U, __m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sqrt_ps (__mmask16 __U, __m512 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_add_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_add_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_add_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_add_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_add_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_add_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sub_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sub_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sub_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_sub_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_sub_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_sub_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mul_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mul_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mul_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mul_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_mul_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_mul_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_div_pd (__m512d __M, __m512d __V)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_div_pd (__m512d __W, __mmask8 __U, __m512d __M, __m512d __V)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_div_pd (__mmask8 __U, __m512d __M, __m512d __V)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_div_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_div_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_div_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_max_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_max_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_max_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_max_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_max_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_max_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_min_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_min_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_min_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_min_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_min_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_min_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_scalef_pd (__m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_scalef_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_scalef_pd (__mmask8 __U, __m512d __A, __m512d __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_scalef_ps (__m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_scalef_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_scalef_ps (__mmask16 __U, __m512 __A, __m512 __B)
;
extern __m128d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_scalef_sd (__m128d __A, __m128d __B)
;
extern __m128
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_scalef_ss (__m128 __A, __m128 __B)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmadd_pd (__m512d __A, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmadd_pd (__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmadd_pd (__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmadd_pd (__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmadd_ps (__m512 __A, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmadd_ps (__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmadd_ps (__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmadd_ps (__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmsub_pd (__m512d __A, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmsub_pd (__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmsub_pd (__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmsub_pd (__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmsub_ps (__m512 __A, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmsub_ps (__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmsub_ps (__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmsub_ps (__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmaddsub_pd (__m512d __A, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmaddsub_pd (__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmaddsub_pd (__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmaddsub_pd (__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmaddsub_ps (__m512 __A, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmaddsub_ps (__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmaddsub_ps (__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmaddsub_ps (__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmsubadd_pd (__m512d __A, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmsubadd_pd (__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmsubadd_pd (__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmsubadd_pd (__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fmsubadd_ps (__m512 __A, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fmsubadd_ps (__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fmsubadd_ps (__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fmsubadd_ps (__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fnmadd_pd (__m512d __A, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fnmadd_pd (__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fnmadd_pd (__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fnmadd_pd (__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fnmadd_ps (__m512 __A, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fnmadd_ps (__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fnmadd_ps (__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fnmadd_ps (__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fnmsub_pd (__m512d __A, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fnmsub_pd (__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fnmsub_pd (__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fnmsub_pd (__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_fnmsub_ps (__m512 __A, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_fnmsub_ps (__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask3_fnmsub_ps (__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_fnmsub_ps (__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvttpd_epi32 (__m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvttpd_epi32 (__m256i __W, __mmask8 __U, __m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvttpd_epi32 (__mmask8 __U, __m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvttpd_epu32 (__m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvttpd_epu32 (__m256i __W, __mmask8 __U, __m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvttpd_epu32 (__mmask8 __U, __m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtpd_epi32 (__m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtpd_epi32 (__m256i __W, __mmask8 __U, __m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtpd_epi32 (__mmask8 __U, __m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtpd_epu32 (__m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtpd_epu32 (__m256i __W, __mmask8 __U, __m512d __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtpd_epu32 (__mmask8 __U, __m512d __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvttps_epi32 (__m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvttps_epi32 (__m512i __W, __mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvttps_epi32 (__mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvttps_epu32 (__m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvttps_epu32 (__m512i __W, __mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvttps_epu32 (__mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtps_epi32 (__m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtps_epi32 (__m512i __W, __mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtps_epi32 (__mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtps_epu32 (__m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtps_epu32 (__m512i __W, __mmask16 __U, __m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtps_epu32 (__mmask16 __U, __m512 __A)
;
extern __m128
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtu64_ss (__m128 __A, unsigned long long __B)
;
extern __m128d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtu64_sd (__m128d __A, unsigned long long __B)
;
extern __m128
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtu32_ss (__m128 __A, unsigned __B)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepi32_ps (__m512i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepi32_ps (__m512 __W, __mmask16 __U, __m512i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepi32_ps (__mmask16 __U, __m512i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtepu32_ps (__m512i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtepu32_ps (__m512 __W, __mmask16 __U, __m512i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtepu32_ps (__mmask16 __U, __m512i __A)
;
#define _mm512_fixupimm_pd(X,Y,Z,C) ((__m512d)__builtin_ia32_fixupimmpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (__v8di)(__m512i)(Z), (int)(C), (__mmask8)(-1), _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_fixupimm_pd(X,U,Y,Z,C) ((__m512d)__builtin_ia32_fixupimmpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (__v8di)(__m512i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_fixupimm_pd(U,X,Y,Z,C) ((__m512d)__builtin_ia32_fixupimmpd512_maskz ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (__v8di)(__m512i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_fixupimm_ps(X,Y,Z,C) ((__m512)__builtin_ia32_fixupimmps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(-1), _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_fixupimm_ps(X,U,Y,Z,C) ((__m512)__builtin_ia32_fixupimmps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_fixupimm_ps(U,X,Y,Z,C) ((__m512)__builtin_ia32_fixupimmps512_maskz ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm_fixupimm_sd(X,Y,Z,C) ((__m128d)__builtin_ia32_fixupimmsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(-1), _MM_FROUND_CUR_DIRECTION))
#define _mm_mask_fixupimm_sd(X,U,Y,Z,C) ((__m128d)__builtin_ia32_fixupimmsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm_maskz_fixupimm_sd(U,X,Y,Z,C) ((__m128d)__builtin_ia32_fixupimmsd_maskz ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm_fixupimm_ss(X,Y,Z,C) ((__m128)__builtin_ia32_fixupimmss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(-1), _MM_FROUND_CUR_DIRECTION))
#define _mm_mask_fixupimm_ss(X,U,Y,Z,C) ((__m128)__builtin_ia32_fixupimmss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm_maskz_fixupimm_ss(U,X,Y,Z,C) ((__m128)__builtin_ia32_fixupimmss_maskz ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
extern unsigned long long
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_u64 (__m128 __A)
;
extern unsigned long long
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_u64 (__m128 __A)
;
extern long long
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_i64 (__m128 __A)
;
extern unsigned
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_u32 (__m128 __A)
;
extern unsigned
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_u32 (__m128 __A)
;
extern int
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_i32 (__m128 __A)
;
extern unsigned long long
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_u64 (__m128d __A)
;
extern unsigned long long
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_u64 (__m128d __A)
;
extern long long
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_i64 (__m128d __A)
;
extern unsigned
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_u32 (__m128d __A)
;
extern unsigned
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_u32 (__m128d __A)
;
extern int
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_i32 (__m128d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtps_pd (__m256 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtps_pd (__m512d __W, __mmask8 __U, __m256 __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtps_pd (__mmask8 __U, __m256 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtph_ps (__m256i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtph_ps (__m512 __W, __mmask16 __U, __m256i __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtph_ps (__mmask16 __U, __m256i __A)
;
extern __m256
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cvtpd_ps (__m512d __A)
;
extern __m256
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cvtpd_ps (__m256 __W, __mmask8 __U, __m512d __A)
;
extern __m256
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_cvtpd_ps (__mmask8 __U, __m512d __A)
;
#define _mm512_getmant_pd(X,B,C) ((__m512d)__builtin_ia32_getmantpd512_mask ((__v8df)(__m512d)(X), (int)(((C)<<2) | (B)), (__v8df)_mm512_undefined_pd(), (__mmask8)-1, _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_getmant_pd(W,U,X,B,C) ((__m512d)__builtin_ia32_getmantpd512_mask ((__v8df)(__m512d)(X), (int)(((C)<<2) | (B)), (__v8df)(__m512d)(W), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_getmant_pd(U,X,B,C) ((__m512d)__builtin_ia32_getmantpd512_mask ((__v8df)(__m512d)(X), (int)(((C)<<2) | (B)), (__v8df)_mm512_setzero_pd(), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_getmant_ps(X,B,C) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)_mm512_undefined_ps(), (__mmask16)-1, _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_getmant_ps(W,U,X,B,C) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)(__m512)(W), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_getmant_ps(U,X,B,C) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)_mm512_setzero_ps(), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm_getmant_sd(X,Y,C,D) ((__m128d)__builtin_ia32_getmantsd_round ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(((D)<<2) | (C)), _MM_FROUND_CUR_DIRECTION))
#define _mm_getmant_ss(X,Y,C,D) ((__m128)__builtin_ia32_getmantss_round ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(((D)<<2) | (C)), _MM_FROUND_CUR_DIRECTION))
#define _mm_getexp_ss(A,B) ((__m128)__builtin_ia32_getexpss128_mask((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), _MM_FROUND_CUR_DIRECTION))
#define _mm_getexp_sd(A,B) ((__m128d)__builtin_ia32_getexpsd128_mask((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), _MM_FROUND_CUR_DIRECTION))
#define _mm512_getexp_ps(A) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)_mm512_undefined_ps(), (__mmask16)-1, _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_getexp_ps(W,U,A) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)(__m512)(W), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_getexp_ps(U,A) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)_mm512_setzero_ps(), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_getexp_pd(A) ((__m512d)__builtin_ia32_getexppd512_mask((__v8df)(__m512d)(A), (__v8df)_mm512_undefined_pd(), (__mmask8)-1, _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_getexp_pd(W,U,A) ((__m512d)__builtin_ia32_getexppd512_mask((__v8df)(__m512d)(A), (__v8df)(__m512d)(W), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_getexp_pd(U,A) ((__m512d)__builtin_ia32_getexppd512_mask((__v8df)(__m512d)(A), (__v8df)_mm512_setzero_pd(), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
#define _mm512_roundscale_ps(A,B) ((__m512) __builtin_ia32_rndscaleps_mask ((__v16sf)(__m512)(A), (int)(B), (__v16sf)_mm512_undefined_ps(), (__mmask16)(-1), _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_roundscale_ps(A,B,C,D) ((__m512) __builtin_ia32_rndscaleps_mask ((__v16sf)(__m512)(C), (int)(D), (__v16sf)(__m512)(A), (__mmask16)(B), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_roundscale_ps(A,B,C) ((__m512) __builtin_ia32_rndscaleps_mask ((__v16sf)(__m512)(B), (int)(C), (__v16sf)_mm512_setzero_ps(), (__mmask16)(A), _MM_FROUND_CUR_DIRECTION))
#define _mm512_roundscale_pd(A,B) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(A), (int)(B), (__v8df)_mm512_undefined_pd(), (__mmask8)(-1), _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_roundscale_pd(A,B,C,D) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(C), (int)(D), (__v8df)(__m512d)(A), (__mmask8)(B), _MM_FROUND_CUR_DIRECTION))
#define _mm512_maskz_roundscale_pd(A,B,C) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(B), (int)(C), (__v8df)_mm512_setzero_pd(), (__mmask8)(A), _MM_FROUND_CUR_DIRECTION))
#define _mm_roundscale_ss(A,B,C) ((__m128) __builtin_ia32_rndscaless_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), _MM_FROUND_CUR_DIRECTION))
#define _mm_roundscale_sd(A,B,C) ((__m128d) __builtin_ia32_rndscalesd_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), _MM_FROUND_CUR_DIRECTION))
#define _mm512_cmp_pd_mask(X,Y,P) ((__mmask8) __builtin_ia32_cmppd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(P), (__mmask8)-1,_MM_FROUND_CUR_DIRECTION))
#define _mm512_cmp_ps_mask(X,Y,P) ((__mmask16) __builtin_ia32_cmpps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(P), (__mmask16)-1,_MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_cmp_pd_mask(M,X,Y,P) ((__mmask8) __builtin_ia32_cmppd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(P), (__mmask8)M, _MM_FROUND_CUR_DIRECTION))
#define _mm512_mask_cmp_ps_mask(M,X,Y,P) ((__mmask16) __builtin_ia32_cmpps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(P), (__mmask16)M,_MM_FROUND_CUR_DIRECTION))
#define _mm_cmp_sd_mask(X,Y,P) ((__mmask8) __builtin_ia32_cmpsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P), (__mmask8)-1,_MM_FROUND_CUR_DIRECTION))
#define _mm_mask_cmp_sd_mask(M,X,Y,P) ((__mmask8) __builtin_ia32_cmpsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P), M,_MM_FROUND_CUR_DIRECTION))
#define _mm_cmp_ss_mask(X,Y,P) ((__mmask8) __builtin_ia32_cmpss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P), (__mmask8)-1,_MM_FROUND_CUR_DIRECTION))
#define _mm_mask_cmp_ss_mask(M,X,Y,P) ((__mmask8) __builtin_ia32_cmpss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P), M,_MM_FROUND_CUR_DIRECTION))
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_kmov (__mmask16 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castpd_ps (__m512d __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castpd_si512 (__m512d __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castps_pd (__m512 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castps_si512 (__m512 __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castsi512_ps (__m512i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castsi512_pd (__m512i __A)
;
extern __m128d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castpd512_pd128 (__m512d __A)
;
extern __m128
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castps512_ps128 (__m512 __A)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castsi512_si128 (__m512i __A)
;
extern __m256d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castpd512_pd256 (__m512d __A)
;
extern __m256
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castps512_ps256 (__m512 __A)
;
extern __m256i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castsi512_si256 (__m512i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castpd128_pd512 (__m128d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castps128_ps512 (__m128 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castsi128_si512 (__m128i __A)
;
extern __m512d
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castpd256_pd512 (__m256d __A)
;
extern __m512
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castps256_ps512 (__m256 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_castsi256_si512 (__m256i __A)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpeq_epu32_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpeq_epu32_mask (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpeq_epu64_mask (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpeq_epu64_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpgt_epu32_mask (__m512i __A, __m512i __B)
;
extern __mmask16
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpgt_epu32_mask (__mmask16 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_cmpgt_epu64_mask (__mmask8 __U, __m512i __A, __m512i __B)
;
extern __mmask8
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_cmpgt_epu64_mask (__m512i __A, __m512i __B)
;
#undef __DISABLE_AVX512F__
#pragma GCC pop_options
#define _AVX512ERINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("avx512er")
#define __DISABLE_AVX512ER__
typedef double __v8df __attribute__ ((__vector_size__ (64)));
typedef float __v16sf __attribute__ ((__vector_size__ (64)));
typedef float __m512 __attribute__ ((__vector_size__ (64), __may_alias__));
typedef double __m512d __attribute__ ((__vector_size__ (64), __may_alias__));
typedef unsigned char __mmask8;
typedef unsigned short __mmask16;
#define _mm512_exp2a23_round_pd(A,C) __builtin_ia32_exp2pd_mask(A, (__v8df)_mm512_setzero_pd(), -1, C)
#define _mm512_mask_exp2a23_round_pd(W,U,A,C) __builtin_ia32_exp2pd_mask(A, W, U, C)
#define _mm512_maskz_exp2a23_round_pd(U,A,C) __builtin_ia32_exp2pd_mask(A, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_exp2a23_round_ps(A,C) __builtin_ia32_exp2ps_mask(A, (__v16sf)_mm512_setzero_ps(), -1, C)
#define _mm512_mask_exp2a23_round_ps(W,U,A,C) __builtin_ia32_exp2ps_mask(A, W, U, C)
#define _mm512_maskz_exp2a23_round_ps(U,A,C) __builtin_ia32_exp2ps_mask(A, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm512_rcp28_round_pd(A,C) __builtin_ia32_rcp28pd_mask(A, (__v8df)_mm512_setzero_pd(), -1, C)
#define _mm512_mask_rcp28_round_pd(W,U,A,C) __builtin_ia32_rcp28pd_mask(A, W, U, C)
#define _mm512_maskz_rcp28_round_pd(U,A,C) __builtin_ia32_rcp28pd_mask(A, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_rcp28_round_ps(A,C) __builtin_ia32_rcp28ps_mask(A, (__v16sf)_mm512_setzero_ps(), -1, C)
#define _mm512_mask_rcp28_round_ps(W,U,A,C) __builtin_ia32_rcp28ps_mask(A, W, U, C)
#define _mm512_maskz_rcp28_round_ps(U,A,C) __builtin_ia32_rcp28ps_mask(A, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm512_rsqrt28_round_pd(A,C) __builtin_ia32_rsqrt28pd_mask(A, (__v8df)_mm512_setzero_pd(), -1, C)
#define _mm512_mask_rsqrt28_round_pd(W,U,A,C) __builtin_ia32_rsqrt28pd_mask(A, W, U, C)
#define _mm512_maskz_rsqrt28_round_pd(U,A,C) __builtin_ia32_rsqrt28pd_mask(A, (__v8df)_mm512_setzero_pd(), U, C)
#define _mm512_rsqrt28_round_ps(A,C) __builtin_ia32_rsqrt28ps_mask(A, (__v16sf)_mm512_setzero_ps(), -1, C)
#define _mm512_mask_rsqrt28_round_ps(W,U,A,C) __builtin_ia32_rsqrt28ps_mask(A, W, U, C)
#define _mm512_maskz_rsqrt28_round_ps(U,A,C) __builtin_ia32_rsqrt28ps_mask(A, (__v16sf)_mm512_setzero_ps(), U, C)
#define _mm_rcp28_round_sd(A,B,R) __builtin_ia32_rcp28sd_round(A, B, R)
#define _mm_rcp28_round_ss(A,B,R) __builtin_ia32_rcp28ss_round(A, B, R)
#define _mm_rsqrt28_round_sd(A,B,R) __builtin_ia32_rsqrt28sd_round(A, B, R)
#define _mm_rsqrt28_round_ss(A,B,R) __builtin_ia32_rsqrt28ss_round(A, B, R)
#define _mm512_exp2a23_pd(A) _mm512_exp2a23_round_pd(A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_mask_exp2a23_pd(W,U,A) _mm512_mask_exp2a23_round_pd(W, U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_maskz_exp2a23_pd(U,A) _mm512_maskz_exp2a23_round_pd(U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_exp2a23_ps(A) _mm512_exp2a23_round_ps(A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_mask_exp2a23_ps(W,U,A) _mm512_mask_exp2a23_round_ps(W, U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_maskz_exp2a23_ps(U,A) _mm512_maskz_exp2a23_round_ps(U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_rcp28_pd(A) _mm512_rcp28_round_pd(A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_mask_rcp28_pd(W,U,A) _mm512_mask_rcp28_round_pd(W, U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_maskz_rcp28_pd(U,A) _mm512_maskz_rcp28_round_pd(U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_rcp28_ps(A) _mm512_rcp28_round_ps(A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_mask_rcp28_ps(W,U,A) _mm512_mask_rcp28_round_ps(W, U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_maskz_rcp28_ps(U,A) _mm512_maskz_rcp28_round_ps(U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_rsqrt28_pd(A) _mm512_rsqrt28_round_pd(A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_mask_rsqrt28_pd(W,U,A) _mm512_mask_rsqrt28_round_pd(W, U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_maskz_rsqrt28_pd(U,A) _mm512_maskz_rsqrt28_round_pd(U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_rsqrt28_ps(A) _mm512_rsqrt28_round_ps(A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_mask_rsqrt28_ps(W,U,A) _mm512_mask_rsqrt28_round_ps(W, U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm512_maskz_rsqrt28_ps(U,A) _mm512_maskz_rsqrt28_round_ps(U, A, _MM_FROUND_CUR_DIRECTION)
#define _mm_rcp28_sd(A,B) __builtin_ia32_rcp28sd_round(B, A, _MM_FROUND_CUR_DIRECTION)
#define _mm_rcp28_ss(A,B) __builtin_ia32_rcp28ss_round(B, A, _MM_FROUND_CUR_DIRECTION)
#define _mm_rsqrt28_sd(A,B) __builtin_ia32_rsqrt28sd_round(B, A, _MM_FROUND_CUR_DIRECTION)
#define _mm_rsqrt28_ss(A,B) __builtin_ia32_rsqrt28ss_round(B, A, _MM_FROUND_CUR_DIRECTION)
#undef __DISABLE_AVX512ER__
#pragma GCC pop_options
#define _AVX512PFINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("avx512pf")
#define __DISABLE_AVX512PF__
typedef long long __v8di __attribute__ ((__vector_size__ (64)));
typedef int __v16si __attribute__ ((__vector_size__ (64)));
typedef long long __m512i __attribute__ ((__vector_size__ (64), __may_alias__));
typedef unsigned char __mmask8;
typedef unsigned short __mmask16;
#define _mm512_mask_prefetch_i32gather_pd(INDEX,MASK,ADDR,SCALE,HINT) __builtin_ia32_gatherpfdpd ((__mmask8)MASK, (__v8si)(__m256i)INDEX, (long long const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_mask_prefetch_i32gather_ps(INDEX,MASK,ADDR,SCALE,HINT) __builtin_ia32_gatherpfdps ((__mmask16)MASK, (__v16si)(__m512i)INDEX, (int const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_mask_prefetch_i64gather_pd(INDEX,MASK,ADDR,SCALE,HINT) __builtin_ia32_gatherpfqpd ((__mmask8)MASK, (__v8di)(__m512i)INDEX, (long long const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_mask_prefetch_i64gather_ps(INDEX,MASK,ADDR,SCALE,HINT) __builtin_ia32_gatherpfqps ((__mmask8)MASK, (__v8di)(__m512i)INDEX, (int const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_prefetch_i32scatter_pd(ADDR,INDEX,SCALE,HINT) __builtin_ia32_scatterpfdpd ((__mmask8)0xFF, (__v8si)(__m256i)INDEX, (long long const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_prefetch_i32scatter_ps(ADDR,INDEX,SCALE,HINT) __builtin_ia32_scatterpfdps ((__mmask16)0xFFFF, (__v16si)(__m512i)INDEX, (int const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_mask_prefetch_i32scatter_pd(ADDR,MASK,INDEX,SCALE,HINT) __builtin_ia32_scatterpfdpd ((__mmask8)MASK, (__v8si)(__m256i)INDEX, (long long const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_mask_prefetch_i32scatter_ps(ADDR,MASK,INDEX,SCALE,HINT) __builtin_ia32_scatterpfdps ((__mmask16)MASK, (__v16si)(__m512i)INDEX, (int const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_prefetch_i64scatter_pd(ADDR,INDEX,SCALE,HINT) __builtin_ia32_scatterpfqpd ((__mmask8)0xFF, (__v8di)(__m512i)INDEX, (long long const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_prefetch_i64scatter_ps(ADDR,INDEX,SCALE,HINT) __builtin_ia32_scatterpfqps ((__mmask8)0xFF, (__v8di)(__m512i)INDEX, (int const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_mask_prefetch_i64scatter_pd(ADDR,MASK,INDEX,SCALE,HINT) __builtin_ia32_scatterpfqpd ((__mmask8)MASK, (__v8di)(__m512i)INDEX, (long long const *)ADDR, (int)SCALE, (int)HINT)
#define _mm512_mask_prefetch_i64scatter_ps(ADDR,MASK,INDEX,SCALE,HINT) __builtin_ia32_scatterpfqps ((__mmask8)MASK, (__v8di)(__m512i)INDEX, (int const *)ADDR, (int)SCALE, (int)HINT)
#undef __DISABLE_AVX512PF__
#pragma GCC pop_options
#define _AVX512CDINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("avx512cd")
#define __DISABLE_AVX512CD__
typedef long long __v8di __attribute__ ((__vector_size__ (64)));
typedef int __v16si __attribute__ ((__vector_size__ (64)));
typedef long long __m512i __attribute__ ((__vector_size__ (64), __may_alias__));
typedef double __m512d __attribute__ ((__vector_size__ (64), __may_alias__));
typedef unsigned char __mmask8;
typedef unsigned short __mmask16;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_conflict_epi32 (__m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_conflict_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_conflict_epi32 (__mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_conflict_epi64 (__m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_conflict_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_conflict_epi64 (__mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_lzcnt_epi64 (__m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_lzcnt_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_lzcnt_epi64 (__mmask8 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_lzcnt_epi32 (__m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_mask_lzcnt_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_maskz_lzcnt_epi32 (__mmask16 __U, __m512i __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcastmb_epi64 (__mmask8 __A)
;
extern __m512i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm512_broadcastmw_epi32 (__mmask16 __A)
;
#undef __DISABLE_AVX512CD__
#pragma GCC pop_options
#define _SHAINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("sha")
#define __DISABLE_SHA__
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha1msg1_epu32 (__m128i __A, __m128i __B)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha1msg2_epu32 (__m128i __A, __m128i __B)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha1nexte_epu32 (__m128i __A, __m128i __B)
;
#define _mm_sha1rnds4_epu32(A,B,I) ((__m128i) __builtin_ia32_sha1rnds4 ((__v4si)(__m128i)A, (__v4si)(__m128i)B, (int)I))
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha256msg1_epu32 (__m128i __A, __m128i __B)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha256msg2_epu32 (__m128i __A, __m128i __B)
;
extern __m128i
__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha256rnds2_epu32 (__m128i __A, __m128i __B, __m128i __C)
;
#undef __DISABLE_SHA__
#pragma GCC pop_options
#define _LZCNTINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("lzcnt")
#define __DISABLE_LZCNT__
extern unsigned short __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__lzcnt16 (unsigned short __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__lzcnt32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_lzcnt_u32 (unsigned int __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__lzcnt64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_lzcnt_u64 (unsigned long long __X)
;
#undef __DISABLE_LZCNT__
#pragma GCC pop_options
#define _BMIINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("bmi")
#define __DISABLE_BMI__
extern unsigned short __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__tzcnt_u16 (unsigned short __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__andn_u32 (unsigned int __X, unsigned int __Y)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bextr_u32 (unsigned int __X, unsigned int __Y)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_bextr_u32 (unsigned int __X, unsigned int __Y, unsigned __Z)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsi_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_blsi_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsmsk_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_blsmsk_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsr_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_blsr_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__tzcnt_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_tzcnt_u32 (unsigned int __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__andn_u64 (unsigned long long __X, unsigned long long __Y)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__bextr_u64 (unsigned long long __X, unsigned long long __Y)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_bextr_u64 (unsigned long long __X, unsigned int __Y, unsigned int __Z)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsi_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_blsi_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsmsk_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_blsmsk_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsr_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_blsr_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__tzcnt_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_tzcnt_u64 (unsigned long long __X)
;
#undef __DISABLE_BMI__
#pragma GCC pop_options
#define _BMI2INTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("bmi2")
#define __DISABLE_BMI2__
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_bzhi_u32 (unsigned int __X, unsigned int __Y)
;
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_pdep_u32 (unsigned int __X, unsigned int __Y)
;
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_pext_u32 (unsigned int __X, unsigned int __Y)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_bzhi_u64 (unsigned long long __X, unsigned long long __Y)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_pdep_u64 (unsigned long long __X, unsigned long long __Y)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_pext_u64 (unsigned long long __X, unsigned long long __Y)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mulx_u64 (unsigned long long __X, unsigned long long __Y,
unsigned long long *__P)
;
#undef __DISABLE_BMI2__
#pragma GCC pop_options
#define _FMAINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("fma")
#define __DISABLE_FMA__
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmadd_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m256d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmadd_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmadd_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m256
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmadd_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmadd_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmadd_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmsub_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m256d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmsub_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmsub_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m256
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmsub_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmsub_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmsub_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmadd_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m256d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fnmadd_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmadd_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m256
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fnmadd_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmadd_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmadd_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmsub_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m256d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fnmsub_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmsub_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m256
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fnmsub_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmsub_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fnmsub_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmaddsub_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m256d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmaddsub_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmaddsub_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m256
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmaddsub_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m128d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmsubadd_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m256d
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmsubadd_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m128
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_fmsubadd_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m256
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_fmsubadd_ps (__m256 __A, __m256 __B, __m256 __C)
;
#undef __DISABLE_FMA__
#pragma GCC pop_options
#define _F16CINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("f16c")
#define __DISABLE_F16C__
extern float __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_cvtsh_ss (unsigned short __S)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtph_ps (__m128i __A)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_cvtph_ps (__m128i __A)
;
#define _cvtss_sh(__F,__I) (__extension__ ({ __v4sf __A = __extension__ (__v4sf){ __F, 0, 0, 0 }; __v8hi __H = __builtin_ia32_vcvtps2ph (__A, __I); (unsigned short) __builtin_ia32_vec_ext_v8hi (__H, 0); }))
#define _mm_cvtps_ph(A,I) ((__m128i) __builtin_ia32_vcvtps2ph ((__v4sf)(__m128) A, (int) (I)))
#define _mm256_cvtps_ph(A,I) ((__m128i) __builtin_ia32_vcvtps2ph256 ((__v8sf)(__m256) A, (int) (I)))
#undef __DISABLE_F16C__
#pragma GCC pop_options
#define _RTMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("rtm")
#define __DISABLE_RTM__
#define _XBEGIN_STARTED (~0u)
#define _XABORT_EXPLICIT (1 << 0)
#define _XABORT_RETRY (1 << 1)
#define _XABORT_CONFLICT (1 << 2)
#define _XABORT_CAPACITY (1 << 3)
#define _XABORT_DEBUG (1 << 4)
#define _XABORT_NESTED (1 << 5)
#define _XABORT_CODE(x) (((x) >> 24) & 0xFF)
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xbegin (void)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xend (void)
;
#define _xabort(N) __builtin_ia32_xabort (N)
#undef __DISABLE_RTM__
#pragma GCC pop_options
#define _XTESTINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("rtm")
#define __DISABLE_RTM__
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xtest (void)
;
#undef __DISABLE_RTM__
#pragma GCC pop_options
#pragma GCC push_options
#pragma GCC target("rdrnd")
#define __DISABLE_RDRND__
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_rdrand16_step (unsigned short *__P)
;
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_rdrand32_step (unsigned int *__P)
;
#undef __DISABLE_RDRND__
#pragma GCC pop_options
#pragma GCC push_options
#pragma GCC target("fsgsbase")
#define __DISABLE_FSGSBASE__
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_readfsbase_u32 (void)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_readfsbase_u64 (void)
;
extern unsigned int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_readgsbase_u32 (void)
;
extern unsigned long long
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_readgsbase_u64 (void)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_writefsbase_u32 (unsigned int __B)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_writefsbase_u64 (unsigned long long __B)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_writegsbase_u32 (unsigned int __B)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_writegsbase_u64 (unsigned long long __B)
;
#undef __DISABLE_FSGSBASE__
#pragma GCC pop_options
#pragma GCC push_options
#pragma GCC target("rdrnd")
#define __DISABLE_RDRND__
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_rdrand64_step (unsigned long long *__P)
;
#undef __DISABLE_RDRND__
#pragma GCC pop_options
#define _MM3DNOW_H_INCLUDED
#define _PRFCHWINTRIN_H_INCLUDED
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_prefetchw (void *__P)
;
#pragma GCC push_options
#pragma GCC target("3dnow")
#define __DISABLE_3dNOW__
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_femms (void)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pavgusb (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pf2id (__m64 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfacc (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfadd (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfcmpeq (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfcmpge (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfcmpgt (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfmax (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfmin (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfmul (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfrcp (__m64 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfrcpit1 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfrcpit2 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfrsqrt (__m64 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfrsqit1 (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfsub (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pfsubr (__m64 __A, __m64 __B)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pi2fd (__m64 __A)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmulhrw (__m64 __A, __m64 __B)
;
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_prefetch (void *__P)
;
extern __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_from_float (float __A)
;
extern float __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_to_float (__m64 __A)
;
#undef __DISABLE_3dNOW__
#pragma GCC pop_options
#define _FMA4INTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("fma4")
#define __DISABLE_FMA4__
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macc_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macc_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macc_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macc_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_msub_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_msub_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_msub_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_msub_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmacc_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmacc_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmacc_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmacc_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmsub_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmsub_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmsub_ss (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_nmsub_sd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maddsub_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maddsub_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_msubadd_ps (__m128 __A, __m128 __B, __m128 __C)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_msubadd_pd (__m128d __A, __m128d __B, __m128d __C)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_macc_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_macc_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_msub_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_msub_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_nmacc_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_nmacc_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_nmsub_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_nmsub_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maddsub_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_maddsub_pd (__m256d __A, __m256d __B, __m256d __C)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_msubadd_ps (__m256 __A, __m256 __B, __m256 __C)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_msubadd_pd (__m256d __A, __m256d __B, __m256d __C)
;
#undef __DISABLE_FMA4__
#pragma GCC pop_options
#define _XOPMMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("xop")
#define __DISABLE_XOP__
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maccs_epi16(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macc_epi16(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maccsd_epi16(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maccd_epi16(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maccs_epi32(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macc_epi32(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maccslo_epi32(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macclo_epi32(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maccshi_epi32(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_macchi_epi32(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maddsd_epi16(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maddd_epi16(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddw_epi8(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddd_epi8(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddq_epi8(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddd_epi16(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddq_epi16(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddq_epi32(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddw_epu8(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddd_epu8(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddq_epu8(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddd_epu16(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddq_epu16(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_haddq_epu32(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsubw_epi8(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsubd_epi16(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_hsubq_epi32(__m128i __A)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmov_si128(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_perm_epi8(__m128i __A, __m128i __B, __m128i __C)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rot_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rot_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rot_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rot_epi64(__m128i __A, __m128i __B)
;
#define _mm_roti_epi8(A,N) ((__m128i) __builtin_ia32_vprotbi ((__v16qi)(__m128i)(A), (int)(N)))
#define _mm_roti_epi16(A,N) ((__m128i) __builtin_ia32_vprotwi ((__v8hi)(__m128i)(A), (int)(N)))
#define _mm_roti_epi32(A,N) ((__m128i) __builtin_ia32_vprotdi ((__v4si)(__m128i)(A), (int)(N)))
#define _mm_roti_epi64(A,N) ((__m128i) __builtin_ia32_vprotqi ((__v2di)(__m128i)(A), (int)(N)))
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shl_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shl_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shl_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shl_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sha_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epu8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epu16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epu32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epu64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epi8(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epi16(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epi32(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comlt_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comle_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comgt_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comge_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comeq_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comneq_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comfalse_epi64(__m128i __A, __m128i __B)
;
extern __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comtrue_epi64(__m128i __A, __m128i __B)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_frcz_ps (__m128 __A)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_frcz_pd (__m128d __A)
;
extern __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_frcz_ss (__m128 __A, __m128 __B)
;
extern __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_frcz_sd (__m128d __A, __m128d __B)
;
extern __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_frcz_ps (__m256 __A)
;
extern __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm256_frcz_pd (__m256d __A)
;
#define _mm_permute2_pd(X,Y,C,I) ((__m128d) __builtin_ia32_vpermil2pd ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128d)(C), (int)(I)))
#define _mm256_permute2_pd(X,Y,C,I) ((__m256d) __builtin_ia32_vpermil2pd256 ((__v4df)(__m256d)(X), (__v4df)(__m256d)(Y), (__v4di)(__m256d)(C), (int)(I)))
#define _mm_permute2_ps(X,Y,C,I) ((__m128) __builtin_ia32_vpermil2ps ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128)(C), (int)(I)))
#define _mm256_permute2_ps(X,Y,C,I) ((__m256) __builtin_ia32_vpermil2ps256 ((__v8sf)(__m256)(X), (__v8sf)(__m256)(Y), (__v8si)(__m256)(C), (int)(I)))
#undef __DISABLE_XOP__
#pragma GCC pop_options
#define _LWPINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("lwp")
#define __DISABLE_LWP__
extern void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__llwpcb (void *pcbAddress)
;
extern void * __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__slwpcb (void)
;
#define __lwpval32(D2,D1,F) (__builtin_ia32_lwpval32 ((unsigned int) (D2), (unsigned int) (D1), (unsigned int) (F)))
#define __lwpval64(D2,D1,F) (__builtin_ia32_lwpval64 ((unsigned long long) (D2), (unsigned int) (D1), (unsigned int) (F)))
#define __lwpins32(D2,D1,F) (__builtin_ia32_lwpins32 ((unsigned int) (D2), (unsigned int) (D1), (unsigned int) (F)))
#define __lwpins64(D2,D1,F) (__builtin_ia32_lwpins64 ((unsigned long long) (D2), (unsigned int) (D1), (unsigned int) (F)))
#undef __DISABLE_LWP__
#pragma GCC pop_options
#define _TBMINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("tbm")
#define __DISABLE_TBM__
#define __bextri_u32(X,I) ((unsigned int)__builtin_ia32_bextri_u32 ((unsigned int)(X), (unsigned int)(I)))
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcfill_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blci_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcic_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcmsk_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcs_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsfill_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsic_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__t1mskc_u32 (unsigned int __X)
;
extern unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__tzmsk_u32 (unsigned int __X)
;
#define __bextri_u64(X,I) ((unsigned long long)__builtin_ia32_bextri_u64 ((unsigned long long)(X), (unsigned long long)(I)))
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcfill_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blci_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcic_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcmsk_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blcs_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsfill_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__blsic_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__t1mskc_u64 (unsigned long long __X)
;
extern unsigned long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
__tzmsk_u64 (unsigned long long __X)
;
#undef __DISABLE_TBM__
#pragma GCC pop_options
#define _RDSEEDINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("rdseed")
#define __DISABLE_RDSEED__
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_rdseed16_step (unsigned short *p)
;
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_rdseed32_step (unsigned int *p)
;
extern int
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_rdseed64_step (unsigned long long *p)
;
#undef __DISABLE_RDSEED__
#pragma GCC pop_options
#define _FXSRINTRIN_H_INCLUDED
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_fxsave (void *__P)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_fxrstor (void *__P)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_fxsave64 (void *__P)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_fxrstor64 (void *__P)
;
#define _XSAVEINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("xsave")
#define __DISABLE_XSAVE__
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsave (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xrstor (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsave64 (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xrstor64 (void *__P, long long __M)
;
#undef __DISABLE_XSAVE__
#pragma GCC pop_options
#define _XSAVEOPTINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("xsaveopt")
#define __DISABLE_XSAVEOPT__
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsaveopt (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsaveopt64 (void *__P, long long __M)
;
#undef __DISABLE_XSAVEOPT__
#pragma GCC pop_options
#define _ADXINTRIN_H_INCLUDED
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_subborrow_u32 (unsigned char __CF, unsigned int __X,
unsigned int __Y, unsigned int *__P)
;
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_addcarry_u32 (unsigned char __CF, unsigned int __X,
unsigned int __Y, unsigned int *__P)
;
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_addcarryx_u32 (unsigned char __CF, unsigned int __X,
unsigned int __Y, unsigned int *__P)
;
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_subborrow_u64 (unsigned char __CF, unsigned long __X,
unsigned long __Y, unsigned long long *__P)
;
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_addcarry_u64 (unsigned char __CF, unsigned long __X,
unsigned long __Y, unsigned long long *__P)
;
extern unsigned char
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_addcarryx_u64 (unsigned char __CF, unsigned long __X,
unsigned long __Y, unsigned long long *__P)
;
#define _CLFLUSHOPTINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("clflushopt")
#define __DISABLE_CLFLUSHOPT__
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_clflushopt (void *__A)
;
#undef __DISABLE_CLFLUSHOPT__
#pragma GCC pop_options
#define _XSAVESINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("xsaves")
#define __DISABLE_XSAVES__
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsaves (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xrstors (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xrstors64 (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsaves64 (void *__P, long long __M)
;
#undef __DISABLE_XSAVES__
#pragma GCC pop_options
#define _XSAVECINTRIN_H_INCLUDED
#pragma GCC push_options
#pragma GCC target("xsavec")
#define __DISABLE_XSAVEC__
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsavec (void *__P, long long __M)
;
extern void
__attribute__((__gnu_inline__, __always_inline__, __artificial__))
_xsavec64 (void *__P, long long __M)
;
#undef __DISABLE_XSAVEC__
#pragma GCC pop_options
namespace std __attribute__ ((__visibility__ ("default")))
{
}
#define _RANDOM_TCC 1
#define _GLIBCXX_NUMERIC 1
#define _STL_NUMERIC_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _ForwardIterator, typename _Tp>
void
iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _InputIterator, typename _Tp>
_Tp
accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
;
template<typename _InputIterator, typename _Tp, typename _BinaryOperation>
_Tp
accumulate(_InputIterator __first, _InputIterator __last, _Tp __init,
_BinaryOperation __binary_op)
;
template<typename _InputIterator1, typename _InputIterator2, typename _Tp>
_Tp
inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _Tp __init)
;
template<typename _InputIterator1, typename _InputIterator2, typename _Tp,
typename _BinaryOperation1, typename _BinaryOperation2>
_Tp
inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _Tp __init,
_BinaryOperation1 __binary_op1,
_BinaryOperation2 __binary_op2)
;
template<typename _InputIterator, typename _OutputIterator>
_OutputIterator
partial_sum(_InputIterator __first, _InputIterator __last,
_OutputIterator __result)
;
template<typename _InputIterator, typename _OutputIterator,
typename _BinaryOperation>
_OutputIterator
partial_sum(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _BinaryOperation __binary_op)
;
template<typename _InputIterator, typename _OutputIterator>
_OutputIterator
adjacent_difference(_InputIterator __first,
_InputIterator __last, _OutputIterator __result)
;
template<typename _InputIterator, typename _OutputIterator,
typename _BinaryOperation>
_OutputIterator
adjacent_difference(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _BinaryOperation __binary_op)
;
}
namespace std __attribute__ ((__visibility__ ("default")))
{
namespace __detail
{
template<typename _InputIterator, typename _OutputIterator,
typename _Tp>
_OutputIterator
__normalize(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, const _Tp& __factor)
;
}
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
constexpr _UIntType
linear_congruential_engine<_UIntType, __a, __c, __m>::multiplier;
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
constexpr _UIntType
linear_congruential_engine<_UIntType, __a, __c, __m>::increment;
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
constexpr _UIntType
linear_congruential_engine<_UIntType, __a, __c, __m>::modulus;
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
constexpr _UIntType
linear_congruential_engine<_UIntType, __a, __c, __m>::default_seed;
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const linear_congruential_engine<_UIntType,
__a, __c, __m>& __lcr)
;
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
linear_congruential_engine<_UIntType, __a, __c, __m>& __lcr)
;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::word_size;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::state_size;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::shift_size;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::mask_bits;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr _UIntType
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::xor_mask;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::tempering_u;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr _UIntType
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::tempering_d;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::tempering_s;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr _UIntType
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::tempering_b;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::tempering_t;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr _UIntType
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::tempering_c;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr size_t
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::tempering_l;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr _UIntType
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::
initialization_multiplier;
template<typename _UIntType,
size_t __w, size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f>
constexpr _UIntType
mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
__s, __b, __t, __c, __l, __f>::default_seed;
template<typename _UIntType, size_t __w,
size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const mersenne_twister_engine<_UIntType, __w, __n, __m,
__r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __x)
;
template<typename _UIntType, size_t __w,
size_t __n, size_t __m, size_t __r,
_UIntType __a, size_t __u, _UIntType __d, size_t __s,
_UIntType __b, size_t __t, _UIntType __c, size_t __l,
_UIntType __f, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
mersenne_twister_engine<_UIntType, __w, __n, __m,
__r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __x)
;
template<typename _UIntType, size_t __w, size_t __s, size_t __r>
constexpr size_t
subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size;
template<typename _UIntType, size_t __w, size_t __s, size_t __r>
constexpr size_t
subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag;
template<typename _UIntType, size_t __w, size_t __s, size_t __r>
constexpr size_t
subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag;
template<typename _UIntType, size_t __w, size_t __s, size_t __r>
constexpr _UIntType
subtract_with_carry_engine<_UIntType, __w, __s, __r>::default_seed;
template<typename _UIntType, size_t __w, size_t __s, size_t __r,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const subtract_with_carry_engine<_UIntType,
__w, __s, __r>& __x)
;
template<typename _UIntType, size_t __w, size_t __s, size_t __r,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
subtract_with_carry_engine<_UIntType, __w, __s, __r>& __x)
;
template<typename _RandomNumberEngine, size_t __p, size_t __r>
constexpr size_t
discard_block_engine<_RandomNumberEngine, __p, __r>::block_size;
template<typename _RandomNumberEngine, size_t __p, size_t __r>
constexpr size_t
discard_block_engine<_RandomNumberEngine, __p, __r>::used_block;
template<typename _RandomNumberEngine, size_t __p, size_t __r,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const discard_block_engine<_RandomNumberEngine,
__p, __r>& __x)
;
template<typename _RandomNumberEngine, size_t __p, size_t __r,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
discard_block_engine<_RandomNumberEngine, __p, __r>& __x)
;
template<typename _RandomNumberEngine, size_t __k>
constexpr size_t
shuffle_order_engine<_RandomNumberEngine, __k>::table_size;
template<typename _RandomNumberEngine, size_t __k,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const shuffle_order_engine<_RandomNumberEngine, __k>& __x)
;
template<typename _RandomNumberEngine, size_t __k,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
shuffle_order_engine<_RandomNumberEngine, __k>& __x)
;
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const uniform_int_distribution<_IntType>& __x)
;
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
uniform_int_distribution<_IntType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const uniform_real_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
uniform_real_distribution<_RealType>& __x)
;
template<typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const bernoulli_distribution& __x)
;
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const geometric_distribution<_IntType>& __x)
;
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
geometric_distribution<_IntType>& __x)
;
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const negative_binomial_distribution<_IntType>& __x)
;
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
negative_binomial_distribution<_IntType>& __x)
;
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const poisson_distribution<_IntType>& __x)
;
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
poisson_distribution<_IntType>& __x)
;
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const binomial_distribution<_IntType>& __x)
;
template<typename _IntType,
typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
binomial_distribution<_IntType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const exponential_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
exponential_distribution<_RealType>& __x)
;
template<typename _RealType>
bool
operator==(const std::normal_distribution<_RealType>& __d1,
const std::normal_distribution<_RealType>& __d2)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const normal_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
normal_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const lognormal_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
lognormal_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const chi_squared_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
chi_squared_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const cauchy_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
cauchy_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const fisher_f_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
fisher_f_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const student_t_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
student_t_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const gamma_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
gamma_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const weibull_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
weibull_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const extreme_value_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
extreme_value_distribution<_RealType>& __x)
;
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const discrete_distribution<_IntType>& __x)
;
template<typename _IntType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
discrete_distribution<_IntType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const piecewise_constant_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
piecewise_constant_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os,
const piecewise_linear_distribution<_RealType>& __x)
;
template<typename _RealType, typename _CharT, typename _Traits>
std::basic_istream<_CharT, _Traits>&
operator>>(std::basic_istream<_CharT, _Traits>& __is,
piecewise_linear_distribution<_RealType>& __x)
;
template<typename _RealType, size_t __bits,
typename _UniformRandomNumberGenerator>
_RealType
generate_canonical(_UniformRandomNumberGenerator& __urng)
;
}
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)
;
template<typename _InputIterator, typename _Predicate>
_InputIterator
__find_if(_InputIterator __first, _InputIterator __last,
_Predicate __pred, input_iterator_tag)
;
template<typename _RandomAccessIterator, typename _Predicate>
_RandomAccessIterator
__find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Predicate __pred, random_access_iterator_tag)
;
template<typename _Iterator, typename _Predicate>
_Iterator
__find_if(_Iterator __first, _Iterator __last, _Predicate __pred)
;
template<typename _InputIterator, typename _Predicate>
_InputIterator
__find_if_not(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
;
template<typename _InputIterator, typename _Predicate, typename _Distance>
_InputIterator
__find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
;
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
_ForwardIterator1
__search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2,
_BinaryPredicate __predicate)
;
template<typename _ForwardIterator, typename _Integer,
typename _UnaryPredicate>
_ForwardIterator
__search_n_aux(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count, _UnaryPredicate __unary_pred,
std::forward_iterator_tag)
;
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)
;
template<typename _ForwardIterator, typename _Integer,
typename _UnaryPredicate>
_ForwardIterator
__search_n(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count,
_UnaryPredicate __unary_pred)
;
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)
;
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)
;
template<typename _ForwardIterator1, typename _ForwardIterator2>
_ForwardIterator1
find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2)
;
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
_ForwardIterator1
find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2,
_BinaryPredicate __comp)
;
template<typename _InputIterator, typename _Predicate>
bool
all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
;
template<typename _InputIterator, typename _Predicate>
bool
none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
;
template<typename _InputIterator, typename _Predicate>
bool
any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
;
template<typename _InputIterator, typename _Predicate>
_InputIterator
find_if_not(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
;
template<typename _InputIterator, typename _Predicate>
bool
is_partitioned(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
partition_point(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _InputIterator, typename _OutputIterator,
typename _Predicate>
_OutputIterator
__remove_copy_if(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _Predicate __pred)
;
template<typename _InputIterator, typename _OutputIterator, typename _Tp>
_OutputIterator
remove_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, const _Tp& __value)
;
template<typename _InputIterator, typename _OutputIterator,
typename _Predicate>
_OutputIterator
remove_copy_if(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _Predicate __pred)
;
template<typename _InputIterator, typename _OutputIterator,
typename _Predicate>
_OutputIterator
copy_if(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _Predicate __pred)
;
template<typename _InputIterator, typename _Size, typename _OutputIterator>
_OutputIterator
__copy_n(_InputIterator __first, _Size __n,
_OutputIterator __result, input_iterator_tag)
;
template<typename _RandomAccessIterator, typename _Size,
typename _OutputIterator>
_OutputIterator
__copy_n(_RandomAccessIterator __first, _Size __n,
_OutputIterator __result, random_access_iterator_tag)
;
template<typename _InputIterator, typename _Size, typename _OutputIterator>
_OutputIterator
copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
;
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)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
__remove_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _ForwardIterator, typename _Tp>
_ForwardIterator
remove(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __value)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
remove_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _ForwardIterator, typename _BinaryPredicate>
_ForwardIterator
__adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __binary_pred)
;
template<typename _ForwardIterator, typename _BinaryPredicate>
_ForwardIterator
__unique(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __binary_pred)
;
template<typename _ForwardIterator>
_ForwardIterator
unique(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _BinaryPredicate>
_ForwardIterator
unique(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __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)
;
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)
;
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)
;
template<typename _BidirectionalIterator>
void
__reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
bidirectional_iterator_tag)
;
template<typename _RandomAccessIterator>
void
__reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
random_access_iterator_tag)
;
template<typename _BidirectionalIterator>
void
reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
;
template<typename _BidirectionalIterator, typename _OutputIterator>
_OutputIterator
reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
_OutputIterator __result)
;
template<typename _EuclideanRingElement>
_EuclideanRingElement
__gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
;
template<typename _ForwardIterator>
void
__rotate(_ForwardIterator __first,
_ForwardIterator __middle,
_ForwardIterator __last,
forward_iterator_tag)
;
template<typename _BidirectionalIterator>
void
__rotate(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
bidirectional_iterator_tag)
;
template<typename _RandomAccessIterator>
void
__rotate(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last,
random_access_iterator_tag)
;
template<typename _ForwardIterator>
void
rotate(_ForwardIterator __first, _ForwardIterator __middle,
_ForwardIterator __last)
;
template<typename _ForwardIterator, typename _OutputIterator>
_OutputIterator
rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
_ForwardIterator __last, _OutputIterator __result)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
__partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred, forward_iterator_tag)
;
template<typename _BidirectionalIterator, typename _Predicate>
_BidirectionalIterator
__partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
_Predicate __pred, bidirectional_iterator_tag)
;
template<typename _ForwardIterator, typename _Predicate, typename _Distance>
_ForwardIterator
__inplace_stable_partition(_ForwardIterator __first,
_Predicate __pred, _Distance __len)
;
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)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
__stable_partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
stable_partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__heap_select(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _InputIterator, typename _RandomAccessIterator,
typename _Compare>
_RandomAccessIterator
__partial_sort_copy(_InputIterator __first, _InputIterator __last,
_RandomAccessIterator __result_first,
_RandomAccessIterator __result_last,
_Compare __comp)
;
template<typename _InputIterator, typename _RandomAccessIterator>
_RandomAccessIterator
partial_sort_copy(_InputIterator __first, _InputIterator __last,
_RandomAccessIterator __result_first,
_RandomAccessIterator __result_last)
;
template<typename _InputIterator, typename _RandomAccessIterator,
typename _Compare>
_RandomAccessIterator
partial_sort_copy(_InputIterator __first, _InputIterator __last,
_RandomAccessIterator __result_first,
_RandomAccessIterator __result_last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__unguarded_linear_insert(_RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__unguarded_insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
enum { _S_threshold = 16 };
template<typename _RandomAccessIterator, typename _Compare>
void
__final_insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
_RandomAccessIterator
__unguarded_partition(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_RandomAccessIterator __pivot, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
_RandomAccessIterator
__unguarded_partition_pivot(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__partial_sort(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Size, typename _Compare>
void
__introsort_loop(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Size __depth_limit, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Size, typename _Compare>
void
__introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last, _Size __depth_limit,
_Compare __comp)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
_ForwardIterator
lower_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
_ForwardIterator
__upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
;
template<typename _ForwardIterator, typename _Tp>
_ForwardIterator
upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
_ForwardIterator
upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __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)
;
template<typename _ForwardIterator, typename _Tp>
pair<_ForwardIterator, _ForwardIterator>
equal_range(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
pair<_ForwardIterator, _ForwardIterator>
equal_range(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
;
template<typename _ForwardIterator, typename _Tp>
bool
binary_search(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
;
template<typename _ForwardIterator, typename _Tp, typename _Compare>
bool
binary_search(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
;
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)
;
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)
;
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)
;
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)
;
template<typename _BidirectionalIterator, typename _Distance,
typename _Compare>
void
__merge_without_buffer(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Distance __len1, _Distance __len2,
_Compare __comp)
;
template<typename _BidirectionalIterator, typename _Compare>
void
__inplace_merge(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Compare __comp)
;
template<typename _BidirectionalIterator>
void
inplace_merge(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last)
;
template<typename _BidirectionalIterator, typename _Compare>
void
inplace_merge(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Compare __comp)
;
template<typename _InputIterator, typename _OutputIterator,
typename _Compare>
_OutputIterator
__move_merge(_InputIterator __first1, _InputIterator __last1,
_InputIterator __first2, _InputIterator __last2,
_OutputIterator __result, _Compare __comp)
;
template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
typename _Distance, typename _Compare>
void
__merge_sort_loop(_RandomAccessIterator1 __first,
_RandomAccessIterator1 __last,
_RandomAccessIterator2 __result, _Distance __step_size,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Distance,
typename _Compare>
void
__chunk_insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Distance __chunk_size, _Compare __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)
;
template<typename _RandomAccessIterator, typename _Pointer,
typename _Distance, typename _Compare>
void
__stable_sort_adaptive(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Pointer __buffer, _Distance __buffer_size,
_Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__inplace_stable_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _Compare>
bool
__includes(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2>
bool
includes(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _Compare>
bool
includes(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_Compare __comp)
;
template<typename _BidirectionalIterator, typename _Compare>
bool
__next_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last, _Compare __comp)
;
template<typename _BidirectionalIterator>
bool
next_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last)
;
template<typename _BidirectionalIterator, typename _Compare>
bool
next_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last, _Compare __comp)
;
template<typename _BidirectionalIterator, typename _Compare>
bool
__prev_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last, _Compare __comp)
;
template<typename _BidirectionalIterator>
bool
prev_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last)
;
template<typename _BidirectionalIterator, typename _Compare>
bool
prev_permutation(_BidirectionalIterator __first,
_BidirectionalIterator __last, _Compare __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)
;
template<typename _InputIterator, typename _OutputIterator, typename _Tp>
_OutputIterator
replace_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result,
const _Tp& __old_value, const _Tp& __new_value)
;
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)
;
template<typename _InputIterator, typename _Predicate>
typename iterator_traits<_InputIterator>::difference_type
__count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
;
template<typename _ForwardIterator>
bool
is_sorted(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Compare>
bool
is_sorted(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
__is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _ForwardIterator>
_ForwardIterator
is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _Tp>
pair<const _Tp&, const _Tp&>
minmax(const _Tp& __a, const _Tp& __b)
;
template<typename _Tp, typename _Compare>
pair<const _Tp&, const _Tp&>
minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
;
template<typename _ForwardIterator, typename _Compare>
pair<_ForwardIterator, _ForwardIterator>
__minmax_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _ForwardIterator>
pair<_ForwardIterator, _ForwardIterator>
minmax_element(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Compare>
pair<_ForwardIterator, _ForwardIterator>
minmax_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _Tp>
_Tp
min(initializer_list<_Tp> __l)
;
template<typename _Tp, typename _Compare>
_Tp
min(initializer_list<_Tp> __l, _Compare __comp)
;
template<typename _Tp>
_Tp
max(initializer_list<_Tp> __l)
;
template<typename _Tp, typename _Compare>
_Tp
max(initializer_list<_Tp> __l, _Compare __comp)
;
template<typename _Tp>
pair<_Tp, _Tp>
minmax(initializer_list<_Tp> __l)
;
template<typename _Tp, typename _Compare>
pair<_Tp, _Tp>
minmax(initializer_list<_Tp> __l, _Compare __comp)
;
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
bool
__is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _BinaryPredicate __pred)
;
template<typename _ForwardIterator1, typename _ForwardIterator2>
bool
is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2)
;
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
bool
is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _BinaryPredicate __pred)
;
template<typename _RandomAccessIterator,
typename _UniformRandomNumberGenerator>
void
shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
_UniformRandomNumberGenerator&& __g)
;
template<typename _InputIterator, typename _Function>
_Function
for_each(_InputIterator __first, _InputIterator __last, _Function __f)
;
template<typename _InputIterator, typename _Tp>
_InputIterator
find(_InputIterator __first, _InputIterator __last,
const _Tp& __val)
;
template<typename _InputIterator, typename _Predicate>
_InputIterator
find_if(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
;
template<typename _InputIterator, typename _ForwardIterator>
_InputIterator
find_first_of(_InputIterator __first1, _InputIterator __last1,
_ForwardIterator __first2, _ForwardIterator __last2)
;
template<typename _InputIterator, typename _ForwardIterator,
typename _BinaryPredicate>
_InputIterator
find_first_of(_InputIterator __first1, _InputIterator __last1,
_ForwardIterator __first2, _ForwardIterator __last2,
_BinaryPredicate __comp)
;
template<typename _ForwardIterator>
_ForwardIterator
adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _BinaryPredicate>
_ForwardIterator
adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __binary_pred)
;
template<typename _InputIterator, typename _Tp>
typename iterator_traits<_InputIterator>::difference_type
count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
;
template<typename _InputIterator, typename _Predicate>
typename iterator_traits<_InputIterator>::difference_type
count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
;
template<typename _ForwardIterator1, typename _ForwardIterator2>
_ForwardIterator1
search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2)
;
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
_ForwardIterator1
search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2,
_BinaryPredicate __predicate)
;
template<typename _ForwardIterator, typename _Integer, typename _Tp>
_ForwardIterator
search_n(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count, const _Tp& __val)
;
template<typename _ForwardIterator, typename _Integer, typename _Tp,
typename _BinaryPredicate>
_ForwardIterator
search_n(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count, const _Tp& __val,
_BinaryPredicate __binary_pred)
;
template<typename _InputIterator, typename _OutputIterator,
typename _UnaryOperation>
_OutputIterator
transform(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _UnaryOperation __unary_op)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _BinaryOperation>
_OutputIterator
transform(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _OutputIterator __result,
_BinaryOperation __binary_op)
;
template<typename _ForwardIterator, typename _Tp>
void
replace(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __old_value, const _Tp& __new_value)
;
template<typename _ForwardIterator, typename _Predicate, typename _Tp>
void
replace_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred, const _Tp& __new_value)
;
template<typename _ForwardIterator, typename _Generator>
void
generate(_ForwardIterator __first, _ForwardIterator __last,
_Generator __gen)
;
template<typename _OutputIterator, typename _Size, typename _Generator>
_OutputIterator
generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
;
template<typename _InputIterator, typename _OutputIterator>
_OutputIterator
unique_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result)
;
template<typename _InputIterator, typename _OutputIterator,
typename _BinaryPredicate>
_OutputIterator
unique_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result,
_BinaryPredicate __binary_pred)
;
template<typename _RandomAccessIterator>
void
random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
void
random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
_RandomNumberGenerator&& __rand)
;
template<typename _ForwardIterator, typename _Predicate>
_ForwardIterator
partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
;
template<typename _RandomAccessIterator>
void
partial_sort(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
partial_sort(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator>
void
nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last, _Compare __comp)
;
template<typename _RandomAccessIterator>
void
sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
_OutputIterator
__merge(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
_OutputIterator
merge(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
_OutputIterator
merge(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
;
template<typename _RandomAccessIterator, typename _Compare>
void
__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
;
template<typename _RandomAccessIterator>
void
stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
;
template<typename _RandomAccessIterator, typename _Compare>
void
stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __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)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
_OutputIterator
set_union(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
_OutputIterator
set_union(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __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)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
_OutputIterator
set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
_OutputIterator
set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __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)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
_OutputIterator
set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
_OutputIterator
set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __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)
;
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
_OutputIterator
set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
;
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)
;
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
__min_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _ForwardIterator>
_ForwardIterator
min_element(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
min_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
__max_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
template<typename _ForwardIterator>
_ForwardIterator
max_element(_ForwardIterator __first, _ForwardIterator __last)
;
template<typename _ForwardIterator, typename _Compare>
_ForwardIterator
max_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
;
}
namespace boost
{
template<class T> class shared_ptr;
template<class T> class weak_ptr;
template<class T> class enable_shared_from_this;
class enable_shared_from_raw;
namespace detail
{
template< class T > struct sp_element
{
typedef T type;
};
template< class T > struct sp_element< T[] >
{
typedef T type;
};
template< class T, std::size_t N > struct sp_element< T[N] >
{
typedef T type;
};
template< class T > struct sp_dereference
{
typedef T & type;
};
template<> struct sp_dereference< void >
{
typedef void type;
};
template<> struct sp_dereference< void const >
{
typedef void type;
};
template<> struct sp_dereference< void volatile >
{
typedef void type;
};
template<> struct sp_dereference< void const volatile >
{
typedef void type;
};
template< class T > struct sp_dereference< T[] >
{
typedef void type;
};
template< class T, std::size_t N > struct sp_dereference< T[N] >
{
typedef void type;
};
template< class T > struct sp_member_access
{
typedef T * type;
};
template< class T > struct sp_member_access< T[] >
{
typedef void type;
};
template< class T, std::size_t N > struct sp_member_access< T[N] >
{
typedef void type;
};
template< class T > struct sp_array_access
{
typedef void type;
};
template< class T > struct sp_array_access< T[] >
{
typedef T & type;
};
template< class T, std::size_t N > struct sp_array_access< T[N] >
{
typedef T & type;
};
template< class T > struct sp_extent
{
enum _vt { value = 0 };
};
template< class T, std::size_t N > struct sp_extent< T[N] >
{
enum _vt { value = N };
};
template< class X, class Y, class T > void sp_enable_shared_from_this( boost::shared_ptr<X> const * ppx, Y const * py, boost::enable_shared_from_this< T > const * pe )
;
template< class X, class Y > inline void sp_enable_shared_from_this( boost::shared_ptr<X> * ppx, Y const * py, boost::enable_shared_from_raw const * pe );
void sp_enable_shared_from_this( ... )
;
template< class T, class R > struct sp_enable_if_auto_ptr
{
};
template< class T, class R > struct sp_enable_if_auto_ptr< std::auto_ptr< T >, R >
{
typedef R type;
};
template< class Y, class T > void sp_assert_convertible()
;
template< class T, class Y > void sp_pointer_construct( boost::shared_ptr< T > * ppx, Y * p, boost::detail::shared_count & pn )
;
template< class T, class Y > void sp_pointer_construct( boost::shared_ptr< T[] > * , Y * p, boost::detail::shared_count & pn )
;
template< class T, std::size_t N, class Y > void sp_pointer_construct( boost::shared_ptr< T[N] > * , Y * p, boost::detail::shared_count & pn )
;
template< class T, class Y > void sp_deleter_construct( boost::shared_ptr< T > * ppx, Y * p )
;
template< class T, class Y > void sp_deleter_construct( boost::shared_ptr< T[] > * , Y * )
;
template< class T, std::size_t N, class Y > void sp_deleter_construct( boost::shared_ptr< T[N] > * , Y * )
;
}
template<class T> class shared_ptr
{
private:
typedef shared_ptr<T> this_type;
public:
typedef typename boost::detail::sp_element< T >::type element_type;
shared_ptr() noexcept : px( 0 ), pn()
{
}
shared_ptr( boost::detail::sp_nullptr_t ) noexcept : px( 0 ), pn()
{
}
template<class Y>
explicit shared_ptr( Y * p ): px( p ), pn()
{
boost::detail::sp_pointer_construct( this, p, pn );
}
template<class Y, class D> shared_ptr( Y * p, D d ): px( p ), pn( p, d )
{
boost::detail::sp_deleter_construct( this, p );
}
template<class D> shared_ptr( boost::detail::sp_nullptr_t p, D d ): px( p ), pn( p, d )
{
}
template<class Y, class D, class A> shared_ptr( Y * p, D d, A a ): px( p ), pn( p, d, a )
{
boost::detail::sp_deleter_construct( this, p );
}
template<class D, class A> shared_ptr( boost::detail::sp_nullptr_t p, D d, A a ): px( p ), pn( p, d, a )
{
}
shared_ptr( shared_ptr const & r ) noexcept : px( r.px ), pn( r.pn )
{
}
template<class Y>
explicit shared_ptr( weak_ptr<Y> const & r ): pn( r.pn )
{
boost::detail::sp_assert_convertible< Y, T >();
px = r.px;
}
template<class Y>
shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag )
noexcept : px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() )
{
if( !pn.empty() )
{
px = r.px;
}
}
template<class Y>
shared_ptr( shared_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
noexcept : px( r.px ), pn( r.pn )
{
boost::detail::sp_assert_convertible< Y, T >();
}
template< class Y >
shared_ptr( shared_ptr<Y> const & r, element_type * p ) noexcept : px( p ), pn( r.pn )
{
}
template<class Y>
explicit shared_ptr( std::auto_ptr<Y> & r ): px(r.get()), pn()
{
boost::detail::sp_assert_convertible< Y, T >();
Y * tmp = r.get();
pn = boost::detail::shared_count( r );
boost::detail::sp_deleter_construct( this, tmp );
}
template<class Y>
shared_ptr( std::auto_ptr<Y> && r ): px(r.get()), pn()
{
boost::detail::sp_assert_convertible< Y, T >();
Y * tmp = r.get();
pn = boost::detail::shared_count( r );
boost::detail::sp_deleter_construct( this, tmp );
}
template< class Y, class D >
shared_ptr( std::unique_ptr< Y, D > && r ): px( r.get() ), pn()
{
boost::detail::sp_assert_convertible< Y, T >();
typename std::unique_ptr< Y, D >::pointer tmp = r.get();
pn = boost::detail::shared_count( r );
boost::detail::sp_deleter_construct( this, tmp );
}
shared_ptr & operator=( shared_ptr const & r ) noexcept
{
this_type(r).swap(*this);
return *this;
}
template<class Y>
shared_ptr & operator=(shared_ptr<Y> const & r) noexcept
{
this_type(r).swap(*this);
return *this;
}
template<class Y>
shared_ptr & operator=( std::auto_ptr<Y> & r )
{
this_type( r ).swap( *this );
return *this;
}
template<class Y>
shared_ptr & operator=( std::auto_ptr<Y> && r )
{
this_type( static_cast< std::auto_ptr<Y> && >( r ) ).swap( *this );
return *this;
}
template<class Y, class D>
shared_ptr & operator=( std::unique_ptr<Y, D> && r )
{
this_type( static_cast< std::unique_ptr<Y, D> && >( r ) ).swap(*this);
return *this;
}
shared_ptr( shared_ptr && r ) noexcept : px( r.px ), pn()
{
pn.swap( r.pn );
r.px = 0;
}
template<class Y>
shared_ptr( shared_ptr<Y> && r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
noexcept : px( r.px ), pn()
{
boost::detail::sp_assert_convertible< Y, T >();
pn.swap( r.pn );
r.px = 0;
}
shared_ptr & operator=( shared_ptr && r ) noexcept
{
this_type( static_cast< shared_ptr && >( r ) ).swap( *this );
return *this;
}
template<class Y>
shared_ptr & operator=( shared_ptr<Y> && r ) noexcept
{
this_type( static_cast< shared_ptr<Y> && >( r ) ).swap( *this );
return *this;
}
shared_ptr & operator=( boost::detail::sp_nullptr_t ) noexcept
{
this_type().swap(*this);
return *this;
}
void reset() noexcept
{
this_type().swap(*this);
}
template<class Y> void reset( Y * p )
{
(static_cast<void> (0));
this_type( p ).swap( *this );
}
template<class Y, class D> void reset( Y * p, D d )
{
this_type( p, d ).swap( *this );
}
template<class Y, class D, class A> void reset( Y * p, D d, A a )
{
this_type( p, d, a ).swap( *this );
}
template<class Y> void reset( shared_ptr<Y> const & r, element_type * p )
{
this_type( r, p ).swap( *this );
}
typename boost::detail::sp_dereference< T >::type operator* () const
{
(static_cast<void> (0));
return *px;
}
typename boost::detail::sp_member_access< T >::type operator-> () const
{
(static_cast<void> (0));
return px;
}
typename boost::detail::sp_array_access< T >::type operator[] ( std::ptrdiff_t i ) const
{
(static_cast<void> (0));
(static_cast<void> (0));
return px[ i ];
}
element_type * get() const noexcept
{
return px;
}
explicit operator bool () const noexcept
{
return px != 0;
}
bool operator! () const noexcept
{
return px == 0;
}
bool unique() const noexcept
{
return pn.unique();
}
long use_count() const noexcept
{
return pn.use_count();
}
void swap( shared_ptr & other ) noexcept
{
std::swap(px, other.px);
pn.swap(other.pn);
}
template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const noexcept
{
return pn < rhs.pn;
}
template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const noexcept
{
return pn < rhs.pn;
}
void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const noexcept
{
return pn.get_deleter( ti );
}
void * _internal_get_untyped_deleter() const noexcept
{
return pn.get_untyped_deleter();
}
bool _internal_equiv( shared_ptr const & r ) const noexcept
{
return px == r.px && pn == r.pn;
}
private:
template<class Y> friend class shared_ptr;
template<class Y> friend class weak_ptr;
element_type * px;
boost::detail::shared_count pn;
};
template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept
{
return a.get() == b.get();
}
template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept
{
return a.get() != b.get();
}
template<class T> inline bool operator==( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) noexcept
{
return p.get() == 0;
}
template<class T> inline bool operator==( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) noexcept
{
return p.get() == 0;
}
template<class T> inline bool operator!=( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) noexcept
{
return p.get() != 0;
}
template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) noexcept
{
return p.get() != 0;
}
template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept
{
return a.owner_before( b );
}
template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b) noexcept
{
a.swap(b);
}
template<class T, class U> shared_ptr<T> static_pointer_cast( shared_ptr<U> const & r ) noexcept
{
(void) static_cast< T* >( static_cast< U* >( 0 ) );
typedef typename shared_ptr<T>::element_type E;
E * p = static_cast< E* >( r.get() );
return shared_ptr<T>( r, p );
}
template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> const & r ) noexcept
{
(void) const_cast< T* >( static_cast< U* >( 0 ) );
typedef typename shared_ptr<T>::element_type E;
E * p = const_cast< E* >( r.get() );
return shared_ptr<T>( r, p );
}
template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> const & r ) noexcept
{
(void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
typedef typename shared_ptr<T>::element_type E;
E * p = dynamic_cast< E* >( r.get() );
return p? shared_ptr<T>( r, p ): shared_ptr<T>();
}
template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U> const & r ) noexcept
{
(void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
typedef typename shared_ptr<T>::element_type E;
E * p = reinterpret_cast< E* >( r.get() );
return shared_ptr<T>( r, p );
}
template<class T> inline typename shared_ptr<T>::element_type * get_pointer(shared_ptr<T> const & p) noexcept
{
return p.get();
}
template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)
{
os << p.get();
return os;
}
namespace detail
{
template<class D, class T> D * basic_get_deleter( shared_ptr<T> const & p ) noexcept
{
return static_cast<D *>( p._internal_get_deleter(typeid(D)) );
}
class esft2_deleter_wrapper
{
private:
shared_ptr<void> deleter_;
public:
esft2_deleter_wrapper()
{
}
template< class T > void set_deleter( shared_ptr<T> const & deleter )
{
deleter_ = deleter;
}
template<typename D> D* get_deleter() const noexcept
{
return boost::detail::basic_get_deleter<D>( deleter_ );
}
template< class T> void operator()( T* )
{
(static_cast<void> (0));
deleter_.reset();
}
};
}
template<class D, class T> D * get_deleter( shared_ptr<T> const & p ) noexcept
{
D *del = boost::detail::basic_get_deleter<D>(p);
if(del == 0)
{
boost::detail::esft2_deleter_wrapper *del_wrapper = boost::detail::basic_get_deleter<boost::detail::esft2_deleter_wrapper>(p);
if(del_wrapper) del = del_wrapper->::boost::detail::esft2_deleter_wrapper::get_deleter<D>();
}
return del;
}
template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * ) noexcept
{
return false;
}
template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p )
{
boost::detail::spinlock_pool<2>::scoped_lock lock( p );
return *p;
}
template<class T> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, memory_order )
{
return atomic_load( p );
}
template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r )
{
boost::detail::spinlock_pool<2>::scoped_lock lock( p );
p->swap( r );
}
template<class T> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order )
{
atomic_store( p, r );
}
template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r )
{
boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
sp.lock();
p->swap( r );
sp.unlock();
return r;
}
template<class T> shared_ptr<T> atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order )
{
return atomic_exchange( p, r );
}
template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w )
{
boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
sp.lock();
if( p->_internal_equiv( *v ) )
{
p->swap( w );
sp.unlock();
return true;
}
else
{
shared_ptr<T> tmp( *p );
sp.unlock();
tmp.swap( *v );
return false;
}
}
template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, memory_order , memory_order )
{
return atomic_compare_exchange( p, v, w );
}
template< class T > struct hash;
template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p ) noexcept
{
return boost::hash< T* >()( p.get() );
}
}
namespace boost {
namespace date_time {
template<class time_type>
class second_clock
{
public:
typedef typename time_type::date_type date_type;
typedef typename time_type::time_duration_type time_duration_type;
static time_type local_time()
;
static time_type universal_time()
;
template<class time_zone_type>
static time_type local_time(boost::shared_ptr<time_zone_type> tz_ptr)
;
private:
static time_type create_time(::std::tm* current)
;
};
} }
#define DATE_TIME_HIGHRES_TIME_CLOCK_HPP___
#define DATE_TIME_FILETIME_FUNCTIONS_HPP__
namespace boost {
namespace date_time {
template<class time_type>
class microsec_clock
{
private:
typedef std::tm* (*time_converter)(const std::time_t*, std::tm*);
public:
typedef typename time_type::date_type date_type;
typedef typename time_type::time_duration_type time_duration_type;
typedef typename time_duration_type::rep_type resolution_traits_type;
template<class time_zone_type>
static time_type local_time(shared_ptr<time_zone_type> tz_ptr)
;
static time_type local_time()
;
static time_type universal_time()
;
private:
static time_type create_time(time_converter converter)
;
};
} }
#define POSIX_PTIME_HPP___
#define POSIX_TIME_SYSTEM_HPP___
#define POSIX_TIME_CONFIG_HPP___
#define BOOST_CONFIG_CMATH
#define BOOST_TR1_NO_RECURSION
#define BOOST_CONFIG_NO_CMATH_RECURSION
#undef BOOST_TR1_NO_RECURSION
#undef BOOST_CONFIG_NO_CMATH_RECURSION
#define DATE_TIME_TIME_DURATION_HPP___
#define BOOST_STATIC_ASSERT_HPP
#define BOOST_STATIC_ASSERT_MSG(...) static_assert(__VA_ARGS__)
#define BOOST_STATIC_ASSERT_BOOL_CAST(...) ((__VA_ARGS__) == 0 ? false : true)
#define BOOST_STATIC_ASSERT_UNUSED_ATTRIBUTE __attribute__((unused))
#define BOOST_STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
#define DATE_TIME_TIME_PRECISION_LIMITS_HPP
namespace boost {
namespace date_time {
enum time_resolutions {
sec,
tenth,
hundreth,
hundredth = hundreth,
milli,
ten_thousandth,
micro,
nano,
NumResolutions
};
enum dst_flags {not_dst, is_dst, calculate};
} }
#define DATE_TIME_SPECIAL_DEFS_HPP__
namespace boost {
namespace date_time {
enum special_values {not_a_date_time,
neg_infin, pos_infin,
min_date_time, max_date_time,
not_special, NumSpecialValues};
} }
namespace boost {
namespace date_time {
template<class T, typename rep_type>
class time_duration : private
boost::less_than_comparable<T
, boost::equality_comparable<T
> >
{
public:
typedef T duration_type;
typedef rep_type traits_type;
typedef typename rep_type::day_type day_type;
typedef typename rep_type::hour_type hour_type;
typedef typename rep_type::min_type min_type;
typedef typename rep_type::sec_type sec_type;
typedef typename rep_type::fractional_seconds_type fractional_seconds_type;
typedef typename rep_type::tick_type tick_type;
typedef typename rep_type::impl_type impl_type;
time_duration() ;
time_duration(hour_type hours_in,
min_type minutes_in,
sec_type seconds_in=0,
fractional_seconds_type frac_sec_in = 0)
;
time_duration(const time_duration<T, rep_type>& other)
;
time_duration(special_values sv)
;
static duration_type unit()
;
static tick_type ticks_per_second()
;
static time_resolutions resolution()
;
hour_type hours() const
;
min_type minutes() const
;
sec_type seconds() const
;
sec_type total_seconds() const
;
tick_type total_milliseconds() const
;
tick_type total_nanoseconds() const
;
tick_type total_microseconds() const
;
fractional_seconds_type fractional_seconds() const
;
static unsigned short num_fractional_digits()
;
duration_type invert_sign() const
;
bool is_negative() const
;
bool operator<(const time_duration& rhs) const
;
bool operator==(const time_duration& rhs) const
;
duration_type operator-()const
;
duration_type operator-(const duration_type& d) const
;
duration_type operator+(const duration_type& d) const
;
duration_type operator/(int divisor) const
;
duration_type operator-=(const duration_type& d)
;
duration_type operator+=(const duration_type& d)
;
duration_type operator/=(int divisor)
;
duration_type operator*(int rhs) const
;
duration_type operator*=(int divisor)
;
tick_type ticks() const
;
bool is_special()const
;
bool is_pos_infinity()const
;
bool is_neg_infinity()const
;
bool is_not_a_date_time()const
;
impl_type get_rep()const
;
protected:
explicit time_duration(impl_type in) ;
impl_type ticks_;
};
template<class base_duration, boost::int64_t frac_of_second>
class subsecond_duration : public base_duration
{
public:
typedef typename base_duration::impl_type impl_type;
typedef typename base_duration::traits_type traits_type;
private:
static_assert((traits_type::ticks_per_second >= frac_of_second ? traits_type::ticks_per_second % frac_of_second : frac_of_second % traits_type::ticks_per_second) == 0, "The base duration resolution must be a multiple of the subsecond duration resolution");
static const boost::int64_t adjustment_ratio = (traits_type::ticks_per_second >= frac_of_second ? traits_type::ticks_per_second / frac_of_second : frac_of_second / traits_type::ticks_per_second);
public:
explicit subsecond_duration(boost::int64_t ss)
;
};
} }
#define DATE_TIME_TIME_RESOLUTION_TRAITS_HPP
#define _DATE_TIME_INT_ADAPTER_HPP__
namespace boost {
namespace date_time {
template<typename int_type_>
class int_adapter {
public:
typedef int_type_ int_type;
int_adapter(int_type v)
;
static bool has_infinity()
;
static const int_adapter pos_infinity()
;
static const int_adapter neg_infinity()
;
static const int_adapter not_a_number()
;
static int_adapter max ()
;
static int_adapter min ()
;
static int_adapter from_special(special_values sv)
;
static bool is_inf(int_type v)
;
static bool is_neg_inf(int_type v)
;
static bool is_pos_inf(int_type v)
;
static bool is_not_a_number(int_type v)
;
static special_values to_special(int_type v)
;
static int_type maxcount()
;
bool is_infinity() const
;
bool is_pos_infinity()const
;
bool is_neg_infinity()const
;
bool is_nan() const
;
bool is_special() const
;
bool operator==(const int_adapter& rhs) const
;
bool operator==(const int& rhs) const
;
bool operator!=(const int_adapter& rhs) const
;
bool operator!=(const int& rhs) const
;
bool operator<(const int_adapter& rhs) const
;
bool operator<(const int& rhs) const
;
bool operator>(const int_adapter& rhs) const
;
int_type as_number() const
;
special_values as_special() const
;
template<class rhs_type>
int_adapter operator+(const int_adapter<rhs_type>& rhs) const
;
int_adapter operator+(const int_type rhs) const
;
template<class rhs_type>
int_adapter operator-(const int_adapter<rhs_type>& rhs)const
;
int_adapter operator-(const int_type rhs) const
;
int_adapter operator*(const int_adapter& rhs)const
;
int_adapter operator*(const int rhs) const
;
int_adapter operator/(const int_adapter& rhs)const
;
int_adapter operator/(const int rhs) const
;
int_adapter operator%(const int_adapter& rhs)const
;
int_adapter operator%(const int rhs) const
;
private:
int_type value_;
int compare(const int_adapter& rhs)const
;
int_adapter mult_div_specials(const int_adapter& rhs)const
;
int_adapter mult_div_specials(const int& rhs) const
;
};
template<class charT, class traits, typename int_type>
std::basic_ostream<charT, traits>&
operator<<(std::basic_ostream<charT, traits>& os, const int_adapter<int_type>& ia)
;
} }
namespace boost {
namespace date_time {
template <typename T>
T absolute_value(T x)
;
struct time_resolution_traits_bi32_impl {
typedef boost::int32_t int_type;
typedef boost::int32_t impl_type;
static int_type as_number(impl_type i);
static bool is_adapted() ;
};
struct time_resolution_traits_adapted32_impl {
typedef boost::int32_t int_type;
typedef boost::date_time::int_adapter<boost::int32_t> impl_type;
static int_type as_number(impl_type i);
static bool is_adapted() ;
};
struct time_resolution_traits_bi64_impl {
typedef boost::int64_t int_type;
typedef boost::int64_t impl_type;
static int_type as_number(impl_type i);
static bool is_adapted() ;
};
struct time_resolution_traits_adapted64_impl {
typedef boost::int64_t int_type;
typedef boost::date_time::int_adapter<boost::int64_t> impl_type;
static int_type as_number(impl_type i);
static bool is_adapted() ;
};
template<typename frac_sec_type,
time_resolutions res,
typename frac_sec_type::int_type resolution_adjust,
unsigned short frac_digits,
typename v_type = boost::int32_t >
class time_resolution_traits {
public:
typedef typename frac_sec_type::int_type fractional_seconds_type;
typedef typename frac_sec_type::int_type tick_type;
typedef typename frac_sec_type::impl_type impl_type;
typedef v_type day_type;
typedef v_type hour_type;
typedef v_type min_type;
typedef v_type sec_type;
static fractional_seconds_type as_number(impl_type i)
;
static bool is_adapted()
;
static const fractional_seconds_type ticks_per_second = resolution_adjust;
static time_resolutions resolution()
;
static unsigned short num_fractional_digits()
;
static fractional_seconds_type res_adjust()
;
static tick_type to_tick_count(hour_type hours,
min_type minutes,
sec_type seconds,
fractional_seconds_type fs)
;
};
typedef time_resolution_traits<time_resolution_traits_adapted32_impl, milli, 1000, 3 > milli_res;
typedef time_resolution_traits<time_resolution_traits_adapted64_impl, micro, 1000000, 6 > micro_res;
typedef time_resolution_traits<time_resolution_traits_adapted64_impl, nano, 1000000000, 9 > nano_res;
} }
#define _GREGORIAN_TYPES_HPP__
#define DATE_TIME_DATE_HPP___
#define YearMonthDayBase_HPP__
namespace boost {
namespace date_time {
template<typename YearType, typename MonthType, typename DayType>
struct year_month_day_base {
year_month_day_base(YearType year,
MonthType month,
DayType day);
YearType year;
MonthType month;
DayType day;
typedef YearType year_type;
typedef MonthType month_type;
typedef DayType day_type;
};
} }
namespace boost {
namespace date_time {
template<class T, class calendar, class duration_type_>
class date : private
boost::less_than_comparable<T
, boost::equality_comparable<T
> >
{
public:
typedef T date_type;
typedef calendar calendar_type;
typedef typename calendar::date_traits_type traits_type;
typedef duration_type_ duration_type;
typedef typename calendar::year_type year_type;
typedef typename calendar::month_type month_type;
typedef typename calendar::day_type day_type;
typedef typename calendar::ymd_type ymd_type;
typedef typename calendar::date_rep_type date_rep_type;
typedef typename calendar::date_int_type date_int_type;
typedef typename calendar::day_of_week_type day_of_week_type;
date(year_type y, month_type m, day_type d)
;
date(const ymd_type& ymd)
;
year_type year() const
;
month_type month() const
;
day_type day() const
;
day_of_week_type day_of_week() const
;
ymd_type year_month_day() const
;
bool operator<(const date_type& rhs) const
;
bool operator==(const date_type& rhs) const
;
bool is_special()const
;
bool is_not_a_date() const
;
bool is_infinity() const
;
bool is_pos_infinity() const
;
bool is_neg_infinity() const
;
special_values as_special() const
;
duration_type operator-(const date_type& d) const
;
date_type operator-(const duration_type& dd) const
;
date_type operator-=(const duration_type& dd)
;
date_rep_type day_count() const
;
date_type operator+(const duration_type& dd) const
;
date_type operator+=(const duration_type& dd)
;
protected:
explicit date(date_int_type days) ;
explicit date(date_rep_type days) ;
date_int_type days_;
};
} }
#define DATE_TIME_PERIOD_HPP___
namespace boost {
namespace date_time {
template<class point_rep, class duration_rep>
class period : private
boost::less_than_comparable<period<point_rep, duration_rep>
, boost::equality_comparable< period<point_rep, duration_rep>
> >
{
public:
typedef point_rep point_type;
typedef duration_rep duration_type;
period(point_rep first_point, point_rep end_point);
period(point_rep first_point, duration_rep len);
point_rep begin() const;
point_rep end() const;
point_rep last() const;
duration_rep length() const;
bool is_null() const;
bool operator==(const period& rhs) const;
bool operator<(const period& rhs) const;
void shift(const duration_rep& d);
void expand(const duration_rep& d);
bool contains(const point_rep& point) const;
bool contains(const period& other) const;
bool intersects(const period& other) const;
bool is_adjacent(const period& other) const;
bool is_before(const point_rep& point) const;
bool is_after(const point_rep& point) const;
period intersection(const period& other) const;
period merge(const period& other) const;
period span(const period& other) const;
private:
point_rep begin_;
point_rep last_;
};
} }
#define GREGORIAN_GREGORIAN_CALENDAR_HPP__
#define GREG_WEEKDAY_HPP___
#define CONSTRAINED_VALUE_HPP___
#define BOOST_MPL_IF_HPP_INCLUDED
#define BOOST_MPL_AUX_VALUE_WKND_HPP_INCLUDED
#define BOOST_MPL_AUX_STATIC_CAST_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED
#define BOOST_MPL_AUX_STATIC_CAST(T,expr) static_cast<T>(expr)
#define BOOST_MPL_AUX_CONFIG_INTEGRAL_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_ETI_HPP_INCLUDED
#define BOOST_MPL_AUX_VALUE_WKND(C) C
#define BOOST_MPL_AUX_MSVC_VALUE_WKND(C) C
#define BOOST_MPL_AUX_NESTED_VALUE_WKND(T,C) BOOST_MPL_AUX_VALUE_WKND(C)::value
namespace boost { namespace mpl { namespace aux {
template< typename T > struct value_type_wknd
{
typedef typename T::value_type type;
};
}}}
#define BOOST_MPL_AUX_NA_SPEC_HPP_INCLUDED
#define BOOST_MPL_LAMBDA_FWD_HPP_INCLUDED
#define BOOST_MPL_VOID_FWD_HPP_INCLUDED
#define BOOST_MPL_AUX_ADL_BARRIER_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_ADL_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_INTEL_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_GCC_HPP_INCLUDED
#define BOOST_MPL_CFG_GCC ((__GNUC__ << 8) | __GNUC_MINOR__)
#define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE mpl_
#define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN namespace mpl_ {
#define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE }
#define BOOST_MPL_AUX_ADL_BARRIER_DECL(type) namespace boost { namespace mpl { using ::BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::type; } }
namespace mpl_ { namespace aux {} }
namespace boost { namespace mpl { using namespace mpl_;
namespace aux { using namespace mpl_::aux; }
}}
namespace mpl_ {
struct void_;
}
namespace boost { namespace mpl { using ::mpl_::void_; } }
#define BOOST_MPL_AUX_NA_HPP_INCLUDED
#define BOOST_MPL_BOOL_HPP_INCLUDED
#define BOOST_MPL_BOOL_FWD_HPP_INCLUDED
namespace mpl_ {
template< bool C_ > struct bool_;
typedef bool_<true> true_;
typedef bool_<false> false_;
}
namespace boost { namespace mpl { using ::mpl_::bool_; } }
namespace boost { namespace mpl { using ::mpl_::true_; } }
namespace boost { namespace mpl { using ::mpl_::false_; } }
#define BOOST_MPL_INTEGRAL_C_TAG_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED
namespace mpl_ {
struct integral_c_tag { static const int value = 0; };
}
namespace boost { namespace mpl { using ::mpl_::integral_c_tag; } }
namespace mpl_ {
template< bool C_ > struct bool_
{
static const bool value = C_;
typedef integral_c_tag tag;
typedef bool_ type;
typedef bool value_type;
operator bool() const ;
};
template< bool C_ >
bool const bool_<C_>::value;
}
#define BOOST_MPL_AUX_NA_FWD_HPP_INCLUDED
namespace mpl_ {
struct na
{
typedef na type;
enum { value = 0 };
};
}
namespace boost { namespace mpl { using ::mpl_::na; } }
#define BOOST_MPL_AUX_CONFIG_CTPS_HPP_INCLUDED
namespace boost { namespace mpl {
template< typename T >
struct is_na
: false_
{
};
template<>
struct is_na<na>
: true_
{
};
template< typename T >
struct is_not_na
: true_
{
};
template<>
struct is_not_na<na>
: false_
{
};
template< typename T, typename U > struct if_na
{
typedef T type;
};
template< typename U > struct if_na<na,U>
{
typedef U type;
};
}}
#define BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_TTP_HPP_INCLUDED
#define BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING
#define BOOST_MPL_INT_HPP_INCLUDED
#define BOOST_MPL_INT_FWD_HPP_INCLUDED
#define BOOST_MPL_AUX_NTTP_DECL_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_NTTP_HPP_INCLUDED
#define BOOST_MPL_AUX_NTTP_DECL(T,x) T x
namespace mpl_ {
template< int N > struct int_;
}
namespace boost { namespace mpl { using ::mpl_::int_; } }
#define AUX_WRAPPER_VALUE_TYPE int
#define BOOST_PREPROCESSOR_CAT_HPP
#define BOOST_PREPROCESSOR_CONFIG_CONFIG_HPP
#define BOOST_PP_CONFIG_STRICT() 0x0001
#define BOOST_PP_CONFIG_IDEAL() 0x0002
#define BOOST_PP_CONFIG_MSVC() 0x0004
#define BOOST_PP_CONFIG_MWCC() 0x0008
#define BOOST_PP_CONFIG_BCC() 0x0010
#define BOOST_PP_CONFIG_EDG() 0x0020
#define BOOST_PP_CONFIG_DMC() 0x0040
#define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT())
#define BOOST_PP_CONFIG_EXTENDED_LINE_INFO 0
#define BOOST_PP_CONFIG_ERRORS 0
#define BOOST_PP_VARIADICS 1
#define BOOST_PP_CAT(a,b) BOOST_PP_CAT_I(a, b)
#define BOOST_PP_CAT_I(a,b) a ## b
#define AUX_WRAPPER_NAME BOOST_PP_CAT(AUX_WRAPPER_VALUE_TYPE,_)
#define AUX_WRAPPER_PARAMS(N) BOOST_MPL_AUX_NTTP_DECL(AUX_WRAPPER_VALUE_TYPE, N)
#define AUX_WRAPPER_INST(value) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::AUX_WRAPPER_NAME< value >
namespace mpl_ {
template< int N >
struct int_
{
static const int value = N;
typedef int_ type;
typedef int value_type;
typedef integral_c_tag tag;
typedef mpl_::int_< static_cast<int>((value + 1)) > next;
typedef mpl_::int_< static_cast<int>((value - 1)) > prior;
operator int() const ;
};
template< int N >
int const mpl_::int_< N >::value;
}
#undef AUX_WRAPPER_NAME
#undef AUX_WRAPPER_PARAMS
#undef AUX_WRAPPER_INST
#undef AUX_WRAPPER_VALUE_TYPE
#define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED
#define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(param) , param
#define BOOST_MPL_AUX_TEMPLATE_ARITY_FWD_HPP_INCLUDED
namespace boost { namespace mpl { namespace aux {
template< typename F > struct template_arity;
}}}
namespace boost { namespace mpl {
template<
typename T = na
, typename Tag = void_
, typename Arity = int_< aux::template_arity<T>::value >
>
struct lambda;
}}
#define BOOST_MPL_AUX_ARITY_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_DTP_HPP_INCLUDED
#define BOOST_MPL_AUX_PREPROCESSOR_PARAMS_HPP_INCLUDED
#define BOOST_MPL_AUX_CONFIG_PREPROCESSOR_HPP_INCLUDED
#define BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES
#define BOOST_PREPROCESSOR_COMMA_IF_HPP
#define BOOST_PREPROCESSOR_PUNCTUATION_COMMA_IF_HPP
#define BOOST_PREPROCESSOR_CONTROL_IF_HPP
#define BOOST_PREPROCESSOR_CONTROL_IIF_HPP
#define BOOST_PP_IIF(bit,t,f) BOOST_PP_IIF_I(bit, t, f)
#define BOOST_PP_IIF_I(bit,t,f) BOOST_PP_IIF_ ## bit(t, f)
#define BOOST_PP_IIF_0(t,f) f
#define BOOST_PP_IIF_1(t,f) t
#define BOOST_PREPROCESSOR_LOGICAL_BOOL_HPP
#define BOOST_PP_BOOL(x) BOOST_PP_BOOL_I(x)
#define BOOST_PP_BOOL_I(x) BOOST_PP_BOOL_ ## x
#define BOOST_PP_BOOL_0 0
#define BOOST_PP_BOOL_1 1
#define BOOST_PP_BOOL_2 1
#define BOOST_PP_BOOL_3 1
#define BOOST_PP_BOOL_4 1
#define BOOST_PP_BOOL_5 1
#define BOOST_PP_BOOL_6 1
#define BOOST_PP_BOOL_7 1
#define BOOST_PP_BOOL_8 1
#define BOOST_PP_BOOL_9 1
#define BOOST_PP_BOOL_10 1
#define BOOST_PP_BOOL_11 1
#define BOOST_PP_BOOL_12 1
#define BOOST_PP_BOOL_13 1
#define BOOST_PP_BOOL_14 1
#define BOOST_PP_BOOL_15 1
#define BOOST_PP_BOOL_16 1
#define BOOST_PP_BOOL_17 1
#define BOOST_PP_BOOL_18 1
#define BOOST_PP_BOOL_19 1
#define BOOST_PP_BOOL_20 1
#define BOOST_PP_BOOL_21 1
#define BOOST_PP_BOOL_22 1
#define BOOST_PP_BOOL_23 1
#define BOOST_PP_BOOL_24 1
#define BOOST_PP_BOOL_25 1
#define BOOST_PP_BOOL_26 1
#define BOOST_PP_BOOL_27 1
#define BOOST_PP_BOOL_28 1
#define BOOST_PP_BOOL_29 1
#define BOOST_PP_BOOL_30 1
#define BOOST_PP_BOOL_31 1
#define BOOST_PP_BOOL_32 1
#define BOOST_PP_BOOL_33 1
#define BOOST_PP_BOOL_34 1
#define BOOST_PP_BOOL_35 1
#define BOOST_PP_BOOL_36 1
#define BOOST_PP_BOOL_37 1
#define BOOST_PP_BOOL_38 1
#define BOOST_PP_BOOL_39 1
#define BOOST_PP_BOOL_40 1
#define BOOST_PP_BOOL_41 1
#define BOOST_PP_BOOL_42 1
#define BOOST_PP_BOOL_43 1
#define BOOST_PP_BOOL_44 1
#define BOOST_PP_BOOL_45 1
#define BOOST_PP_BOOL_46 1
#define BOOST_PP_BOOL_47 1
#define BOOST_PP_BOOL_48 1
#define BOOST_PP_BOOL_49 1
#define BOOST_PP_BOOL_50 1
#define BOOST_PP_BOOL_51 1
#define BOOST_PP_BOOL_52 1
#define BOOST_PP_BOOL_53 1
#define BOOST_PP_BOOL_54 1
#define BOOST_PP_BOOL_55 1
#define BOOST_PP_BOOL_56 1
#define BOOST_PP_BOOL_57 1
#define BOOST_PP_BOOL_58 1
#define BOOST_PP_BOOL_59 1
#define BOOST_PP_BOOL_60 1
#define BOOST_PP_BOOL_61 1
#define BOOST_PP_BOOL_62 1
#define BOOST_PP_BOOL_63 1
#define BOOST_PP_BOOL_64 1
#define BOOST_PP_BOOL_65 1
#define BOOST_PP_BOOL_66 1
#define BOOST_PP_BOOL_67 1
#define BOOST_PP_BOOL_68 1
#define BOOST_PP_BOOL_69 1
#define BOOST_PP_BOOL_70 1
#define BOOST_PP_BOOL_71 1
#define BOOST_PP_BOOL_72 1
#define BOOST_PP_BOOL_73 1
#define BOOST_PP_BOOL_74 1
#define BOOST_PP_BOOL_75 1
#define BOOST_PP_BOOL_76 1
#define BOOST_PP_BOOL_77 1
#define BOOST_PP_BOOL_78 1
#define BOOST_PP_BOOL_79 1
#define BOOST_PP_BOOL_80 1
#define BOOST_PP_BOOL_81 1
#define BOOST_PP_BOOL_82 1
#define BOOST_PP_BOOL_83 1
#define BOOST_PP_BOOL_84 1
#define BOOST_PP_BOOL_85 1
#define BOOST_PP_BOOL_86 1
#define BOOST_PP_BOOL_87 1
#define BOOST_PP_BOOL_88 1
#define BOOST_PP_BOOL_89 1
#define BOOST_PP_BOOL_90 1
#define BOOST_PP_BOOL_91 1
#define BOOST_PP_BOOL_92 1
#define BOOST_PP_BOOL_93 1
#define BOOST_PP_BOOL_94 1
#define BOOST_PP_BOOL_95 1
#define BOOST_PP_BOOL_96 1
#define BOOST_PP_BOOL_97 1
#define BOOST_PP_BOOL_98 1
#define BOOST_PP_BOOL_99 1
#define BOOST_PP_BOOL_100 1
#define BOOST_PP_BOOL_101 1
#define BOOST_PP_BOOL_102 1
#define BOOST_PP_BOOL_103 1
#define BOOST_PP_BOOL_104 1
#define BOOST_PP_BOOL_105 1
#define BOOST_PP_BOOL_106 1
#define BOOST_PP_BOOL_107 1
#define BOOST_PP_BOOL_108 1
#define BOOST_PP_BOOL_109 1
#define BOOST_PP_BOOL_110 1
#define BOOST_PP_BOOL_111 1
#define BOOST_PP_BOOL_112 1
#define BOOST_PP_BOOL_113 1
#define BOOST_PP_BOOL_114 1
#define BOOST_PP_BOOL_115 1
#define BOOST_PP_BOOL_116 1
#define BOOST_PP_BOOL_117 1
#define BOOST_PP_BOOL_118 1
#define BOOST_PP_BOOL_119 1
#define BOOST_PP_BOOL_120 1
#define BOOST_PP_BOOL_121 1
#define BOOST_PP_BOOL_122 1
#define BOOST_PP_BOOL_123 1
#define BOOST_PP_BOOL_124 1
#define BOOST_PP_BOOL_125 1
#define BOOST_PP_BOOL_126 1
#define BOOST_PP_BOOL_127 1
#define BOOST_PP_BOOL_128 1
#define BOOST_PP_BOOL_129 1
#define BOOST_PP_BOOL_130 1
#define BOOST_PP_BOOL_131 1
#define BOOST_PP_BOOL_132 1
#define BOOST_PP_BOOL_133 1
#define BOOST_PP_BOOL_134 1
#define BOOST_PP_BOOL_135 1
#define BOOST_PP_BOOL_136 1
#define BOOST_PP_BOOL_137 1
#define BOOST_PP_BOOL_138 1
#define BOOST_PP_BOOL_139 1
#define BOOST_PP_BOOL_140 1
#define BOOST_PP_BOOL_141 1
#define BOOST_PP_BOOL_142 1
#define BOOST_PP_BOOL_143 1
#define BOOST_PP_BOOL_144 1
#define BOOST_PP_BOOL_145 1
#define BOOST_PP_BOOL_146 1
#define BOOST_PP_BOOL_147 1
#define BOOST_PP_BOOL_148 1
#define BOOST_PP_BOOL_149 1
#define BOOST_PP_BOOL_150 1
#define BOOST_PP_BOOL_151 1
#define BOOST_PP_BOOL_152 1
#define BOOST_PP_BOOL_153 1
#define BOOST_PP_BOOL_154 1
#define BOOST_PP_BOOL_155 1
#define BOOST_PP_BOOL_156 1
#define BOOST_PP_BOOL_157 1
#define BOOST_PP_BOOL_158 1
#define BOOST_PP_BOOL_159 1
#define BOOST_PP_BOOL_160 1
#define BOOST_PP_BOOL_161 1
#define BOOST_PP_BOOL_162 1
#define BOOST_PP_BOOL_163 1
#define BOOST_PP_BOOL_164 1
#define BOOST_PP_BOOL_165 1
#define BOOST_PP_BOOL_166 1
#define BOOST_PP_BOOL_167 1
#define BOOST_PP_BOOL_168 1
#define BOOST_PP_BOOL_169 1
#define BOOST_PP_BOOL_170 1
#define BOOST_PP_BOOL_171 1
#define BOOST_PP_BOOL_172 1
#define BOOST_PP_BOOL_173 1
#define BOOST_PP_BOOL_174 1
#define BOOST_PP_BOOL_175 1
#define BOOST_PP_BOOL_176 1
#define BOOST_PP_BOOL_177 1
#define BOOST_PP_BOOL_178 1
#define BOOST_PP_BOOL_179 1
#define BOOST_PP_BOOL_180 1
#define BOOST_PP_BOOL_181 1
#define BOOST_PP_BOOL_182 1
#define BOOST_PP_BOOL_183 1
#define BOOST_PP_BOOL_184 1
#define BOOST_PP_BOOL_185 1
#define BOOST_PP_BOOL_186 1
#define BOOST_PP_BOOL_187 1
#define BOOST_PP_BOOL_188 1
#define BOOST_PP_BOOL_189 1
#define BOOST_PP_BOOL_190 1
#define BOOST_PP_BOOL_191 1
#define BOOST_PP_BOOL_192 1
#define BOOST_PP_BOOL_193 1
#define BOOST_PP_BOOL_194 1
#define BOOST_PP_BOOL_195 1
#define BOOST_PP_BOOL_196 1
#define BOOST_PP_BOOL_197 1
#define BOOST_PP_BOOL_198 1
#define BOOST_PP_BOOL_199 1
#define BOOST_PP_BOOL_200 1
#define BOOST_PP_BOOL_201 1
#define BOOST_PP_BOOL_202 1
#define BOOST_PP_BOOL_203 1
#define BOOST_PP_BOOL_204 1
#define BOOST_PP_BOOL_205 1
#define BOOST_PP_BOOL_206 1
#define BOOST_PP_BOOL_207 1
#define BOOST_PP_BOOL_208 1
#define BOOST_PP_BOOL_209 1
#define BOOST_PP_BOOL_210 1
#define BOOST_PP_BOOL_211 1
#define BOOST_PP_BOOL_212 1
#define BOOST_PP_BOOL_213 1
#define BOOST_PP_BOOL_214 1
#define BOOST_PP_BOOL_215 1
#define BOOST_PP_BOOL_216 1
#define BOOST_PP_BOOL_217 1
#define BOOST_PP_BOOL_218 1
#define BOOST_PP_BOOL_219 1
#define BOOST_PP_BOOL_220 1
#define BOOST_PP_BOOL_221 1
#define BOOST_PP_BOOL_222 1
#define BOOST_PP_BOOL_223 1
#define BOOST_PP_BOOL_224 1
#define BOOST_PP_BOOL_225 1
#define BOOST_PP_BOOL_226 1
#define BOOST_PP_BOOL_227 1
#define BOOST_PP_BOOL_228 1
#define BOOST_PP_BOOL_229 1
#define BOOST_PP_BOOL_230 1
#define BOOST_PP_BOOL_231 1
#define BOOST_PP_BOOL_232 1
#define BOOST_PP_BOOL_233 1
#define BOOST_PP_BOOL_234 1
#define BOOST_PP_BOOL_235 1
#define BOOST_PP_BOOL_236 1
#define BOOST_PP_BOOL_237 1
#define BOOST_PP_BOOL_238 1
#define BOOST_PP_BOOL_239 1
#define BOOST_PP_BOOL_240 1
#define BOOST_PP_BOOL_241 1
#define BOOST_PP_BOOL_242 1
#define BOOST_PP_BOOL_243 1
#define BOOST_PP_BOOL_244 1
#define BOOST_PP_BOOL_245 1
#define BOOST_PP_BOOL_246 1
#define BOOST_PP_BOOL_247 1
#define BOOST_PP_BOOL_248 1
#define BOOST_PP_BOOL_249 1
#define BOOST_PP_BOOL_250 1
#define BOOST_PP_BOOL_251 1
#define BOOST_PP_BOOL_252 1
#define BOOST_PP_BOOL_253 1
#define BOOST_PP_BOOL_254 1
#define BOOST_PP_BOOL_255 1
#define BOOST_PP_BOOL_256 1
#define BOOST_PP_IF(cond,t,f) BOOST_PP_IIF(BOOST_PP_BOOL(cond), t, f)
#define BOOST_PREPROCESSOR_FACILITIES_EMPTY_HPP
#define BOOST_PP_EMPTY()
#define BOOST_PREPROCESSOR_PUNCTUATION_COMMA_HPP
#define BOOST_PP_COMMA() ,
#define BOOST_PP_COMMA_IF(cond) BOOST_PP_IF(cond, BOOST_PP_COMMA, BOOST_PP_EMPTY)()
#define BOOST_PREPROCESSOR_REPEAT_HPP
#define BOOST_PREPROCESSOR_REPETITION_REPEAT_HPP
#define BOOST_PREPROCESSOR_DEBUG_ERROR_HPP
#define BOOST_PP_ERROR_0x0000 BOOST_PP_ERROR(0x0000, BOOST_PP_INDEX_OUT_OF_BOUNDS)
#define BOOST_PP_ERROR_0x0001 BOOST_PP_ERROR(0x0001, BOOST_PP_WHILE_OVERFLOW)
#define BOOST_PP_ERROR_0x0002 BOOST_PP_ERROR(0x0002, BOOST_PP_FOR_OVERFLOW)
#define BOOST_PP_ERROR_0x0003 BOOST_PP_ERROR(0x0003, BOOST_PP_REPEAT_OVERFLOW)
#define BOOST_PP_ERROR_0x0004 BOOST_PP_ERROR(0x0004, BOOST_PP_LIST_FOLD_OVERFLOW)
#define BOOST_PP_ERROR_0x0005 BOOST_PP_ERROR(0x0005, BOOST_PP_SEQ_FOLD_OVERFLOW)
#define BOOST_PP_ERROR_0x0006 BOOST_PP_ERROR(0x0006, BOOST_PP_ARITHMETIC_OVERFLOW)
#define BOOST_PP_ERROR_0x0007 BOOST_PP_ERROR(0x0007, BOOST_PP_DIVISION_BY_ZERO)
#define BOOST_PREPROCESSOR_DETAIL_AUTO_REC_HPP
#define BOOST_PP_AUTO_REC(pred,n) BOOST_PP_NODE_ENTRY_ ## n(pred)
#define BOOST_PP_NODE_ENTRY_256(p) BOOST_PP_NODE_128(p)(p)(p)(p)(p)(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_128(p) BOOST_PP_NODE_64(p)(p)(p)(p)(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_64(p) BOOST_PP_NODE_32(p)(p)(p)(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_32(p) BOOST_PP_NODE_16(p)(p)(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_16(p) BOOST_PP_NODE_8(p)(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_8(p) BOOST_PP_NODE_4(p)(p)(p)
#define BOOST_PP_NODE_ENTRY_4(p) BOOST_PP_NODE_2(p)(p)
#define BOOST_PP_NODE_ENTRY_2(p) BOOST_PP_NODE_1(p)
#define BOOST_PP_NODE_128(p) BOOST_PP_IIF(p(128), BOOST_PP_NODE_64, BOOST_PP_NODE_192)
#define BOOST_PP_NODE_64(p) BOOST_PP_IIF(p(64), BOOST_PP_NODE_32, BOOST_PP_NODE_96)
#define BOOST_PP_NODE_32(p) BOOST_PP_IIF(p(32), BOOST_PP_NODE_16, BOOST_PP_NODE_48)
#define BOOST_PP_NODE_16(p) BOOST_PP_IIF(p(16), BOOST_PP_NODE_8, BOOST_PP_NODE_24)
#define BOOST_PP_NODE_8(p) BOOST_PP_IIF(p(8), BOOST_PP_NODE_4, BOOST_PP_NODE_12)
#define BOOST_PP_NODE_4(p) BOOST_PP_IIF(p(4), BOOST_PP_NODE_2, BOOST_PP_NODE_6)
#define BOOST_PP_NODE_2(p) BOOST_PP_IIF(p(2), BOOST_PP_NODE_1, BOOST_PP_NODE_3)
#define BOOST_PP_NODE_1(p) BOOST_PP_IIF(p(1), 1, 2)
#define BOOST_PP_NODE_3(p) BOOST_PP_IIF(p(3), 3, 4)
#define BOOST_PP_NODE_6(p) BOOST_PP_IIF(p(6), BOOST_PP_NODE_5, BOOST_PP_NODE_7)
#define BOOST_PP_NODE_5(p) BOOST_PP_IIF(p(5), 5, 6)
#define BOOST_PP_NODE_7(p) BOOST_PP_IIF(p(7), 7, 8)
#define BOOST_PP_NODE_12(p) BOOST_PP_IIF(p(12), BOOST_PP_NODE_10, BOOST_PP_NODE_14)
#define BOOST_PP_NODE_10(p) BOOST_PP_IIF(p(10), BOOST_PP_NODE_9, BOOST_PP_NODE_11)
#define BOOST_PP_NODE_9(p) BOOST_PP_IIF(p(9), 9, 10)
#define BOOST_PP_NODE_11(p) BOOST_PP_IIF(p(11), 11, 12)
#define BOOST_PP_NODE_14(p) BOOST_PP_IIF(p(14), BOOST_PP_NODE_13, BOOST_PP_NODE_15)
#define BOOST_PP_NODE_13(p) BOOST_PP_IIF(p(13), 13, 14)
#define BOOST_PP_NODE_15(p) BOOST_PP_IIF(p(15), 15, 16)
#define BOOST_PP_NODE_24(p) BOOST_PP_IIF(p(24), BOOST_PP_NODE_20, BOOST_PP_NODE_28)
#define BOOST_PP_NODE_20(p) BOOST_PP_IIF(p(20), BOOST_PP_NODE_18, BOOST_PP_NODE_22)
#define BOOST_PP_NODE_18(p) BOOST_PP_IIF(p(18), BOOST_PP_NODE_17, BOOST_PP_NODE_19)
#define BOOST_PP_NODE_17(p) BOOST_PP_IIF(p(17), 17, 18)
#define BOOST_PP_NODE_19(p) BOOST_PP_IIF(p(19), 19, 20)
#define BOOST_PP_NODE_22(p) BOOST_PP_IIF(p(22), BOOST_PP_NODE_21, BOOST_PP_NODE_23)
#define BOOST_PP_NODE_21(p) BOOST_PP_IIF(p(21), 21, 22)
#define BOOST_PP_NODE_23(p) BOOST_PP_IIF(p(23), 23, 24)
#define BOOST_PP_NODE_28(p) BOOST_PP_IIF(p(28), BOOST_PP_NODE_26, BOOST_PP_NODE_30)
#define BOOST_PP_NODE_26(p) BOOST_PP_IIF(p(26), BOOST_PP_NODE_25, BOOST_PP_NODE_27)
#define BOOST_PP_NODE_25(p) BOOST_PP_IIF(p(25), 25, 26)
#define BOOST_PP_NODE_27(p) BOOST_PP_IIF(p(27), 27, 28)
#define BOOST_PP_NODE_30(p) BOOST_PP_IIF(p(30), BOOST_PP_NODE_29, BOOST_PP_NODE_31)
#define BOOST_PP_NODE_29(p) BOOST_PP_IIF(p(29), 29, 30)
#define BOOST_PP_NODE_31(p) BOOST_PP_IIF(p(31), 31, 32)
#define BOOST_PP_NODE_48(p) BOOST_PP_IIF(p(48), BOOST_PP_NODE_40, BOOST_PP_NODE_56)
#define BOOST_PP_NODE_40(p) BOOST_PP_IIF(p(40), BOOST_PP_NODE_36, BOOST_PP_NODE_44)
#define BOOST_PP_NODE_36(p) BOOST_PP_IIF(p(36), BOOST_PP_NODE_34, BOOST_PP_NODE_38)
#define BOOST_PP_NODE_34(p) BOOST_PP_IIF(p(34), BOOST_PP_NODE_33, BOOST_PP_NODE_35)
#define BOOST_PP_NODE_33(p) BOOST_PP_IIF(p(33), 33, 34)
#define BOOST_PP_NODE_35(p) BOOST_PP_IIF(p(35), 35, 36)
#define BOOST_PP_NODE_38(p) BOOST_PP_IIF(p(38), BOOST_PP_NODE_37, BOOST_PP_NODE_39)
#define BOOST_PP_NODE_37(p) BOOST_PP_IIF(p(37), 37, 38)
#define BOOST_PP_NODE_39(p) BOOST_PP_IIF(p(39), 39, 40)
#define BOOST_PP_NODE_44(p) BOOST_PP_IIF(p(44), BOOST_PP_NODE_42, BOOST_PP_NODE_46)
#define BOOST_PP_NODE_42(p) BOOST_PP_IIF(p(42), BOOST_PP_NODE_41, BOOST_PP_NODE_43)
#define BOOST_PP_NODE_41(p) BOOST_PP_IIF(p(41), 41, 42)
#define BOOST_PP_NODE_43(p) BOOST_PP_IIF(p(43), 43, 44)
#define BOOST_PP_NODE_46(p) BOOST_PP_IIF(p(46), BOOST_PP_NODE_45, BOOST_PP_NODE_47)
#define BOOST_PP_NODE_45(p) BOOST_PP_IIF(p(45), 45, 46)
#define BOOST_PP_NODE_47(p) BOOST_PP_IIF(p(47), 47, 48)
#define BOOST_PP_NODE_56(p) BOOST_PP_IIF(p(56), BOOST_PP_NODE_52, BOOST_PP_NODE_60)
#define BOOST_PP_NODE_52(p) BOOST_PP_IIF(p(52), BOOST_PP_NODE_50, BOOST_PP_NODE_54)
#define BOOST_PP_NODE_50(p) BOOST_PP_IIF(p(50), BOOST_PP_NODE_49, BOOST_PP_NODE_51)
#define BOOST_PP_NODE_49(p) BOOST_PP_IIF(p(49), 49, 50)
#define BOOST_PP_NODE_51(p) BOOST_PP_IIF(p(51), 51, 52)
#define BOOST_PP_NODE_54(p) BOOST_PP_IIF(p(54), BOOST_PP_NODE_53, BOOST_PP_NODE_55)
#define BOOST_PP_NODE_53(p) BOOST_PP_IIF(p(53), 53, 54)
#define BOOST_PP_NODE_55(p) BOOST_PP_IIF(p(55), 55, 56)
#define BOOST_PP_NODE_60(p) BOOST_PP_IIF(p(60), BOOST_PP_NODE_58, BOOST_PP_NODE_62)
#define BOOST_PP_NODE_58(p) BOOST_PP_IIF(p(58), BOOST_PP_NODE_57, BOOST_PP_NODE_59)
#define BOOST_PP_NODE_57(p) BOOST_PP_IIF(p(57), 57, 58)
#define BOOST_PP_NODE_59(p) BOOST_PP_IIF(p(59), 59, 60)
#define BOOST_PP_NODE_62(p) BOOST_PP_IIF(p(62), BOOST_PP_NODE_61, BOOST_PP_NODE_63)
#define BOOST_PP_NODE_61(p) BOOST_PP_IIF(p(61), 61, 62)
#define BOOST_PP_NODE_63(p) BOOST_PP_IIF(p(63), 63, 64)
#define BOOST_PP_NODE_96(p) BOOST_PP_IIF(p(96), BOOST_PP_NODE_80, BOOST_PP_NODE_112)
#define BOOST_PP_NODE_80(p) BOOST_PP_IIF(p(80), BOOST_PP_NODE_72, BOOST_PP_NODE_88)
#define BOOST_PP_NODE_72(p) BOOST_PP_IIF(p(72), BOOST_PP_NODE_68, BOOST_PP_NODE_76)
#define BOOST_PP_NODE_68(p) BOOST_PP_IIF(p(68), BOOST_PP_NODE_66, BOOST_PP_NODE_70)
#define BOOST_PP_NODE_66(p) BOOST_PP_IIF(p(66), BOOST_PP_NODE_65, BOOST_PP_NODE_67)
#define BOOST_PP_NODE_65(p) BOOST_PP_IIF(p(65), 65, 66)
#define BOOST_PP_NODE_67(p) BOOST_PP_IIF(p(67), 67, 68)
#define BOOST_PP_NODE_70(p) BOOST_PP_IIF(p(70), BOOST_PP_NODE_69, BOOST_PP_NODE_71)
#define BOOST_PP_NODE_69(p) BOOST_PP_IIF(p(69), 69, 70)
#define BOOST_PP_NODE_71(p) BOOST_PP_IIF(p(71), 71, 72)
#define BOOST_PP_NODE_76(p) BOOST_PP_IIF(p(76), BOOST_PP_NODE_74, BOOST_PP_NODE_78)
#define BOOST_PP_NODE_74(p) BOOST_PP_IIF(p(74), BOOST_PP_NODE_73, BOOST_PP_NODE_75)
#define BOOST_PP_NODE_73(p) BOOST_PP_IIF(p(73), 73, 74)
#define BOOST_PP_NODE_75(p) BOOST_PP_IIF(p(75), 75, 76)
#define BOOST_PP_NODE_78(p) BOOST_PP_IIF(p(78), BOOST_PP_NODE_77, BOOST_PP_NODE_79)
#define BOOST_PP_NODE_77(p) BOOST_PP_IIF(p(77), 77, 78)
#define BOOST_PP_NODE_79(p) BOOST_PP_IIF(p(79), 79, 80)
#define BOOST_PP_NODE_88(p) BOOST_PP_IIF(p(88), BOOST_PP_NODE_84, BOOST_PP_NODE_92)
#define BOOST_PP_NODE_84(p) BOOST_PP_IIF(p(84), BOOST_PP_NODE_82, BOOST_PP_NODE_86)
#define BOOST_PP_NODE_82(p) BOOST_PP_IIF(p(82), BOOST_PP_NODE_81, BOOST_PP_NODE_83)
#define BOOST_PP_NODE_81(p) BOOST_PP_IIF(p(81), 81, 82)
#define BOOST_PP_NODE_83(p) BOOST_PP_IIF(p(83), 83, 84)
#define BOOST_PP_NODE_86(p) BOOST_PP_IIF(p(86), BOOST_PP_NODE_85, BOOST_PP_NODE_87)
#define BOOST_PP_NODE_85(p) BOOST_PP_IIF(p(85), 85, 86)
#define BOOST_PP_NODE_87(p) BOOST_PP_IIF(p(87), 87, 88)
#define BOOST_PP_NODE_92(p) BOOST_PP_IIF(p(92), BOOST_PP_NODE_90, BOOST_PP_NODE_94)
#define BOOST_PP_NODE_90(p) BOOST_PP_IIF(p(90), BOOST_PP_NODE_89, BOOST_PP_NODE_91)
#define BOOST_PP_NODE_89(p) BOOST_PP_IIF(p(89), 89, 90)
#define BOOST_PP_NODE_91(p) BOOST_PP_IIF(p(91), 91, 92)
#define BOOST_PP_NODE_94(p) BOOST_PP_IIF(p(94), BOOST_PP_NODE_93, BOOST_PP_NODE_95)
#define BOOST_PP_NODE_93(p) BOOST_PP_IIF(p(93), 93, 94)
#define BOOST_PP_NODE_95(p) BOOST_PP_IIF(p(95), 95, 96)
#define BOOST_PP_NODE_112(p) BOOST_PP_IIF(p(112), BOOST_PP_NODE_104, BOOST_PP_NODE_120)
#define BOOST_PP_NODE_104(p) BOOST_PP_IIF(p(104), BOOST_PP_NODE_100, BOOST_PP_NODE_108)
#define BOOST_PP_NODE_100(p) BOOST_PP_IIF(p(100), BOOST_PP_NODE_98, BOOST_PP_NODE_102)
#define BOOST_PP_NODE_98(p) BOOST_PP_IIF(p(98), BOOST_PP_NODE_97, BOOST_PP_NODE_99)
#define BOOST_PP_NODE_97(p) BOOST_PP_IIF(p(97), 97, 98)
#define BOOST_PP_NODE_99(p) BOOST_PP_IIF(p(99), 99, 100)
#define BOOST_PP_NODE_102(p) BOOST_PP_IIF(p(102), BOOST_PP_NODE_101, BOOST_PP_NODE_103)
#define BOOST_PP_NODE_101(p) BOOST_PP_IIF(p(101), 101, 102)
#define BOOST_PP_NODE_103(p) BOOST_PP_IIF(p(103), 103, 104)
#define BOOST_PP_NODE_108(p) BOOST_PP_IIF(p(108), BOOST_PP_NODE_106, BOOST_PP_NODE_110)
#define BOOST_PP_NODE_106(p) BOOST_PP_IIF(p(106), BOOST_PP_NODE_105, BOOST_PP_NODE_107)
#define BOOST_PP_NODE_105(p) BOOST_PP_IIF(p(105), 105, 106)
#define BOOST_PP_NODE_107(p) BOOST_PP_IIF(p(107), 107, 108)
#define BOOST_PP_NODE_110(p) BOOST_PP_IIF(p(110), BOOST_PP_NODE_109, BOOST_PP_NODE_111)
#define BOOST_PP_NODE_109(p) BOOST_PP_IIF(p(109), 109, 110)
#define BOOST_PP_NODE_111(p) BOOST_PP_IIF(p(111), 111, 112)
#define BOOST_PP_NODE_120(p) BOOST_PP_IIF(p(120), BOOST_PP_NODE_116, BOOST_PP_NODE_124)
#define BOOST_PP_NODE_116(p) BOOST_PP_IIF(p(116), BOOST_PP_NODE_114, BOOST_PP_NODE_118)
#define BOOST_PP_NODE_114(p) BOOST_PP_IIF(p(114), BOOST_PP_NODE_113, BOOST_PP_NODE_115)
#define BOOST_PP_NODE_113(p) BOOST_PP_IIF(p(113), 113, 114)
#define BOOST_PP_NODE_115(p) BOOST_PP_IIF(p(115), 115, 116)
#define BOOST_PP_NODE_118(p) BOOST_PP_IIF(p(118), BOOST_PP_NODE_117, BOOST_PP_NODE_119)
#define BOOST_PP_NODE_117(p) BOOST_PP_IIF(p(117), 117, 118)
#define BOOST_PP_NODE_119(p) BOOST_PP_IIF(p(119), 119, 120)
#define BOOST_PP_NODE_124(p) BOOST_PP_IIF(p(124), BOOST_PP_NODE_122, BOOST_PP_NODE_126)
#define BOOST_PP_NODE_122(p) BOOST_PP_IIF(p(122), BOOST_PP_NODE_121, BOOST_PP_NODE_123)
#define BOOST_PP_NODE_121(p) BOOST_PP_IIF(p(121), 121, 122)
#define BOOST_PP_NODE_123(p) BOOST_PP_IIF(p(123), 123, 124)
#define BOOST_PP_NODE_126(p) BOOST_PP_IIF(p(126), BOOST_PP_NODE_125, BOOST_PP_NODE_127)
#define BOOST_PP_NODE_125(p) BOOST_PP_IIF(p(125), 125, 126)
#define BOOST_PP_NODE_127(p) BOOST_PP_IIF(p(127), 127, 128)
#define BOOST_PP_NODE_192(p) BOOST_PP_IIF(p(192), BOOST_PP_NODE_160, BOOST_PP_NODE_224)
#define BOOST_PP_NODE_160(p) BOOST_PP_IIF(p(160), BOOST_PP_NODE_144, BOOST_PP_NODE_176)
#define BOOST_PP_NODE_144(p) BOOST_PP_IIF(p(144), BOOST_PP_NODE_136, BOOST_PP_NODE_152)
#define BOOST_PP_NODE_136(p) BOOST_PP_IIF(p(136), BOOST_PP_NODE_132, BOOST_PP_NODE_140)
#define BOOST_PP_NODE_132(p) BOOST_PP_IIF(p(132), BOOST_PP_NODE_130, BOOST_PP_NODE_134)
#define BOOST_PP_NODE_130(p) BOOST_PP_IIF(p(130), BOOST_PP_NODE_129, BOOST_PP_NODE_131)
#define BOOST_PP_NODE_129(p) BOOST_PP_IIF(p(129), 129, 130)
#define BOOST_PP_NODE_131(p) BOOST_PP_IIF(p(131), 131, 132)
#define BOOST_PP_NODE_134(p) BOOST_PP_IIF(p(134), BOOST_PP_NODE_133, BOOST_PP_NODE_135)
#define BOOST_PP_NODE_133(p) BOOST_PP_IIF(p(133), 133, 134)
#define BOOST_PP_NODE_135(p) BOOST_PP_IIF(p(135), 135, 136)
#define BOOST_PP_NODE_140(p) BOOST_PP_IIF(p(140), BOOST_PP_NODE_138, BOOST_PP_NODE_142)
#define BOOST_PP_NODE_138(p) BOOST_PP_IIF(p(138), BOOST_PP_NODE_137, BOOST_PP_NODE_139)
#define BOOST_PP_NODE_137(p) BOOST_PP_IIF(p(137), 137, 138)
#define BOOST_PP_NODE_139(p) BOOST_PP_IIF(p(139), 139, 140)
#define BOOST_PP_NODE_142(p) BOOST_PP_IIF(p(142), BOOST_PP_NODE_141, BOOST_PP_NODE_143)
#define BOOST_PP_NODE_141(p) BOOST_PP_IIF(p(141), 141, 142)
#define BOOST_PP_NODE_143(p) BOOST_PP_IIF(p(143), 143, 144)
#define BOOST_PP_NODE_152(p) BOOST_PP_IIF(p(152), BOOST_PP_NODE_148, BOOST_PP_NODE_156)
#define BOOST_PP_NODE_148(p) BOOST_PP_IIF(p(148), BOOST_PP_NODE_146, BOOST_PP_NODE_150)
#define BOOST_PP_NODE_146(p) BOOST_PP_IIF(p(146), BOOST_PP_NODE_145, BOOST_PP_NODE_147)
#define BOOST_PP_NODE_145(p) BOOST_PP_IIF(p(145), 145, 146)
#define BOOST_PP_NODE_147(p) BOOST_PP_IIF(p(147), 147, 148)
#define BOOST_PP_NODE_150(p) BOOST_PP_IIF(p(150), BOOST_PP_NODE_149, BOOST_PP_NODE_151)
#define BOOST_PP_NODE_149(p) BOOST_PP_IIF(p(149), 149, 150)
#define BOOST_PP_NODE_151(p) BOOST_PP_IIF(p(151), 151, 152)
#define BOOST_PP_NODE_156(p) BOOST_PP_IIF(p(156), BOOST_PP_NODE_154, BOOST_PP_NODE_158)
#define BOOST_PP_NODE_154(p) BOOST_PP_IIF(p(154), BOOST_PP_NODE_153, BOOST_PP_NODE_155)
#define BOOST_PP_NODE_153(p) BOOST_PP_IIF(p(153), 153, 154)
#define BOOST_PP_NODE_155(p) BOOST_PP_IIF(p(155), 155, 156)
#define BOOST_PP_NODE_158(p) BOOST_PP_IIF(p(158), BOOST_PP_NODE_157, BOOST_PP_NODE_159)
#define BOOST_PP_NODE_157(p) BOOST_PP_IIF(p(157), 157, 158)
#define BOOST_PP_NODE_159(p) BOOST_PP_IIF(p(159), 159, 160)
#define BOOST_PP_NODE_176(p) BOOST_PP_IIF(p(176), BOOST_PP_NODE_168, BOOST_PP_NODE_184)
#define BOOST_PP_NODE_168(p) BOOST_PP_IIF(p(168), BOOST_PP_NODE_164, BOOST_PP_NODE_172)
#define BOOST_PP_NODE_164(p) BOOST_PP_IIF(p(164), BOOST_PP_NODE_162, BOOST_PP_NODE_166)
#define BOOST_PP_NODE_162(p) BOOST_PP_IIF(p(162), BOOST_PP_NODE_161, BOOST_PP_NODE_163)
#define BOOST_PP_NODE_161(p) BOOST_PP_IIF(p(161), 161, 162)
#define BOOST_PP_NODE_163(p) BOOST_PP_IIF(p(163), 163, 164)
#define BOOST_PP_NODE_166(p) BOOST_PP_IIF(p(166), BOOST_PP_NODE_165, BOOST_PP_NODE_167)
#define BOOST_PP_NODE_165(p) BOOST_PP_IIF(p(165), 165, 166)
#define BOOST_PP_NODE_167(p) BOOST_PP_IIF(p(167), 167, 168)
#define BOOST_PP_NODE_172(p) BOOST_PP_IIF(p(172), BOOST_PP_NODE_170, BOOST_PP_NODE_174)
#define BOOST_PP_NODE_170(p) BOOST_PP_IIF(p(170), BOOST_PP_NODE_169, BOOST_PP_NODE_171)
#define BOOST_PP_NODE_169(p) BOOST_PP_IIF(p(169), 169, 170)
#define BOOST_PP_NODE_171(p) BOOST_PP_IIF(p(171), 171, 172)
#define BOOST_PP_NODE_174(p) BOOST_PP_IIF(p(174), BOOST_PP_NODE_173, BOOST_PP_NODE_175)
#define BOOST_PP_NODE_173(p) BOOST_PP_IIF(p(173), 173, 174)
#define BOOST_PP_NODE_175(p) BOOST_PP_IIF(p(175), 175, 176)
#define BOOST_PP_NODE_184(p) BOOST_PP_IIF(p(184), BOOST_PP_NODE_180, BOOST_PP_NODE_188)
#define BOOST_PP_NODE_180(p) BOOST_PP_IIF(p(180), BOOST_PP_NODE_178, BOOST_PP_NODE_182)
#define BOOST_PP_NODE_178(p) BOOST_PP_IIF(p(178), BOOST_PP_NODE_177, BOOST_PP_NODE_179)
#define BOOST_PP_NODE_177(p) BOOST_PP_IIF(p(177), 177, 178)
#define BOOST_PP_NODE_179(p) BOOST_PP_IIF(p(179), 179, 180)
#define BOOST_PP_NODE_182(p) BOOST_PP_IIF(p(182), BOOST_PP_NODE_181, BOOST_PP_NODE_183)
#define BOOST_PP_NODE_181(p) BOOST_PP_IIF(p(181), 181, 182)
#define BOOST_PP_NODE_183(p) BOOST_PP_IIF(p(183), 183, 184)
#define BOOST_PP_NODE_188(p) BOOST_PP_IIF(p(188), BOOST_PP_NODE_186, BOOST_PP_NODE_190)
#define BOOST_PP_NODE_186(p) BOOST_PP_IIF(p(186), BOOST_PP_NODE_185, BOOST_PP_NODE_187)
#define BOOST_PP_NODE_185(p) BOOST_PP_IIF(p(185), 185, 186)
#define BOOST_PP_NODE_187(p) BOOST_PP_IIF(p(187), 187, 188)
#define BOOST_PP_NODE_190(p) BOOST_PP_IIF(p(190), BOOST_PP_NODE_189, BOOST_PP_NODE_191)
#define BOOST_PP_NODE_189(p) BOOST_PP_IIF(p(189), 189, 190)
#define BOOST_PP_NODE_191(p) BOOST_PP_IIF(p(191), 191, 192)
#define BOOST_PP_NODE_224(p) BOOST_PP_IIF(p(224), BOOST_PP_NODE_208, BOOST_PP_NODE_240)
#define BOOST_PP_NODE_208(p) BOOST_PP_IIF(p(208), BOOST_PP_NODE_200, BOOST_PP_NODE_216)
#define BOOST_PP_NODE_200(p) BOOST_PP_IIF(p(200), BOOST_PP_NODE_196, BOOST_PP_NODE_204)
#define BOOST_PP_NODE_196(p) BOOST_PP_IIF(p(196), BOOST_PP_NODE_194, BOOST_PP_NODE_198)
#define BOOST_PP_NODE_194(p) BOOST_PP_IIF(p(194), BOOST_PP_NODE_193, BOOST_PP_NODE_195)
#define BOOST_PP_NODE_193(p) BOOST_PP_IIF(p(193), 193, 194)
#define BOOST_PP_NODE_195(p) BOOST_PP_IIF(p(195), 195, 196)
#define BOOST_PP_NODE_198(p) BOOST_PP_IIF(p(198), BOOST_PP_NODE_197, BOOST_PP_NODE_199)
#define BOOST_PP_NODE_197(p) BOOST_PP_IIF(p(197), 197, 198)
#define BOOST_PP_NODE_199(p) BOOST_PP_IIF(p(199), 199, 200)
#define BOOST_PP_NODE_204(p) BOOST_PP_IIF(p(204), BOOST_PP_NODE_202, BOOST_PP_NODE_206)
#define BOOST_PP_NODE_202(p) BOOST_PP_IIF(p(202), BOOST_PP_NODE_201, BOOST_PP_NODE_203)
#define BOOST_PP_NODE_201(p) BOOST_PP_IIF(p(201), 201, 202)
#define BOOST_PP_NODE_203(p) BOOST_PP_IIF(p(203), 203, 204)
#define BOOST_PP_NODE_206(p) BOOST_PP_IIF(p(206), BOOST_PP_NODE_205, BOOST_PP_NODE_207)
#define BOOST_PP_NODE_205(p) BOOST_PP_IIF(p(205), 205, 206)
#define BOOST_PP_NODE_207(p) BOOST_PP_IIF(p(207), 207, 208)
#define BOOST_PP_NODE_216(p) BOOST_PP_IIF(p(216), BOOST_PP_NODE_212, BOOST_PP_NODE_220)
#define BOOST_PP_NODE_212(p) BOOST_PP_IIF(p(212), BOOST_PP_NODE_210, BOOST_PP_NODE_214)
#define BOOST_PP_NODE_210(p) BOOST_PP_IIF(p(210), BOOST_PP_NODE_209, BOOST_PP_NODE_211)
#define BOOST_PP_NODE_209(p) BOOST_PP_IIF(p(209), 209, 210)
#define BOOST_PP_NODE_211(p) BOOST_PP_IIF(p(211), 211, 212)
#define BOOST_PP_NODE_214(p) BOOST_PP_IIF(p(214), BOOST_PP_NODE_213, BOOST_PP_NODE_215)
#define BOOST_PP_NODE_213(p) BOOST_PP_IIF(p(213), 213, 214)
#define BOOST_PP_NODE_215(p) BOOST_PP_IIF(p(215), 215, 216)
#define BOOST_PP_NODE_220(p) BOOST_PP_IIF(p(220), BOOST_PP_NODE_218, BOOST_PP_NODE_222)
#define BOOST_PP_NODE_218(p) BOOST_PP_IIF(p(218), BOOST_PP_NODE_217, BOOST_PP_NODE_219)
#define BOOST_PP_NODE_217(p) BOOST_PP_IIF(p(217), 217, 218)
#define BOOST_PP_NODE_219(p) BOOST_PP_IIF(p(219), 219, 220)
#define BOOST_PP_NODE_222(p) BOOST_PP_IIF(p(222), BOOST_PP_NODE_221, BOOST_PP_NODE_223)
#define BOOST_PP_NODE_221(p) BOOST_PP_IIF(p(221), 221, 222)
#define BOOST_PP_NODE_223(p) BOOST_PP_IIF(p(223), 223, 224)
#define BOOST_PP_NODE_240(p) BOOST_PP_IIF(p(240), BOOST_PP_NODE_232, BOOST_PP_NODE_248)
#define BOOST_PP_NODE_232(p) BOOST_PP_IIF(p(232), BOOST_PP_NODE_228, BOOST_PP_NODE_236)
#define BOOST_PP_NODE_228(p) BOOST_PP_IIF(p(228), BOOST_PP_NODE_226, BOOST_PP_NODE_230)
#define BOOST_PP_NODE_226(p) BOOST_PP_IIF(p(226), BOOST_PP_NODE_225, BOOST_PP_NODE_227)
#define BOOST_PP_NODE_225(p) BOOST_PP_IIF(p(225), 225, 226)
#define BOOST_PP_NODE_227(p) BOOST_PP_IIF(p(227), 227, 228)
#define BOOST_PP_NODE_230(p) BOOST_PP_IIF(p(230), BOOST_PP_NODE_229, BOOST_PP_NODE_231)
#define BOOST_PP_NODE_229(p) BOOST_PP_IIF(p(229), 229, 230)
#define BOOST_PP_NODE_231(p) BOOST_PP_IIF(p(231), 231, 232)
#define BOOST_PP_NODE_236(p) BOOST_PP_IIF(p(236), BOOST_PP_NODE_234, BOOST_PP_NODE_238)
#define BOOST_PP_NODE_234(p) BOOST_PP_IIF(p(234), BOOST_PP_NODE_233, BOOST_PP_NODE_235)
#define BOOST_PP_NODE_233(p) BOOST_PP_IIF(p(233), 233, 234)
#define BOOST_PP_NODE_235(p) BOOST_PP_IIF(p(235), 235, 236)
#define BOOST_PP_NODE_238(p) BOOST_PP_IIF(p(238), BOOST_PP_NODE_237, BOOST_PP_NODE_239)
#define BOOST_PP_NODE_237(p) BOOST_PP_IIF(p(237), 237, 238)
#define BOOST_PP_NODE_239(p) BOOST_PP_IIF(p(239), 239, 240)
#define BOOST_PP_NODE_248(p) BOOST_PP_IIF(p(248), BOOST_PP_NODE_244, BOOST_PP_NODE_252)
#define BOOST_PP_NODE_244(p) BOOST_PP_IIF(p(244), BOOST_PP_NODE_242, BOOST_PP_NODE_246)
#define BOOST_PP_NODE_242(p) BOOST_PP_IIF(p(242), BOOST_PP_NODE_241, BOOST_PP_NODE_243)
#define BOOST_PP_NODE_241(p) BOOST_PP_IIF(p(241), 241, 242)
#define BOOST_PP_NODE_243(p) BOOST_PP_IIF(p(243), 243, 244)
#define BOOST_PP_NODE_246(p) BOOST_PP_IIF(p(246), BOOST_PP_NODE_245, BOOST_PP_NODE_247)
#define BOOST_PP_NODE_245(p) BOOST_PP_IIF(p(245), 245, 246)
#define BOOST_PP_NODE_247(p) BOOST_PP_IIF(p(247), 247, 248)
#define BOOST_PP_NODE_252(p) BOOST_PP_IIF(p(252), BOOST_PP_NODE_250, BOOST_PP_NODE_254)
#define BOOST_PP_NODE_250(p) BOOST_PP_IIF(p(250), BOOST_PP_NODE_249, BOOST_PP_NODE_251)
#define BOOST_PP_NODE_249(p) BOOST_PP_IIF(p(249), 249, 250)
#define BOOST_PP_NODE_251(p) BOOST_PP_IIF(p(251), 251, 252)
#define BOOST_PP_NODE_254(p) BOOST_PP_IIF(p(254), BOOST_PP_NODE_253, BOOST_PP_NODE_255)
#define BOOST_PP_NODE_253(p) BOOST_PP_IIF(p(253), 253, 254)
#define BOOST_PP_NODE_255(p) BOOST_PP_IIF(p(255), 255, 256)
#define BOOST_PREPROCESSOR_TUPLE_EAT_HPP
#define BOOST_PP_EAT(...)
#define BOOST_PP_TUPLE_EAT(size) BOOST_PP_EAT
#define BOOST_PP_TUPLE_EAT_1(e0)
#define BOOST_PP_TUPLE_EAT_2(e0,e1)
#define BOOST_PP_TUPLE_EAT_3(e0,e1,e2)
#define BOOST_PP_TUPLE_EAT_4(e0,e1,e2,e3)
#define BOOST_PP_TUPLE_EAT_5(e0,e1,e2,e3,e4)
#define BOOST_PP_TUPLE_EAT_6(e0,e1,e2,e3,e4,e5)
#define BOOST_PP_TUPLE_EAT_7(e0,e1,e2,e3,e4,e5,e6)
#define BOOST_PP_TUPLE_EAT_8(e0,e1,e2,e3,e4,e5,e6,e7)
#define BOOST_PP_TUPLE_EAT_9(e0,e1,e2,e3,e4,e5,e6,e7,e8)
#define BOOST_PP_TUPLE_EAT_10(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9)
#define BOOST_PP_TUPLE_EAT_11(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10)
#define BOOST_PP_TUPLE_EAT_12(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11)
#define BOOST_PP_TUPLE_EAT_13(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12)
#define BOOST_PP_TUPLE_EAT_14(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13)
#define BOOST_PP_TUPLE_EAT_15(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14)
#define BOOST_PP_TUPLE_EAT_16(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15)
#define BOOST_PP_TUPLE_EAT_17(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16)
#define BOOST_PP_TUPLE_EAT_18(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17)
#define BOOST_PP_TUPLE_EAT_19(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18)
#define BOOST_PP_TUPLE_EAT_20(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19)
#define BOOST_PP_TUPLE_EAT_21(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20)
#define BOOST_PP_TUPLE_EAT_22(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21)
#define BOOST_PP_TUPLE_EAT_23(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22)
#define BOOST_PP_TUPLE_EAT_24(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23)
#define BOOST_PP_TUPLE_EAT_25(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24)
#define BOOST_PP_TUPLE_EAT_26(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25)
#define BOOST_PP_TUPLE_EAT_27(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26)
#define BOOST_PP_TUPLE_EAT_28(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27)
#define BOOST_PP_TUPLE_EAT_29(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28)
#define BOOST_PP_TUPLE_EAT_30(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29)
#define BOOST_PP_TUPLE_EAT_31(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30)
#define BOOST_PP_TUPLE_EAT_32(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31)
#define BOOST_PP_TUPLE_EAT_33(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32)
#define BOOST_PP_TUPLE_EAT_34(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33)
#define BOOST_PP_TUPLE_EAT_35(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34)
#define BOOST_PP_TUPLE_EAT_36(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35)
#define BOOST_PP_TUPLE_EAT_37(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36)
#define BOOST_PP_TUPLE_EAT_38(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37)
#define BOOST_PP_TUPLE_EAT_39(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38)
#define BOOST_PP_TUPLE_EAT_40(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39)
#define BOOST_PP_TUPLE_EAT_41(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40)
#define BOOST_PP_TUPLE_EAT_42(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41)
#define BOOST_PP_TUPLE_EAT_43(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42)
#define BOOST_PP_TUPLE_EAT_44(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43)
#define BOOST_PP_TUPLE_EAT_45(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44)
#define BOOST_PP_TUPLE_EAT_46(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45)
#define BOOST_PP_TUPLE_EAT_47(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46)
#define BOOST_PP_TUPLE_EAT_48(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47)
#define BOOST_PP_TUPLE_EAT_49(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48)
#define BOOST_PP_TUPLE_EAT_50(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49)
#define BOOST_PP_TUPLE_EAT_51(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50)
#define BOOST_PP_TUPLE_EAT_52(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51)
#define BOOST_PP_TUPLE_EAT_53(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52)
#define BOOST_PP_TUPLE_EAT_54(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53)
#define BOOST_PP_TUPLE_EAT_55(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54)
#define BOOST_PP_TUPLE_EAT_56(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55)
#define BOOST_PP_TUPLE_EAT_57(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56)
#define BOOST_PP_TUPLE_EAT_58(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57)
#define BOOST_PP_TUPLE_EAT_59(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58)
#define BOOST_PP_TUPLE_EAT_60(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59)
#define BOOST_PP_TUPLE_EAT_61(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60)
#define BOOST_PP_TUPLE_EAT_62(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61)
#define BOOST_PP_TUPLE_EAT_63(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62)
#define BOOST_PP_TUPLE_EAT_64(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62,e63)
#define BOOST_PP_REPEAT BOOST_PP_CAT(BOOST_PP_REPEAT_, BOOST_PP_AUTO_REC(BOOST_PP_REPEAT_P, 4))
#define BOOST_PP_REPEAT_P(n) BOOST_PP_CAT(BOOST_PP_REPEAT_CHECK_, BOOST_PP_REPEAT_ ## n(1, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3, BOOST_PP_NIL))
#define BOOST_PP_REPEAT_CHECK_BOOST_PP_NIL 1
#define BOOST_PP_REPEAT_CHECK_BOOST_PP_REPEAT_1(c,m,d) 0
#define BOOST_PP_REPEAT_CHECK_BOOST_PP_REPEAT_2(c,m,d) 0
#define BOOST_PP_REPEAT_CHECK_BOOST_PP_REPEAT_3(c,m,d) 0
#define BOOST_PP_REPEAT_1(c,m,d) BOOST_PP_REPEAT_1_I(c, m, d)
#define BOOST_PP_REPEAT_2(c,m,d) BOOST_PP_REPEAT_2_I(c, m, d)
#define BOOST_PP_REPEAT_3(c,m,d) BOOST_PP_REPEAT_3_I(c, m, d)
#define BOOST_PP_REPEAT_4(c,m,d) BOOST_PP_ERROR(0x0003)
#define BOOST_PP_REPEAT_1_I(c,m,d) BOOST_PP_REPEAT_1_ ## c(m, d)
#define BOOST_PP_REPEAT_2_I(c,m,d) BOOST_PP_REPEAT_2_ ## c(m, d)
#define BOOST_PP_REPEAT_3_I(c,m,d) BOOST_PP_REPEAT_3_ ## c(m, d)
#define BOOST_PP_REPEAT_1ST BOOST_PP_REPEAT_1
#define BOOST_PP_REPEAT_2ND BOOST_PP_REPEAT_2
#define BOOST_PP_REPEAT_3RD BOOST_PP_REPEAT_3
#define BOOST_PP_REPEAT_1_0(m,d)
#define BOOST_PP_REPEAT_1_1(m,d) m(2, 0, d)
#define BOOST_PP_REPEAT_1_2(m,d) BOOST_PP_REPEAT_1_1(m, d) m(2, 1, d)
#define BOOST_PP_REPEAT_1_3(m,d) BOOST_PP_REPEAT_1_2(m, d) m(2, 2, d)
#define BOOST_PP_REPEAT_1_4(m,d) BOOST_PP_REPEAT_1_3(m, d) m(2, 3, d)
#define BOOST_PP_REPEAT_1_5(m,d) BOOST_PP_REPEAT_1_4(m, d) m(2, 4, d)
#define BOOST_PP_REPEAT_1_6(m,d) BOOST_PP_REPEAT_1_5(m, d) m(2, 5, d)
#define BOOST_PP_REPEAT_1_7(m,d) BOOST_PP_REPEAT_1_6(m, d) m(2, 6, d)
#define BOOST_PP_REPEAT_1_8(m,d) BOOST_PP_REPEAT_1_7(m, d) m(2, 7, d)
#define BOOST_PP_REPEAT_1_9(m,d) BOOST_PP_REPEAT_1_8(m, d) m(2, 8, d)
#define BOOST_PP_REPEAT_1_10(m,d) BOOST_PP_REPEAT_1_9(m, d) m(2, 9, d)
#define BOOST_PP_REPEAT_1_11(m,d) BOOST_PP_REPEAT_1_10(m, d) m(2, 10, d)
#define BOOST_PP_REPEAT_1_12(m,d) BOOST_PP_REPEAT_1_11(m, d) m(2, 11, d)
#define BOOST_PP_REPEAT_1_13(m,d) BOOST_PP_REPEAT_1_12(m, d) m(2, 12, d)
#define BOOST_PP_REPEAT_1_14(m,d) BOOST_PP_REPEAT_1_13(m, d) m(2, 13, d)
#define BOOST_PP_REPEAT_1_15(m,d) BOOST_PP_REPEAT_1_14(m, d) m(2, 14, d)
#define BOOST_PP_REPEAT_1_16(m,d) BOOST_PP_REPEAT_1_15(m, d) m(2, 15, d)
#define BOOST_PP_REPEAT_1_17(m,d) BOOST_PP_REPEAT_1_16(m, d) m(2, 16, d)
#define BOOST_PP_REPEAT_1_18(m,d) BOOST_PP_REPEAT_1_17(m, d) m(2, 17, d)
#define BOOST_PP_REPEAT_1_19(m,d) BOOST_PP_REPEAT_1_18(m, d) m(2, 18, d)
#define BOOST_PP_REPEAT_1_20(m,d) BOOST_PP_REPEAT_1_19(m, d) m(2, 19, d)
#define BOOST_PP_REPEAT_1_21(m,d) BOOST_PP_REPEAT_1_20(m, d) m(2, 20, d)
#define BOOST_PP_REPEAT_1_22(m,d) BOOST_PP_REPEAT_1_21(m, d) m(2, 21, d)
#define BOOST_PP_REPEAT_1_23(m,d) BOOST_PP_REPEAT_1_22(m, d) m(2, 22, d)
#define BOOST_PP_REPEAT_1_24(m,d) BOOST_PP_REPEAT_1_23(m, d) m(2, 23, d)
#define BOOST_PP_REPEAT_1_25(m,d) BOOST_PP_REPEAT_1_24(m, d) m(2, 24, d)
#define BOOST_PP_REPEAT_1_26(m,d) BOOST_PP_REPEAT_1_25(m, d) m(2, 25, d)
#define BOOST_PP_REPEAT_1_27(m,d) BOOST_PP_REPEAT_1_26(m, d) m(2, 26, d)
#define BOOST_PP_REPEAT_1_28(m,d) BOOST_PP_REPEAT_1_27(m, d) m(2, 27, d)
#define BOOST_PP_REPEAT_1_29(m,d) BOOST_PP_REPEAT_1_28(m, d) m(2, 28, d)
#define BOOST_PP_REPEAT_1_30(m,d) BOOST_PP_REPEAT_1_29(m, d) m(2, 29, d)
#define BOOST_PP_REPEAT_1_31(m,d) BOOST_PP_REPEAT_1_30(m, d) m(2, 30, d)
#define BOOST_PP_REPEAT_1_32(m,d) BOOST_PP_REPEAT_1_31(m, d) m(2, 31, d)
#define BOOST_PP_REPEAT_1_33(m,d) BOOST_PP_REPEAT_1_32(m, d) m(2, 32, d)
#define BOOST_PP_REPEAT_1_34(m,d) BOOST_PP_REPEAT_1_33(m, d) m(2, 33, d)
#define BOOST_PP_REPEAT_1_35(m,d) BOOST_PP_REPEAT_1_34(m, d) m(2, 34, d)
#define BOOST_PP_REPEAT_1_36(m,d) BOOST_PP_REPEAT_1_35(m, d) m(2, 35, d)
#define BOOST_PP_REPEAT_1_37(m,d) BOOST_PP_REPEAT_1_36(m, d) m(2, 36, d)
#define BOOST_PP_REPEAT_1_38(m,d) BOOST_PP_REPEAT_1_37(m, d) m(2, 37, d)
#define BOOST_PP_REPEAT_1_39(m,d) BOOST_PP_REPEAT_1_38(m, d) m(2, 38, d)
#define BOOST_PP_REPEAT_1_40(m,d) BOOST_PP_REPEAT_1_39(m, d) m(2, 39, d)
#define BOOST_PP_REPEAT_1_41(m,d) BOOST_PP_REPEAT_1_40(m, d) m(2, 40, d)
#define BOOST_PP_REPEAT_1_42(m,d) BOOST_PP_REPEAT_1_41(m, d) m(2, 41, d)
#define BOOST_PP_REPEAT_1_43(m,d) BOOST_PP_REPEAT_1_42(m, d) m(2, 42, d)
#define BOOST_PP_REPEAT_1_44(m,d) BOOST_PP_REPEAT_1_43(m, d) m(2, 43, d)
#define BOOST_PP_REPEAT_1_45(m,d) BOOST_PP_REPEAT_1_44(m, d) m(2, 44, d)
#define BOOST_PP_REPEAT_1_46(m,d) BOOST_PP_REPEAT_1_45(m, d) m(2, 45, d)
#define BOOST_PP_REPEAT_1_47(m,d) BOOST_PP_REPEAT_1_46(m, d) m(2, 46, d)
#define BOOST_PP_REPEAT_1_48(m,d) BOOST_PP_REPEAT_1_47(m, d) m(2, 47, d)
#define BOOST_PP_REPEAT_1_49(m,d) BOOST_PP_REPEAT_1_48(m, d) m(2, 48, d)
#define BOOST_PP_REPEAT_1_50(m,d) BOOST_PP_REPEAT_1_49(m, d) m(2, 49, d)
#define BOOST_PP_REPEAT_1_51(m,d) BOOST_PP_REPEAT_1_50(m, d) m(2, 50, d)
#define BOOST_PP_REPEAT_1_52(m,d) BOOST_PP_REPEAT_1_51(m, d) m(2, 51, d)
#define BOOST_PP_REPEAT_1_53(m,d) BOOST_PP_REPEAT_1_52(m, d) m(2, 52, d)
#define BOOST_PP_REPEAT_1_54(m,d) BOOST_PP_REPEAT_1_53(m, d) m(2, 53, d)
#define BOOST_PP_REPEAT_1_55(m,d) BOOST_PP_REPEAT_1_54(m, d) m(2, 54, d)
#define BOOST_PP_REPEAT_1_56(m,d) BOOST_PP_REPEAT_1_55(m, d) m(2, 55, d)
#define BOOST_PP_REPEAT_1_57(m,d) BOOST_PP_REPEAT_1_56(m, d) m(2, 56, d)
#define BOOST_PP_REPEAT_1_58(m,d) BOOST_PP_REPEAT_1_57(m, d) m(2, 57, d)
#define BOOST_PP_REPEAT_1_59(m,d) BOOST_PP_REPEAT_1_58(m, d) m(2, 58, d)
#define BOOST_PP_REPEAT_1_60(m,d) BOOST_PP_REPEAT_1_59(m, d) m(2, 59, d)
#define BOOST_PP_REPEAT_1_61(m,d) BOOST_PP_REPEAT_1_60(m, d) m(2, 60, d)
#define BOOST_PP_REPEAT_1_62(m,d) BOOST_PP_REPEAT_1_61(m, d) m(2, 61, d)
#define BOOST_PP_REPEAT_1_63(m,d) BOOST_PP_REPEAT_1_62(m, d) m(2, 62, d)
#define BOOST_PP_REPEAT_1_64(m,d) BOOST_PP_REPEAT_1_63(m, d) m(2, 63, d)
#define BOOST_PP_REPEAT_1_65(m,d) BOOST_PP_REPEAT_1_64(m, d) m(2, 64, d)
#define BOOST_PP_REPEAT_1_66(m,d) BOOST_PP_REPEAT_1_65(m, d) m(2, 65, d)
#define BOOST_PP_REPEAT_1_67(m,d) BOOST_PP_REPEAT_1_66(m, d) m(2, 66, d)
#define BOOST_PP_REPEAT_1_68(m,d) BOOST_PP_REPEAT_1_67(m, d) m(2, 67, d)
#define BOOST_PP_REPEAT_1_69(m,d) BOOST_PP_REPEAT_1_68(m, d) m(2, 68, d)
#define BOOST_PP_REPEAT_1_70(m,d) BOOST_PP_REPEAT_1_69(m, d) m(2, 69, d)
#define BOOST_PP_REPEAT_1_71(m,d) BOOST_PP_REPEAT_1_70(m, d) m(2, 70, d)
#define BOOST_PP_REPEAT_1_72(m,d) BOOST_PP_REPEAT_1_71(m, d) m(2, 71, d)
#define BOOST_PP_REPEAT_1_73(m,d) BOOST_PP_REPEAT_1_72(m, d) m(2, 72, d)
#define BOOST_PP_REPEAT_1_74(m,d) BOOST_PP_REPEAT_1_73(m, d) m(2, 73, d)
#define BOOST_PP_REPEAT_1_75(m,d) BOOST_PP_REPEAT_1_74(m, d) m(2, 74, d)
#define BOOST_PP_REPEAT_1_76(m,d) BOOST_PP_REPEAT_1_75(m, d) m(2, 75, d)
#define BOOST_PP_REPEAT_1_77(m,d) BOOST_PP_REPEAT_1_76(m, d) m(2, 76, d)
#define BOOST_PP_REPEAT_1_78(m,d) BOOST_PP_REPEAT_1_77(m, d) m(2, 77, d)
#define BOOST_PP_REPEAT_1_79(m,d) BOOST_PP_REPEAT_1_78(m, d) m(2, 78, d)
#define BOOST_PP_REPEAT_1_80(m,d) BOOST_PP_REPEAT_1_79(m, d) m(2, 79, d)
#define BOOST_PP_REPEAT_1_81(m,d) BOOST_PP_REPEAT_1_80(m, d) m(2, 80, d)
#define BOOST_PP_REPEAT_1_82(m,d) BOOST_PP_REPEAT_1_81(m, d) m(2, 81, d)
#define BOOST_PP_REPEAT_1_83(m,d) BOOST_PP_REPEAT_1_82(m, d) m(2, 82, d)
#define BOOST_PP_REPEAT_1_84(m,d) BOOST_PP_REPEAT_1_83(m, d) m(2, 83, d)
#define BOOST_PP_REPEAT_1_85(m,d) BOOST_PP_REPEAT_1_84(m, d) m(2, 84, d)
#define BOOST_PP_REPEAT_1_86(m,d) BOOST_PP_REPEAT_1_85(m, d) m(2, 85, d)
#define BOOST_PP_REPEAT_1_87(m,d) BOOST_PP_REPEAT_1_86(m, d) m(2, 86, d)
#define BOOST_PP_REPEAT_1_88(m,d) BOOST_PP_REPEAT_1_87(m, d) m(2, 87, d)
#define BOOST_PP_REPEAT_1_89(m,d) BOOST_PP_REPEAT_1_88(m, d) m(2, 88, d)
#define BOOST_PP_REPEAT_1_90(m,d) BOOST_PP_REPEAT_1_89(m, d) m(2, 89, d)
#define BOOST_PP_REPEAT_1_91(m,d) BOOST_PP_REPEAT_1_90(m, d) m(2, 90, d)
#define BOOST_PP_REPEAT_1_92(m,d) BOOST_PP_REPEAT_1_91(m, d) m(2, 91, d)
#define BOOST_PP_REPEAT_1_93(m,d) BOOST_PP_REPEAT_1_92(m, d) m(2, 92, d)
#define BOOST_PP_REPEAT_1_94(m,d) BOOST_PP_REPEAT_1_93(m, d) m(2, 93, d)
#define BOOST_PP_REPEAT_1_95(m,d) BOOST_PP_REPEAT_1_94(m, d) m(2, 94, d)
#define BOOST_PP_REPEAT_1_96(m,d) BOOST_PP_REPEAT_1_95(m, d) m(2, 95, d)
#define BOOST_PP_REPEAT_1_97(m,d) BOOST_PP_REPEAT_1_96(m, d) m(2, 96, d)
#define BOOST_PP_REPEAT_1_98(m,d) BOOST_PP_REPEAT_1_97(m, d) m(2, 97, d)
#define BOOST_PP_REPEAT_1_99(m,d) BOOST_PP_REPEAT_1_98(m, d) m(2, 98, d)
#define BOOST_PP_REPEAT_1_100(m,d) BOOST_PP_REPEAT_1_99(m, d) m(2, 99, d)
#define BOOST_PP_REPEAT_1_101(m,d) BOOST_PP_REPEAT_1_100(m, d) m(2, 100, d)
#define BOOST_PP_REPEAT_1_102(m,d) BOOST_PP_REPEAT_1_101(m, d) m(2, 101, d)
#define BOOST_PP_REPEAT_1_103(m,d) BOOST_PP_REPEAT_1_102(m, d) m(2, 102, d)
#define BOOST_PP_REPEAT_1_104(m,d) BOOST_PP_REPEAT_1_103(m, d) m(2, 103, d)
#define BOOST_PP_REPEAT_1_105(m,d) BOOST_PP_REPEAT_1_104(m, d) m(2, 104, d)
#define BOOST_PP_REPEAT_1_106(m,d) BOOST_PP_REPEAT_1_105(m, d) m(2, 105, d)
#define BOOST_PP_REPEAT_1_107(m,d) BOOST_PP_REPEAT_1_106(m, d) m(2, 106, d)
#define BOOST_PP_REPEAT_1_108(m,d) BOOST_PP_REPEAT_1_107(m, d) m(2, 107, d)
#define BOOST_PP_REPEAT_1_109(m,d) BOOST_PP_REPEAT_1_108(m, d) m(2, 108, d)
#define BOOST_PP_REPEAT_1_110(m,d) BOOST_PP_REPEAT_1_109(m, d) m(2, 109, d)
#define BOOST_PP_REPEAT_1_111(m,d) BOOST_PP_REPEAT_1_110(m, d) m(2, 110, d)
#define BOOST_PP_REPEAT_1_112(m,d) BOOST_PP_REPEAT_1_111(m, d) m(2, 111, d)
#define BOOST_PP_REPEAT_1_113(m,d) BOOST_PP_REPEAT_1_112(m, d) m(2, 112, d)
#define BOOST_PP_REPEAT_1_114(m,d) BOOST_PP_REPEAT_1_113(m, d) m(2, 113, d)
#define BOOST_PP_REPEAT_1_115(m,d) BOOST_PP_REPEAT_1_114(m, d) m(2, 114, d)
#define BOOST_PP_REPEAT_1_116(m,d) BOOST_PP_REPEAT_1_115(m, d) m(2, 115, d)
#define BOOST_PP_REPEAT_1_117(m,d) BOOST_PP_REPEAT_1_116(m, d) m(2, 116, d)
#define BOOST_PP_REPEAT_1_118(m,d) BOOST_PP_REPEAT_1_117(m, d) m(2, 117, d)
#define BOOST_PP_REPEAT_1_119(m,d) BOOST_PP_REPEAT_1_118(m, d) m(2, 118, d)
#define BOOST_PP_REPEAT_1_120(m,d) BOOST_PP_REPEAT_1_119(m, d) m(2, 119, d)
#define BOOST_PP_REPEAT_1_121(m,d) BOOST_PP_REPEAT_1_120(m, d) m(2, 120, d)
#define BOOST_PP_REPEAT_1_122(m,d) BOOST_PP_REPEAT_1_121(m, d) m(2, 121, d)
#define BOOST_PP_REPEAT_1_123(m,d) BOOST_PP_REPEAT_1_122(m, d) m(2, 122, d)
#define BOOST_PP_REPEAT_1_124(m,d) BOOST_PP_REPEAT_1_123(m, d) m(2, 123, d)
#define BOOST_PP_REPEAT_1_125(m,d) BOOST_PP_REPEAT_1_124(m, d) m(2, 124, d)
#define BOOST_PP_REPEAT_1_126(m,d) BOOST_PP_REPEAT_1_125(m, d) m(2, 125, d)
#define BOOST_PP_REPEAT_1_127(m,d) BOOST_PP_REPEAT_1_126(m, d) m(2, 126, d)
#define BOOST_PP_REPEAT_1_128(m,d) BOOST_PP_REPEAT_1_127(m, d) m(2, 127, d)
#define BOOST_PP_REPEAT_1_129(m,d) BOOST_PP_REPEAT_1_128(m, d) m(2, 128, d)
#define BOOST_PP_REPEAT_1_130(m,d) BOOST_PP_REPEAT_1_129(m, d) m(2, 129, d)
#define BOOST_PP_REPEAT_1_131(m,d) BOOST_PP_REPEAT_1_130(m, d) m(2, 130, d)
#define BOOST_PP_REPEAT_1_132(m,d) BOOST_PP_REPEAT_1_131(m, d) m(2, 131, d)
#define BOOST_PP_REPEAT_1_133(m,d) BOOST_PP_REPEAT_1_132(m, d) m(2, 132, d)
#define BOOST_PP_REPEAT_1_134(m,d) BOOST_PP_REPEAT_1_133(m, d) m(2, 133, d)
#define BOOST_PP_REPEAT_1_135(m,d) BOOST_PP_REPEAT_1_134(m, d) m(2, 134, d)
#define BOOST_PP_REPEAT_1_136(m,d) BOOST_PP_REPEAT_1_135(m, d) m(2, 135, d)
#define BOOST_PP_REPEAT_1_137(m,d) BOOST_PP_REPEAT_1_136(m, d) m(2, 136, d)
#define BOOST_PP_REPEAT_1_138(m,d) BOOST_PP_REPEAT_1_137(m, d) m(2, 137, d)
#define BOOST_PP_REPEAT_1_139(m,d) BOOST_PP_REPEAT_1_138(m, d) m(2, 138, d)
#define BOOST_PP_REPEAT_1_140(m,d) BOOST_PP_REPEAT_1_139(m, d) m(2, 139, d)
#define BOOST_PP_REPEAT_1_141(m,d) BOOST_PP_REPEAT_1_140(m, d) m(2, 140, d)
#define BOOST_PP_REPEAT_1_142(m,d) BOOST_PP_REPEAT_1_141(m, d) m(2, 141, d)
#define BOOST_PP_REPEAT_1_143(m,d) BOOST_PP_REPEAT_1_142(m, d) m(2, 142, d)
#define BOOST_PP_REPEAT_1_144(m,d) BOOST_PP_REPEAT_1_143(m, d) m(2, 143, d)
#define BOOST_PP_REPEAT_1_145(m,d) BOOST_PP_REPEAT_1_144(m, d) m(2, 144, d)
#define BOOST_PP_REPEAT_1_146(m,d) BOOST_PP_REPEAT_1_145(m, d) m(2, 145, d)
#define BOOST_PP_REPEAT_1_147(m,d) BOOST_PP_REPEAT_1_146(m, d) m(2, 146, d)
#define BOOST_PP_REPEAT_1_148(m,d) BOOST_PP_REPEAT_1_147(m, d) m(2, 147, d)
#define BOOST_PP_REPEAT_1_149(m,d) BOOST_PP_REPEAT_1_148(m, d) m(2, 148, d)
#define BOOST_PP_REPEAT_1_150(m,d) BOOST_PP_REPEAT_1_149(m, d) m(2, 149, d)
#define BOOST_PP_REPEAT_1_151(m,d) BOOST_PP_REPEAT_1_150(m, d) m(2, 150, d)
#define BOOST_PP_REPEAT_1_152(m,d) BOOST_PP_REPEAT_1_151(m, d) m(2, 151, d)
#define BOOST_PP_REPEAT_1_153(m,d) BOOST_PP_REPEAT_1_152(m, d) m(2, 152, d)
#define BOOST_PP_REPEAT_1_154(m,d) BOOST_PP_REPEAT_1_153(m, d) m(2, 153, d)
#define BOOST_PP_REPEAT_1_155(m,d) BOOST_PP_REPEAT_1_154(m, d) m(2, 154, d)
#define BOOST_PP_REPEAT_1_156(m,d) BOOST_PP_REPEAT_1_155(m, d) m(2, 155, d)
#define BOOST_PP_REPEAT_1_157(m,d) BOOST_PP_REPEAT_1_156(m, d) m(2, 156, d)
#define BOOST_PP_REPEAT_1_158(m,d) BOOST_PP_REPEAT_1_157(m, d) m(2, 157, d)
#define BOOST_PP_REPEAT_1_159(m,d) BOOST_PP_REPEAT_1_158(m, d) m(2, 158, d)
#define BOOST_PP_REPEAT_1_160(m,d) BOOST_PP_REPEAT_1_159(m, d) m(2, 159, d)
#define BOOST_PP_REPEAT_1_161(m,d) BOOST_PP_REPEAT_1_160(m, d) m(2, 160, d)
#define BOOST_PP_REPEAT_1_162(m,d) BOOST_PP_REPEAT_1_161(m, d) m(2, 161, d)
#define BOOST_PP_REPEAT_1_163(m,d) BOOST_PP_REPEAT_1_162(m, d) m(2, 162, d)
#define BOOST_PP_REPEAT_1_164(m,d) BOOST_PP_REPEAT_1_163(m, d) m(2, 163, d)
#define BOOST_PP_REPEAT_1_165(m,d) BOOST_PP_REPEAT_1_164(m, d) m(2, 164, d)
#define BOOST_PP_REPEAT_1_166(m,d) BOOST_PP_REPEAT_1_165(m, d) m(2, 165, d)
#define BOOST_PP_REPEAT_1_167(m,d) BOOST_PP_REPEAT_1_166(m, d) m(2, 166, d)
#define BOOST_PP_REPEAT_1_168(m,d) BOOST_PP_REPEAT_1_167(m, d) m(2, 167, d)
#define BOOST_PP_REPEAT_1_169(m,d) BOOST_PP_REPEAT_1_168(m, d) m(2, 168, d)
#define BOOST_PP_REPEAT_1_170(m,d) BOOST_PP_REPEAT_1_169(m, d) m(2, 169, d)
#define BOOST_PP_REPEAT_1_171(m,d) BOOST_PP_REPEAT_1_170(m, d) m(2, 170, d)
#define BOOST_PP_REPEAT_1_172(m,d) BOOST_PP_REPEAT_1_171(m, d) m(2, 171, d)
#define BOOST_PP_REPEAT_1_173(m,d) BOOST_PP_REPEAT_1_172(m, d) m(2, 172, d)
#define BOOST_PP_REPEAT_1_174(m,d) BOOST_PP_REPEAT_1_173(m, d) m(2, 173, d)
#define BOOST_PP_REPEAT_1_175(m,d) BOOST_PP_REPEAT_1_174(m, d) m(2, 174, d)
#define BOOST_PP_REPEAT_1_176(m,d) BOOST_PP_REPEAT_1_175(m, d) m(2, 175, d)
#define BOOST_PP_REPEAT_1_177(m,d) BOOST_PP_REPEAT_1_176(m, d) m(2, 176, d)
#define BOOST_PP_REPEAT_1_178(m,d) BOOST_PP_REPEAT_1_177(m, d) m(2, 177, d)
#define BOOST_PP_REPEAT_1_179(m,d) BOOST_PP_REPEAT_1_178(m, d) m(2, 178, d)
#define BOOST_PP_REPEAT_1_180(m,d) BOOST_PP_REPEAT_1_179(m, d) m(2, 179, d)
#define BOOST_PP_REPEAT_1_181(m,d) BOOST_PP_REPEAT_1_180(m, d) m(2, 180, d)
#define BOOST_PP_REPEAT_1_182(m,d) BOOST_PP_REPEAT_1_181(m, d) m(2, 181, d)
#define BOOST_PP_REPEAT_1_183(m,d) BOOST_PP_REPEAT_1_182(m, d) m(2, 182, d)
#define BOOST_PP_REPEAT_1_184(m,d) BOOST_PP_REPEAT_1_183(m, d) m(2, 183, d)
#define BOOST_PP_REPEAT_1_185(m,d) BOOST_PP_REPEAT_1_184(m, d) m(2, 184, d)
#define BOOST_PP_REPEAT_1_186(m,d) BOOST_PP_REPEAT_1_185(m, d) m(2, 185, d)
#define BOOST_PP_REPEAT_1_187(m,d) BOOST_PP_REPEAT_1_186(m, d) m(2, 186, d)
#define BOOST_PP_REPEAT_1_188(m,d) BOOST_PP_REPEAT_1_187(m, d) m(2, 187, d)
#define BOOST_PP_REPEAT_1_189(m,d) BOOST_PP_REPEAT_1_188(m, d) m(2, 188, d)
#define BOOST_PP_REPEAT_1_190(m,d) BOOST_PP_REPEAT_1_189(m, d) m(2, 189, d)
#define BOOST_PP_REPEAT_1_191(m,d) BOOST_PP_REPEAT_1_190(m, d) m(2, 190, d)
#define BOOST_PP_REPEAT_1_192(m,d) BOOST_PP_REPEAT_1_191(m, d) m(2, 191, d)
#define BOOST_PP_REPEAT_1_193(m,d) BOOST_PP_REPEAT_1_192(m, d) m(2, 192, d)
#define BOOST_PP_REPEAT_1_194(m,d) BOOST_PP_REPEAT_1_193(m, d) m(2, 193, d)
#define BOOST_PP_REPEAT_1_195(m,d) BOOST_PP_REPEAT_1_194(m, d) m(2, 194, d)
#define BOOST_PP_REPEAT_1_196(m,d) BOOST_PP_REPEAT_1_195(m, d) m(2, 195, d)
#define BOOST_PP_REPEAT_1_197(m,d) BOOST_PP_REPEAT_1_196(m, d) m(2, 196, d)
#define BOOST_PP_REPEAT_1_198(m,d) BOOST_PP_REPEAT_1_197(m, d) m(2, 197, d)
#define BOOST_PP_REPEAT_1_199(m,d) BOOST_PP_REPEAT_1_198(m, d) m(2, 198, d)
#define BOOST_PP_REPEAT_1_200(m,d) BOOST_PP_REPEAT_1_199(m, d) m(2, 199, d)
#define BOOST_PP_REPEAT_1_201(m,d) BOOST_PP_REPEAT_1_200(m, d) m(2, 200, d)
#define BOOST_PP_REPEAT_1_202(m,d) BOOST_PP_REPEAT_1_201(m, d) m(2, 201, d)
#define BOOST_PP_REPEAT_1_203(m,d) BOOST_PP_REPEAT_1_202(m, d) m(2, 202, d)
#define BOOST_PP_REPEAT_1_204(m,d) BOOST_PP_REPEAT_1_203(m, d) m(2, 203, d)
#define BOOST_PP_REPEAT_1_205(m,d) BOOST_PP_REPEAT_1_204(m, d) m(2, 204, d)
#define BOOST_PP_REPEAT_1_206(m,d) BOOST_PP_REPEAT_1_205(m, d) m(2, 205, d)
#define BOOST_PP_REPEAT_1_207(m,d) BOOST_PP_REPEAT_1_206(m, d) m(2, 206, d)
#define BOOST_PP_REPEAT_1_208(m,d) BOOST_PP_REPEAT_1_207(m, d) m(2, 207, d)
#define BOOST_PP_REPEAT_1_209(m,d) BOOST_PP_REPEAT_1_208(m, d) m(2, 208, d)
#define BOOST_PP_REPEAT_1_210(m,d) BOOST_PP_REPEAT_1_209(m, d) m(2, 209, d)
#define BOOST_PP_REPEAT_1_211(m,d) BOOST_PP_REPEAT_1_210(m, d) m(2, 210, d)
#define BOOST_PP_REPEAT_1_212(m,d) BOOST_PP_REPEAT_1_211(m, d) m(2, 211, d)
#define BOOST_PP_REPEAT_1_213(m,d) BOOST_PP_REPEAT_1_212(m, d) m(2, 212, d)
#define BOOST_PP_REPEAT_1_214(m,d) BOOST_PP_REPEAT_1_213(m, d) m(2, 213, d)
#define BOOST_PP_REPEAT_1_215(m,d) BOOST_PP_REPEAT_1_214(m, d) m(2, 214, d)
#define BOOST_PP_REPEAT_1_216(m,d) BOOST_PP_REPEAT_1_215(m, d) m(2, 215, d)
#define BOOST_PP_REPEAT_1_217(m,d) BOOST_PP_REPEAT_1_216(m, d) m(2, 216, d)
#define BOOST_PP_REPEAT_1_218(m,d) BOOST_PP_REPEAT_1_217(m, d) m(2, 217, d)
#define BOOST_PP_REPEAT_1_219(m,d) BOOST_PP_REPEAT_1_218(m, d) m(2, 218, d)
#define BOOST_PP_REPEAT_1_220(m,d) BOOST_PP_REPEAT_1_219(m, d) m(2, 219, d)
#define BOOST_PP_REPEAT_1_221(m,d) BOOST_PP_REPEAT_1_220(m, d) m(2, 220, d)
#define BOOST_PP_REPEAT_1_222(m,d) BOOST_PP_REPEAT_1_221(m, d) m(2, 221, d)
#define BOOST_PP_REPEAT_1_223(m,d) BOOST_PP_REPEAT_1_222(m, d) m(2, 222, d)
#define BOOST_PP_REPEAT_1_224(m,d) BOOST_PP_REPEAT_1_223(m, d) m(2, 223, d)
#define BOOST_PP_REPEAT_1_225(m,d) BOOST_PP_REPEAT_1_224(m, d) m(2, 224, d)
#define BOOST_PP_REPEAT_1_226(m,d) BOOST_PP_REPEAT_1_225(m, d) m(2, 225, d)
#define BOOST_PP_REPEAT_1_227(m,d) BOOST_PP_REPEAT_1_226(m, d) m(2, 226, d)
#define BOOST_PP_REPEAT_1_228(m,d) BOOST_PP_REPEAT_1_227(m, d) m(2, 227, d)
#define BOOST_PP_REPEAT_1_229(m,d) BOOST_PP_REPEAT_1_228(m, d) m(2, 228, d)
#define BOOST_PP_REPEAT_1_230(m,d) BOOST_PP_REPEAT_1_229(m, d) m(2, 229, d)
#define BOOST_PP_REPEAT_1_231(m,d) BOOST_PP_REPEAT_1_230(m, d) m(2, 230, d)
#define BOOST_PP_REPEAT_1_232(m,d) BOOST_PP_REPEAT_1_231(m, d) m(2, 231, d)
#define BOOST_PP_REPEAT_1_233(m,d) BOOST_PP_REPEAT_1_232(m, d) m(2, 232, d)
#define BOOST_PP_REPEAT_1_234(m,d) BOOST_PP_REPEAT_1_233(m, d) m(2, 233, d)
#define BOOST_PP_REPEAT_1_235(m,d) BOOST_PP_REPEAT_1_234(m, d) m(2, 234, d)
#define BOOST_PP_REPEAT_1_236(m,d) BOOST_PP_REPEAT_1_235(m, d) m(2, 235, d)
#define BOOST_PP_REPEAT_1_237(m,d) BOOST_PP_REPEAT_1_236(m, d) m(2, 236, d)
#define BOOST_PP_REPEAT_1_238(m,d) BOOST_PP_REPEAT_1_237(m, d) m(2, 237, d)
#define BOOST_PP_REPEAT_1_239(m,d) BOOST_PP_REPEAT_1_238(m, d) m(2, 238, d)
#define BOOST_PP_REPEAT_1_240(m,d) BOOST_PP_REPEAT_1_239(m, d) m(2, 239, d)
#define BOOST_PP_REPEAT_1_241(m,d) BOOST_PP_REPEAT_1_240(m, d) m(2, 240, d)
#define BOOST_PP_REPEAT_1_242(m,d) BOOST_PP_REPEAT_1_241(m, d) m(2, 241, d)
#define BOOST_PP_REPEAT_1_243(m,d) BOOST_PP_REPEAT_1_242(m, d) m(2, 242, d)
#define BOOST_PP_REPEAT_1_244(m,d) BOOST_PP_REPEAT_1_243(m, d) m(2, 243, d)
#define BOOST_PP_REPEAT_1_245(m,d) BOOST_PP_REPEAT_1_244(m, d) m(2, 244, d)
#define BOOST_PP_REPEAT_1_246(m,d) BOOST_PP_REPEAT_1_245(m, d) m(2, 245, d)
#define BOOST_PP_REPEAT_1_247(m,d) BOOST_PP_REPEAT_1_246(m, d) m(2, 246, d)
#define BOOST_PP_REPEAT_1_248(m,d) BOOST_PP_REPEAT_1_247(m, d) m(2, 247, d)
#define BOOST_PP_REPEAT_1_249(m,d) BOOST_PP_REPEAT_1_248(m, d) m(2, 248, d)
#define BOOST_PP_REPEAT_1_250(m,d) BOOST_PP_REPEAT_1_249(m, d) m(2, 249, d)
#define BOOST_PP_REPEAT_1_251(m,d) BOOST_PP_REPEAT_1_250(m, d) m(2, 250, d)
#define BOOST_PP_REPEAT_1_252(m,d) BOOST_PP_REPEAT_1_251(m, d) m(2, 251, d)
#define BOOST_PP_REPEAT_1_253(m,d) BOOST_PP_REPEAT_1_252(m, d) m(2, 252, d)
#define BOOST_PP_REPEAT_1_254(m,d) BOOST_PP_REPEAT_1_253(m, d) m(2, 253, d)
#define BOOST_PP_REPEAT_1_255(m,d) BOOST_PP_REPEAT_1_254(m, d) m(2, 254, d)
#define BOOST_PP_REPEAT_1_256(m,d) BOOST_PP_REPEAT_1_255(m, d) m(2, 255, d)
#define BOOST_PP_REPEAT_2_0(m,d)
#define BOOST_PP_REPEAT_2_1(m,d) m(3, 0, d)
#define BOOST_PP_REPEAT_2_2(m,d) BOOST_PP_REPEAT_2_1(m, d) m(3, 1, d)
#define BOOST_PP_REPEAT_2_3(m,d) BOOST_PP_REPEAT_2_2(m, d) m(3, 2, d)
#define BOOST_PP_REPEAT_2_4(m,d) BOOST_PP_REPEAT_2_3(m, d) m(3, 3, d)
#define BOOST_PP_REPEAT_2_5(m,d) BOOST_PP_REPEAT_2_4(m, d) m(3, 4, d)
#define BOOST_PP_REPEAT_2_6(m,d) BOOST_PP_REPEAT_2_5(m, d) m(3, 5, d)
#define BOOST_PP_REPEAT_2_7(m,d) BOOST_PP_REPEAT_2_6(m, d) m(3, 6, d)
#define BOOST_PP_REPEAT_2_8(m,d) BOOST_PP_REPEAT_2_7(m, d) m(3, 7, d)
#define BOOST_PP_REPEAT_2_9(m,d) BOOST_PP_REPEAT_2_8(m, d) m(3, 8, d)
#define BOOST_PP_REPEAT_2_10(m,d) BOOST_PP_REPEAT_2_9(m, d) m(3, 9, d)
#define BOOST_PP_REPEAT_2_11(m,d) BOOST_PP_REPEAT_2_10(m, d) m(3, 10, d)
#define BOOST_PP_REPEAT_2_12(m,d) BOOST_PP_REPEAT_2_11(m, d) m(3, 11, d)
#define BOOST_PP_REPEAT_2_13(m,d) BOOST_PP_REPEAT_2_12(m, d) m(3, 12, d)
#define BOOST_PP_REPEAT_2_14(m,d) BOOST_PP_REPEAT_2_13(m, d) m(3, 13, d)
#define BOOST_PP_REPEAT_2_15(m,d) BOOST_PP_REPEAT_2_14(m, d) m(3, 14, d)
#define BOOST_PP_REPEAT_2_16(m,d) BOOST_PP_REPEAT_2_15(m, d) m(3, 15, d)
#define BOOST_PP_REPEAT_2_17(m,d) BOOST_PP_REPEAT_2_16(m, d) m(3, 16, d)
#define BOOST_PP_REPEAT_2_18(m,d) BOOST_PP_REPEAT_2_17(m, d) m(3, 17, d)
#define BOOST_PP_REPEAT_2_19(m,d) BOOST_PP_REPEAT_2_18(m, d) m(3, 18, d)
#define BOOST_PP_REPEAT_2_20(m,d) BOOST_PP_REPEAT_2_19(m, d) m(3, 19, d)
#define BOOST_PP_REPEAT_2_21(m,d) BOOST_PP_REPEAT_2_20(m, d) m(3, 20, d)
#define BOOST_PP_REPEAT_2_22(m,d) BOOST_PP_REPEAT_2_21(m, d) m(3, 21, d)
#define BOOST_PP_REPEAT_2_23(m,d) BOOST_PP_REPEAT_2_22(m, d) m(3, 22, d)
#define BOOST_PP_REPEAT_2_24(m,d) BOOST_PP_REPEAT_2_23(m, d) m(3, 23, d)
#define BOOST_PP_REPEAT_2_25(m,d) BOOST_PP_REPEAT_2_24(m, d) m(3, 24, d)
#define BOOST_PP_REPEAT_2_26(m,d) BOOST_PP_REPEAT_2_25(m, d) m(3, 25, d)
#define BOOST_PP_REPEAT_2_27(m,d) BOOST_PP_REPEAT_2_26(m, d) m(3, 26, d)
#define BOOST_PP_REPEAT_2_28(m,d) BOOST_PP_REPEAT_2_27(m, d) m(3, 27, d)
#define BOOST_PP_REPEAT_2_29(m,d) BOOST_PP_REPEAT_2_28(m, d) m(3, 28, d)
#define BOOST_PP_REPEAT_2_30(m,d) BOOST_PP_REPEAT_2_29(m, d) m(3, 29, d)
#define BOOST_PP_REPEAT_2_31(m,d) BOOST_PP_REPEAT_2_30(m, d) m(3, 30, d)
#define BOOST_PP_REPEAT_2_32(m,d) BOOST_PP_REPEAT_2_31(m, d) m(3, 31, d)
#define BOOST_PP_REPEAT_2_33(m,d) BOOST_PP_REPEAT_2_32(m, d) m(3, 32, d)
#define BOOST_PP_REPEAT_2_34(m,d) BOOST_PP_REPEAT_2_33(m, d) m(3, 33, d)
#define BOOST_PP_REPEAT_2_35(m,d) BOOST_PP_REPEAT_2_34(m, d) m(3, 34, d)
#define BOOST_PP_REPEAT_2_36(m,d) BOOST_PP_REPEAT_2_35(m, d) m(3, 35, d)
#define BOOST_PP_REPEAT_2_37(m,d) BOOST_PP_REPEAT_2_36(m, d) m(3, 36, d)
#define BOOST_PP_REPEAT_2_38(m,d) BOOST_PP_REPEAT_2_37(m, d) m(3, 37, d)
#define BOOST_PP_REPEAT_2_39(m,d) BOOST_PP_REPEAT_2_38(m, d) m(3, 38, d)
#define BOOST_PP_REPEAT_2_40(m,d) BOOST_PP_REPEAT_2_39(m, d) m(3, 39, d)
#define BOOST_PP_REPEAT_2_41(m,d) BOOST_PP_REPEAT_2_40(m, d) m(3, 40, d)
#define BOOST_PP_REPEAT_2_42(m,d) BOOST_PP_REPEAT_2_41(m, d) m(3, 41, d)
#define BOOST_PP_REPEAT_2_43(m,d) BOOST_PP_REPEAT_2_42(m, d) m(3, 42, d)
#define BOOST_PP_REPEAT_2_44(m,d) BOOST_PP_REPEAT_2_43(m, d) m(3, 43, d)
#define BOOST_PP_REPEAT_2_45(m,d) BOOST_PP_REPEAT_2_44(m, d) m(3, 44, d)
#define BOOST_PP_REPEAT_2_46(m,d) BOOST_PP_REPEAT_2_45(m, d) m(3, 45, d)
#define BOOST_PP_REPEAT_2_47(m,d) BOOST_PP_REPEAT_2_46(m, d) m(3, 46, d)
#define BOOST_PP_REPEAT_2_48(m,d) BOOST_PP_REPEAT_2_47(m, d) m(3, 47, d)
#define BOOST_PP_REPEAT_2_49(m,d) BOOST_PP_REPEAT_2_48(m, d) m(3, 48, d)
#define BOOST_PP_REPEAT_2_50(m,d) BOOST_PP_REPEAT_2_49(m, d) m(3, 49, d)
#define BOOST_PP_REPEAT_2_51(m,d) BOOST_PP_REPEAT_2_50(m, d) m(3, 50, d)
#define BOOST_PP_REPEAT_2_52(m,d) BOOST_PP_REPEAT_2_51(m, d) m(3, 51, d)
#define BOOST_PP_REPEAT_2_53(m,d) BOOST_PP_REPEAT_2_52(m, d) m(3, 52, d)
#define BOOST_PP_REPEAT_2_54(m,d) BOOST_PP_REPEAT_2_53(m, d) m(3, 53, d)
#define BOOST_PP_REPEAT_2_55(m,d) BOOST_PP_REPEAT_2_54(m, d) m(3, 54, d)
#define BOOST_PP_REPEAT_2_56(m,d) BOOST_PP_REPEAT_2_55(m, d) m(3, 55, d)
#define BOOST_PP_REPEAT_2_57(m,d) BOOST_PP_REPEAT_2_56(m, d) m(3, 56, d)
#define BOOST_PP_REPEAT_2_58(m,d) BOOST_PP_REPEAT_2_57(m, d) m(3, 57, d)
#define BOOST_PP_REPEAT_2_59(m,d) BOOST_PP_REPEAT_2_58(m, d) m(3, 58, d)
#define BOOST_PP_REPEAT_2_60(m,d) BOOST_PP_REPEAT_2_59(m, d) m(3, 59, d)
#define BOOST_PP_REPEAT_2_61(m,d) BOOST_PP_REPEAT_2_60(m, d) m(3, 60, d)
#define BOOST_PP_REPEAT_2_62(m,d) BOOST_PP_REPEAT_2_61(m, d) m(3, 61, d)
#define BOOST_PP_REPEAT_2_63(m,d) BOOST_PP_REPEAT_2_62(m, d) m(3, 62, d)
#define BOOST_PP_REPEAT_2_64(m,d) BOOST_PP_REPEAT_2_63(m, d) m(3, 63, d)
#define BOOST_PP_REPEAT_2_65(m,d) BOOST_PP_REPEAT_2_64(m, d) m(3, 64, d)
#define BOOST_PP_REPEAT_2_66(m,d) BOOST_PP_REPEAT_2_65(m, d) m(3, 65, d)
#define BOOST_PP_REPEAT_2_67(m,d) BOOST_PP_REPEAT_2_66(m, d) m(3, 66, d)
#define BOOST_PP_REPEAT_2_68(m,d) BOOST_PP_REPEAT_2_67(m, d) m(3, 67, d)
#define BOOST_PP_REPEAT_2_69(m,d) BOOST_PP_REPEAT_2_68(m, d) m(3, 68, d)
#define BOOST_PP_REPEAT_2_70(m,d) BOOST_PP_REPEAT_2_69(m, d) m(3, 69, d)
#define BOOST_PP_REPEAT_2_71(m,d) BOOST_PP_REPEAT_2_70(m, d) m(3, 70, d)
#define BOOST_PP_REPEAT_2_72(m,d) BOOST_PP_REPEAT_2_71(m, d) m(3, 71, d)
#define BOOST_PP_REPEAT_2_73(m,d) BOOST_PP_REPEAT_2_72(m, d) m(3, 72, d)
#define BOOST_PP_REPEAT_2_74(m,d) BOOST_PP_REPEAT_2_73(m, d) m(3, 73, d)
#define BOOST_PP_REPEAT_2_75(m,d) BOOST_PP_REPEAT_2_74(m, d) m(3, 74, d)
#define BOOST_PP_REPEAT_2_76(m,d) BOOST_PP_REPEAT_2_75(m, d) m(3, 75, d)
#define BOOST_PP_REPEAT_2_77(m,d) BOOST_PP_REPEAT_2_76(m, d) m(3, 76, d)
#define BOOST_PP_REPEAT_2_78(m,d) BOOST_PP_REPEAT_2_77(m, d) m(3, 77, d)
#define BOOST_PP_REPEAT_2_79(m,d) BOOST_PP_REPEAT_2_78(m, d) m(3, 78, d)
#define BOOST_PP_REPEAT_2_80(m,d) BOOST_PP_REPEAT_2_79(m, d) m(3, 79, d)
#define BOOST_PP_REPEAT_2_81(m,d) BOOST_PP_REPEAT_2_80(m, d) m(3, 80, d)
#define BOOST_PP_REPEAT_2_82(m,d) BOOST_PP_REPEAT_2_81(m, d) m(3, 81, d)
#define BOOST_PP_REPEAT_2_83(m,d) BOOST_PP_REPEAT_2_82(m, d) m(3, 82, d)
#define BOOST_PP_REPEAT_2_84(m,d) BOOST_PP_REPEAT_2_83(m, d) m(3, 83, d)
#define BOOST_PP_REPEAT_2_85(m,d) BOOST_PP_REPEAT_2_84(m, d) m(3, 84, d)
#define BOOST_PP_REPEAT_2_86(m,d) BOOST_PP_REPEAT_2_85(m, d) m(3, 85, d)
#define BOOST_PP_REPEAT_2_87(m,d) BOOST_PP_REPEAT_2_86(m, d) m(3, 86, d)
#define BOOST_PP_REPEAT_2_88(m,d) BOOST_PP_REPEAT_2_87(m, d) m(3, 87, d)
#define BOOST_PP_REPEAT_2_89(m,d) BOOST_PP_REPEAT_2_88(m, d) m(3, 88, d)
#define BOOST_PP_REPEAT_2_90(m,d) BOOST_PP_REPEAT_2_89(m, d) m(3, 89, d)
#define BOOST_PP_REPEAT_2_91(m,d) BOOST_PP_REPEAT_2_90(m, d) m(3, 90, d)
#define BOOST_PP_REPEAT_2_92(m,d) BOOST_PP_REPEAT_2_91(m, d) m(3, 91, d)
#define BOOST_PP_REPEAT_2_93(m,d) BOOST_PP_REPEAT_2_92(m, d) m(3, 92, d)
#define BOOST_PP_REPEAT_2_94(m,d) BOOST_PP_REPEAT_2_93(m, d) m(3, 93, d)
#define BOOST_PP_REPEAT_2_95(m,d) BOOST_PP_REPEAT_2_94(m, d) m(3, 94, d)
#define BOOST_PP_REPEAT_2_96(m,d) BOOST_PP_REPEAT_2_95(m, d) m(3, 95, d)
#define BOOST_PP_REPEAT_2_97(m,d) BOOST_PP_REPEAT_2_96(m, d) m(3, 96, d)
#define BOOST_PP_REPEAT_2_98(m,d) BOOST_PP_REPEAT_2_97(m, d) m(3, 97, d)
#define BOOST_PP_REPEAT_2_99(m,d) BOOST_PP_REPEAT_2_98(m, d) m(3, 98, d)
#define BOOST_PP_REPEAT_2_100(m,d) BOOST_PP_REPEAT_2_99(m, d) m(3, 99, d)
#define BOOST_PP_REPEAT_2_101(m,d) BOOST_PP_REPEAT_2_100(m, d) m(3, 100, d)
#define BOOST_PP_REPEAT_2_102(m,d) BOOST_PP_REPEAT_2_101(m, d) m(3, 101, d)
#define BOOST_PP_REPEAT_2_103(m,d) BOOST_PP_REPEAT_2_102(m, d) m(3, 102, d)
#define BOOST_PP_REPEAT_2_104(m,d) BOOST_PP_REPEAT_2_103(m, d) m(3, 103, d)
#define BOOST_PP_REPEAT_2_105(m,d) BOOST_PP_REPEAT_2_104(m, d) m(3, 104, d)
#define BOOST_PP_REPEAT_2_106(m,d) BOOST_PP_REPEAT_2_105(m, d) m(3, 105, d)
#define BOOST_PP_REPEAT_2_107(m,d) BOOST_PP_REPEAT_2_106(m, d) m(3, 106, d)
#define BOOST_PP_REPEAT_2_108(m,d) BOOST_PP_REPEAT_2_107(m, d) m(3, 107, d)
#define BOOST_PP_REPEAT_2_109(m,d) BOOST_PP_REPEAT_2_108(m, d) m(3, 108, d)
#define BOOST_PP_REPEAT_2_110(m,d) BOOST_PP_REPEAT_2_109(m, d) m(3, 109, d)
#define BOOST_PP_REPEAT_2_111(m,d) BOOST_PP_REPEAT_2_110(m, d) m(3, 110, d)
#define BOOST_PP_REPEAT_2_112(m,d) BOOST_PP_REPEAT_2_111(m, d) m(3, 111, d)
#define BOOST_PP_REPEAT_2_113(m,d) BOOST_PP_REPEAT_2_112(m, d) m(3, 112, d)
#define BOOST_PP_REPEAT_2_114(m,d) BOOST_PP_REPEAT_2_113(m, d) m(3, 113, d)
#define BOOST_PP_REPEAT_2_115(m,d) BOOST_PP_REPEAT_2_114(m, d) m(3, 114, d)
#define BOOST_PP_REPEAT_2_116(m,d) BOOST_PP_REPEAT_2_115(m, d) m(3, 115, d)
#define BOOST_PP_REPEAT_2_117(m,d) BOOST_PP_REPEAT_2_116(m, d) m(3, 116, d)
#define BOOST_PP_REPEAT_2_118(m,d) BOOST_PP_REPEAT_2_117(m, d) m(3, 117, d)
#define BOOST_PP_REPEAT_2_119(m,d) BOOST_PP_REPEAT_2_118(m, d) m(3, 118, d)
#define BOOST_PP_REPEAT_2_120(m,d) BOOST_PP_REPEAT_2_119(m, d) m(3, 119, d)
#define BOOST_PP_REPEAT_2_121(m,d) BOOST_PP_REPEAT_2_120(m, d) m(3, 120, d)
#define BOOST_PP_REPEAT_2_122(m,d) BOOST_PP_REPEAT_2_121(m, d) m(3, 121, d)
#define BOOST_PP_REPEAT_2_123(m,d) BOOST_PP_REPEAT_2_122(m, d) m(3, 122, d)
#define BOOST_PP_REPEAT_2_124(m,d) BOOST_PP_REPEAT_2_123(m, d) m(3, 123, d)
#define BOOST_PP_REPEAT_2_125(m,d) BOOST_PP_REPEAT_2_124(m, d) m(3, 124, d)
#define BOOST_PP_REPEAT_2_126(m,d) BOOST_PP_REPEAT_2_125(m, d) m(3, 125, d)
#define BOOST_PP_REPEAT_2_127(m,d) BOOST_PP_REPEAT_2_126(m, d) m(3, 126, d)
#define BOOST_PP_REPEAT_2_128(m,d) BOOST_PP_REPEAT_2_127(m, d) m(3, 127, d)
#define BOOST_PP_REPEAT_2_129(m,d) BOOST_PP_REPEAT_2_128(m, d) m(3, 128, d)
#define BOOST_PP_REPEAT_2_130(m,d) BOOST_PP_REPEAT_2_129(m, d) m(3, 129, d)
#define BOOST_PP_REPEAT_2_131(m,d) BOOST_PP_REPEAT_2_130(m, d) m(3, 130, d)
#define BOOST_PP_REPEAT_2_132(m,d) BOOST_PP_REPEAT_2_131(m, d) m(3, 131, d)
#define BOOST_PP_REPEAT_2_133(m,d) BOOST_PP_REPEAT_2_132(m, d) m(3, 132, d)
#define BOOST_PP_REPEAT_2_134(m,d) BOOST_PP_REPEAT_2_133(m, d) m(3, 133, d)
#define BOOST_PP_REPEAT_2_135(m,d) BOOST_PP_REPEAT_2_134(m, d) m(3, 134, d)
#define BOOST_PP_REPEAT_2_136(m,d) BOOST_PP_REPEAT_2_135(m, d) m(3, 135, d)
#define BOOST_PP_REPEAT_2_137(m,d) BOOST_PP_REPEAT_2_136(m, d) m(3, 136, d)
#define BOOST_PP_REPEAT_2_138(m,d) BOOST_PP_REPEAT_2_137(m, d) m(3, 137, d)
#define BOOST_PP_REPEAT_2_139(m,d) BOOST_PP_REPEAT_2_138(m, d) m(3, 138, d)
#define BOOST_PP_REPEAT_2_140(m,d) BOOST_PP_REPEAT_2_139(m, d) m(3, 139, d)
#define BOOST_PP_REPEAT_2_141(m,d) BOOST_PP_REPEAT_2_140(m, d) m(3, 140, d)
#define BOOST_PP_REPEAT_2_142(m,d) BOOST_PP_REPEAT_2_141(m, d) m(3, 141, d)
#define BOOST_PP_REPEAT_2_143(m,d) BOOST_PP_REPEAT_2_142(m, d) m(3, 142, d)
#define BOOST_PP_REPEAT_2_144(m,d) BOOST_PP_REPEAT_2_143(m, d) m(3, 143, d)
#define BOOST_PP_REPEAT_2_145(m,d) BOOST_PP_REPEAT_2_144(m, d) m(3, 144, d)
#define BOOST_PP_REPEAT_2_146(m,d) BOOST_PP_REPEAT_2_145(m, d) m(3, 145, d)
#define BOOST_PP_REPEAT_2_147(m,d) BOOST_PP_REPEAT_2_146(m, d) m(3, 146, d)
#define BOOST_PP_REPEAT_2_148(m,d) BOOST_PP_REPEAT_2_147(m, d) m(3, 147, d)
#define BOOST_PP_REPEAT_2_149(m,d) BOOST_PP_REPEAT_2_148(m, d) m(3, 148, d)
#define BOOST_PP_REPEAT_2_150(m,d) BOOST_PP_REPEAT_2_149(m, d) m(3, 149, d)
#define BOOST_PP_REPEAT_2_151(m,d) BOOST_PP_REPEAT_2_150(m, d) m(3, 150, d)
#define BOOST_PP_REPEAT_2_152(m,d) BOOST_PP_REPEAT_2_151(m, d) m(3, 151, d)
#define BOOST_PP_REPEAT_2_153(m,d) BOOST_PP_REPEAT_2_152(m, d) m(3, 152, d)
#define BOOST_PP_REPEAT_2_154(m,d) BOOST_PP_REPEAT_2_153(m, d) m(3, 153, d)
#define BOOST_PP_REPEAT_2_155(m,d) BOOST_PP_REPEAT_2_154(m, d) m(3, 154, d)
#define BOOST_PP_REPEAT_2_156(m,d) BOOST_PP_REPEAT_2_155(m, d) m(3, 155, d)
#define BOOST_PP_REPEAT_2_157(m,d) BOOST_PP_REPEAT_2_156(m, d) m(3, 156, d)
#define BOOST_PP_REPEAT_2_158(m,d) BOOST_PP_REPEAT_2_157(m, d) m(3, 157, d)
#define BOOST_PP_REPEAT_2_159(m,d) BOOST_PP_REPEAT_2_158(m, d) m(3, 158, d)
#define BOOST_PP_REPEAT_2_160(m,d) BOOST_PP_REPEAT_2_159(m, d) m(3, 159, d)
#define BOOST_PP_REPEAT_2_161(m,d) BOOST_PP_REPEAT_2_160(m, d) m(3, 160, d)
#define BOOST_PP_REPEAT_2_162(m,d) BOOST_PP_REPEAT_2_161(m, d) m(3, 161, d)
#define BOOST_PP_REPEAT_2_163(m,d) BOOST_PP_REPEAT_2_162(m, d) m(3, 162, d)
#define BOOST_PP_REPEAT_2_164(m,d) BOOST_PP_REPEAT_2_163(m, d) m(3, 163, d)
#define BOOST_PP_REPEAT_2_165(m,d) BOOST_PP_REPEAT_2_164(m, d) m(3, 164, d)
#define BOOST_PP_REPEAT_2_166(m,d) BOOST_PP_REPEAT_2_165(m, d) m(3, 165, d)
#define BOOST_PP_REPEAT_2_167(m,d) BOOST_PP_REPEAT_2_166(m, d) m(3, 166, d)
#define BOOST_PP_REPEAT_2_168(m,d) BOOST_PP_REPEAT_2_167(m, d) m(3, 167, d)
#define BOOST_PP_REPEAT_2_169(m,d) BOOST_PP_REPEAT_2_168(m, d) m(3, 168, d)
#define BOOST_PP_REPEAT_2_170(m,d) BOOST_PP_REPEAT_2_169(m, d) m(3, 169, d)
#define BOOST_PP_REPEAT_2_171(m,d) BOOST_PP_REPEAT_2_170(m, d) m(3, 170, d)
#define BOOST_PP_REPEAT_2_172(m,d) BOOST_PP_REPEAT_2_171(m, d) m(3, 171, d)
#define BOOST_PP_REPEAT_2_173(m,d) BOOST_PP_REPEAT_2_172(m, d) m(3, 172, d)
#define BOOST_PP_REPEAT_2_174(m,d) BOOST_PP_REPEAT_2_173(m, d) m(3, 173, d)
#define BOOST_PP_REPEAT_2_175(m,d) BOOST_PP_REPEAT_2_174(m, d) m(3, 174, d)
#define BOOST_PP_REPEAT_2_176(m,d) BOOST_PP_REPEAT_2_175(m, d) m(3, 175, d)
#define BOOST_PP_REPEAT_2_177(m,d) BOOST_PP_REPEAT_2_176(m, d) m(3, 176, d)
#define BOOST_PP_REPEAT_2_178(m,d) BOOST_PP_REPEAT_2_177(m, d) m(3, 177, d)
#define BOOST_PP_REPEAT_2_179(m,d) BOOST_PP_REPEAT_2_178(m, d) m(3, 178, d)
#define BOOST_PP_REPEAT_2_180(m,d) BOOST_PP_REPEAT_2_179(m, d) m(3, 179, d)
#define BOOST_PP_REPEAT_2_181(m,d) BOOST_PP_REPEAT_2_180(m, d) m(3, 180, d)
#define BOOST_PP_REPEAT_2_182(m,d) BOOST_PP_REPEAT_2_181(m, d) m(3, 181, d)
#define BOOST_PP_REPEAT_2_183(m,d) BOOST_PP_REPEAT_2_182(m, d) m(3, 182, d)
#define BOOST_PP_REPEAT_2_184(m,d) BOOST_PP_REPEAT_2_183(m, d) m(3, 183, d)
#define BOOST_PP_REPEAT_2_185(m,d) BOOST_PP_REPEAT_2_184(m, d) m(3, 184, d)
#define BOOST_PP_REPEAT_2_186(m,d) BOOST_PP_REPEAT_2_185(m, d) m(3, 185, d)
#define BOOST_PP_REPEAT_2_187(m,d) BOOST_PP_REPEAT_2_186(m, d) m(3, 186, d)
#define BOOST_PP_REPEAT_2_188(m,d) BOOST_PP_REPEAT_2_187(m, d) m(3, 187, d)
#define BOOST_PP_REPEAT_2_189(m,d) BOOST_PP_REPEAT_2_188(m, d) m(3, 188, d)
#define BOOST_PP_REPEAT_2_190(m,d) BOOST_PP_REPEAT_2_189(m, d) m(3, 189, d)
#define BOOST_PP_REPEAT_2_191(m,d) BOOST_PP_REPEAT_2_190(m, d) m(3, 190, d)
#define BOOST_PP_REPEAT_2_192(m,d) BOOST_PP_REPEAT_2_191(m, d) m(3, 191, d)
#define BOOST_PP_REPEAT_2_193(m,d) BOOST_PP_REPEAT_2_192(m, d) m(3, 192, d)
#define BOOST_PP_REPEAT_2_194(m,d) BOOST_PP_REPEAT_2_193(m, d) m(3, 193, d)
#define BOOST_PP_REPEAT_2_195(m,d) BOOST_PP_REPEAT_2_194(m, d) m(3, 194, d)
#define BOOST_PP_REPEAT_2_196(m,d) BOOST_PP_REPEAT_2_195(m, d) m(3, 195, d)
#define BOOST_PP_REPEAT_2_197(m,d) BOOST_PP_REPEAT_2_196(m, d) m(3, 196, d)
#define BOOST_PP_REPEAT_2_198(m,d) BOOST_PP_REPEAT_2_197(m, d) m(3, 197, d)
#define BOOST_PP_REPEAT_2_199(m,d) BOOST_PP_REPEAT_2_198(m, d) m(3, 198, d)
#define BOOST_PP_REPEAT_2_200(m,d) BOOST_PP_REPEAT_2_199(m, d) m(3, 199, d)
#define BOOST_PP_REPEAT_2_201(m,d) BOOST_PP_REPEAT_2_200(m, d) m(3, 200, d)
#define BOOST_PP_REPEAT_2_202(m,d) BOOST_PP_REPEAT_2_201(m, d) m(3, 201, d)
#define BOOST_PP_REPEAT_2_203(m,d) BOOST_PP_REPEAT_2_202(m, d) m(3, 202, d)
#define BOOST_PP_REPEAT_2_204(m,d) BOOST_PP_REPEAT_2_203(m, d) m(3, 203, d)
#define BOOST_PP_REPEAT_2_205(m,d) BOOST_PP_REPEAT_2_204(m, d) m(3, 204, d)
#define BOOST_PP_REPEAT_2_206(m,d) BOOST_PP_REPEAT_2_205(m, d) m(3, 205, d)
#define BOOST_PP_REPEAT_2_207(m,d) BOOST_PP_REPEAT_2_206(m, d) m(3, 206, d)
#define BOOST_PP_REPEAT_2_208(m,d) BOOST_PP_REPEAT_2_207(m, d) m(3, 207, d)
#define BOOST_PP_REPEAT_2_209(m,d) BOOST_PP_REPEAT_2_208(m, d) m(3, 208, d)
#define BOOST_PP_REPEAT_2_210(m,d) BOOST_PP_REPEAT_2_209(m, d) m(3, 209, d)
#define BOOST_PP_REPEAT_2_211(m,d) BOOST_PP_REPEAT_2_210(m, d) m(3, 210, d)
#define BOOST_PP_REPEAT_2_212(m,d) BOOST_PP_REPEAT_2_211(m, d) m(3, 211, d)
#define BOOST_PP_REPEAT_2_213(m,d) BOOST_PP_REPEAT_2_212(m, d) m(3, 212, d)
#define BOOST_PP_REPEAT_2_214(m,d) BOOST_PP_REPEAT_2_213(m, d) m(3, 213, d)
#define BOOST_PP_REPEAT_2_215(m,d) BOOST_PP_REPEAT_2_214(m, d) m(3, 214, d)
#define BOOST_PP_REPEAT_2_216(m,d) BOOST_PP_REPEAT_2_215(m, d) m(3, 215, d)
#define BOOST_PP_REPEAT_2_217(m,d) BOOST_PP_REPEAT_2_216(m, d) m(3, 216, d)
#define BOOST_PP_REPEAT_2_218(m,d) BOOST_PP_REPEAT_2_217(m, d) m(3, 217, d)
#define BOOST_PP_REPEAT_2_219(m,d) BOOST_PP_REPEAT_2_218(m, d) m(3, 218, d)
#define BOOST_PP_REPEAT_2_220(m,d) BOOST_PP_REPEAT_2_219(m, d) m(3, 219, d)
#define BOOST_PP_REPEAT_2_221(m,d) BOOST_PP_REPEAT_2_220(m, d) m(3, 220, d)
#define BOOST_PP_REPEAT_2_222(m,d) BOOST_PP_REPEAT_2_221(m, d) m(3, 221, d)
#define BOOST_PP_REPEAT_2_223(m,d) BOOST_PP_REPEAT_2_222(m, d) m(3, 222, d)
#define BOOST_PP_REPEAT_2_224(m,d) BOOST_PP_REPEAT_2_223(m, d) m(3, 223, d)
#define BOOST_PP_REPEAT_2_225(m,d) BOOST_PP_REPEAT_2_224(m, d) m(3, 224, d)
#define BOOST_PP_REPEAT_2_226(m,d) BOOST_PP_REPEAT_2_225(m, d) m(3, 225, d)
#define BOOST_PP_REPEAT_2_227(m,d) BOOST_PP_REPEAT_2_226(m, d) m(3, 226, d)
#define BOOST_PP_REPEAT_2_228(m,d) BOOST_PP_REPEAT_2_227(m, d) m(3, 227, d)
#define BOOST_PP_REPEAT_2_229(m,d) BOOST_PP_REPEAT_2_228(m, d) m(3, 228, d)
#define BOOST_PP_REPEAT_2_230(m,d) BOOST_PP_REPEAT_2_229(m, d) m(3, 229, d)
#define BOOST_PP_REPEAT_2_231(m,d) BOOST_PP_REPEAT_2_230(m, d) m(3, 230, d)
#define BOOST_PP_REPEAT_2_232(m,d) BOOST_PP_REPEAT_2_231(m, d) m(3, 231, d)
#define BOOST_PP_REPEAT_2_233(m,d) BOOST_PP_REPEAT_2_232(m, d) m(3, 232, d)
#define BOOST_PP_REPEAT_2_234(m,d) BOOST_PP_REPEAT_2_233(m, d) m(3, 233, d)
#define BOOST_PP_REPEAT_2_235(m,d) BOOST_PP_REPEAT_2_234(m, d) m(3, 234, d)
#define BOOST_PP_REPEAT_2_236(m,d) BOOST_PP_REPEAT_2_235(m, d) m(3, 235, d)
#define BOOST_PP_REPEAT_2_237(m,d) BOOST_PP_REPEAT_2_236(m, d) m(3, 236, d)
#define BOOST_PP_REPEAT_2_238(m,d) BOOST_PP_REPEAT_2_237(m, d) m(3, 237, d)
#define BOOST_PP_REPEAT_2_239(m,d) BOOST_PP_REPEAT_2_238(m, d) m(3, 238, d)
#define BOOST_PP_REPEAT_2_240(m,d) BOOST_PP_REPEAT_2_239(m, d) m(3, 239, d)
#define BOOST_PP_REPEAT_2_241(m,d) BOOST_PP_REPEAT_2_240(m, d) m(3, 240, d)
#define BOOST_PP_REPEAT_2_242(m,d) BOOST_PP_REPEAT_2_241(m, d) m(3, 241, d)
#define BOOST_PP_REPEAT_2_243(m,d) BOOST_PP_REPEAT_2_242(m, d) m(3, 242, d)
#define BOOST_PP_REPEAT_2_244(m,d) BOOST_PP_REPEAT_2_243(m, d) m(3, 243, d)
#define BOOST_PP_REPEAT_2_245(m,d) BOOST_PP_REPEAT_2_244(m, d) m(3, 244, d)
#define BOOST_PP_REPEAT_2_246(m,d) BOOST_PP_REPEAT_2_245(m, d) m(3, 245, d)
#define BOOST_PP_REPEAT_2_247(m,d) BOOST_PP_REPEAT_2_246(m, d) m(3, 246, d)
#define BOOST_PP_REPEAT_2_248(m,d) BOOST_PP_REPEAT_2_247(m, d) m(3, 247, d)
#define BOOST_PP_REPEAT_2_249(m,d) BOOST_PP_REPEAT_2_248(m, d) m(3, 248, d)
#define BOOST_PP_REPEAT_2_250(m,d) BOOST_PP_REPEAT_2_249(m, d) m(3, 249, d)
#define BOOST_PP_REPEAT_2_251(m,d) BOOST_PP_REPEAT_2_250(m, d) m(3, 250, d)
#define BOOST_PP_REPEAT_2_252(m,d) BOOST_PP_REPEAT_2_251(m, d) m(3, 251, d)
#define BOOST_PP_REPEAT_2_253(m,d) BOOST_PP_REPEAT_2_252(m, d) m(3, 252, d)
#define BOOST_PP_REPEAT_2_254(m,d) BOOST_PP_REPEAT_2_253(m, d) m(3, 253, d)
#define BOOST_PP_REPEAT_2_255(m,d) BOOST_PP_REPEAT_2_254(m, d) m(3, 254, d)
#define BOOST_PP_REPEAT_2_256(m,d) BOOST_PP_REPEAT_2_255(m, d) m(3, 255, d)
#define BOOST_PP_REPEAT_3_0(m,d)
#define BOOST_PP_REPEAT_3_1(m,d) m(4, 0, d)
#define BOOST_PP_REPEAT_3_2(m,d) BOOST_PP_REPEAT_3_1(m, d) m(4, 1, d)
#define BOOST_PP_REPEAT_3_3(m,d) BOOST_PP_REPEAT_3_2(m, d) m(4, 2, d)
#define BOOST_PP_REPEAT_3_4(m,d) BOOST_PP_REPEAT_3_3(m, d) m(4, 3, d)
#define BOOST_PP_REPEAT_3_5(m,d) BOOST_PP_REPEAT_3_4(m, d) m(4, 4, d)
#define BOOST_PP_REPEAT_3_6(m,d) BOOST_PP_REPEAT_3_5(m, d) m(4, 5, d)
#define BOOST_PP_REPEAT_3_7(m,d) BOOST_PP_REPEAT_3_6(m, d) m(4, 6, d)
#define BOOST_PP_REPEAT_3_8(m,d) BOOST_PP_REPEAT_3_7(m, d) m(4, 7, d)
#define BOOST_PP_REPEAT_3_9(m,d) BOOST_PP_REPEAT_3_8(m, d) m(4, 8, d)
#define BOOST_PP_REPEAT_3_10(m,d) BOOST_PP_REPEAT_3_9(m, d) m(4, 9, d)
#define BOOST_PP_REPEAT_3_11(m,d) BOOST_PP_REPEAT_3_10(m, d) m(4, 10, d)
#define BOOST_PP_REPEAT_3_12(m,d) BOOST_PP_REPEAT_3_11(m, d) m(4, 11, d)
#define BOOST_PP_REPEAT_3_13(m,d) BOOST_PP_REPEAT_3_12(m, d) m(4, 12, d)
#define BOOST_PP_REPEAT_3_14(m,d) BOOST_PP_REPEAT_3_13(m, d) m(4, 13, d)
#define BOOST_PP_REPEAT_3_15(m,d) BOOST_PP_REPEAT_3_14(m, d) m(4, 14, d)
#define BOOST_PP_REPEAT_3_16(m,d) BOOST_PP_REPEAT_3_15(m, d) m(4, 15, d)
#define BOOST_PP_REPEAT_3_17(m,d) BOOST_PP_REPEAT_3_16(m, d) m(4, 16, d)
#define BOOST_PP_REPEAT_3_18(m,d) BOOST_PP_REPEAT_3_17(m, d) m(4, 17, d)
#define BOOST_PP_REPEAT_3_19(m,d) BOOST_PP_REPEAT_3_18(m, d) m(4, 18, d)
#define BOOST_PP_REPEAT_3_20(m,d) BOOST_PP_REPEAT_3_19(m, d) m(4, 19, d)
#define BOOST_PP_REPEAT_3_21(m,d) BOOST_PP_REPEAT_3_20(m, d) m(4, 20, d)
#define BOOST_PP_REPEAT_3_22(m,d) BOOST_PP_REPEAT_3_21(m, d) m(4, 21, d)
#define BOOST_PP_REPEAT_3_23(m,d) BOOST_PP_REPEAT_3_22(m, d) m(4, 22, d)
#define BOOST_PP_REPEAT_3_24(m,d) BOOST_PP_REPEAT_3_23(m, d) m(4, 23, d)
#define BOOST_PP_REPEAT_3_25(m,d) BOOST_PP_REPEAT_3_24(m, d) m(4, 24, d)
#define BOOST_PP_REPEAT_3_26(m,d) BOOST_PP_REPEAT_3_25(m, d) m(4, 25, d)
#define BOOST_PP_REPEAT_3_27(m,d) BOOST_PP_REPEAT_3_26(m, d) m(4, 26, d)
#define BOOST_PP_REPEAT_3_28(m,d) BOOST_PP_REPEAT_3_27(m, d) m(4, 27, d)
#define BOOST_PP_REPEAT_3_29(m,d) BOOST_PP_REPEAT_3_28(m, d) m(4, 28, d)
#define BOOST_PP_REPEAT_3_30(m,d) BOOST_PP_REPEAT_3_29(m, d) m(4, 29, d)
#define BOOST_PP_REPEAT_3_31(m,d) BOOST_PP_REPEAT_3_30(m, d) m(4, 30, d)
#define BOOST_PP_REPEAT_3_32(m,d) BOOST_PP_REPEAT_3_31(m, d) m(4, 31, d)
#define BOOST_PP_REPEAT_3_33(m,d) BOOST_PP_REPEAT_3_32(m, d) m(4, 32, d)
#define BOOST_PP_REPEAT_3_34(m,d) BOOST_PP_REPEAT_3_33(m, d) m(4, 33, d)
#define BOOST_PP_REPEAT_3_35(m,d) BOOST_PP_REPEAT_3_34(m, d) m(4, 34, d)
#define BOOST_PP_REPEAT_3_36(m,d) BOOST_PP_REPEAT_3_35(m, d) m(4, 35, d)
#define BOOST_PP_REPEAT_3_37(m,d) BOOST_PP_REPEAT_3_36(m, d) m(4, 36, d)
#define BOOST_PP_REPEAT_3_38(m,d) BOOST_PP_REPEAT_3_37(m, d) m(4, 37, d)
#define BOOST_PP_REPEAT_3_39(m,d) BOOST_PP_REPEAT_3_38(m, d) m(4, 38, d)
#define BOOST_PP_REPEAT_3_40(m,d) BOOST_PP_REPEAT_3_39(m, d) m(4, 39, d)
#define BOOST_PP_REPEAT_3_41(m,d) BOOST_PP_REPEAT_3_40(m, d) m(4, 40, d)
#define BOOST_PP_REPEAT_3_42(m,d) BOOST_PP_REPEAT_3_41(m, d) m(4, 41, d)
#define BOOST_PP_REPEAT_3_43(m,d) BOOST_PP_REPEAT_3_42(m, d) m(4, 42, d)
#define BOOST_PP_REPEAT_3_44(m,d) BOOST_PP_REPEAT_3_43(m, d) m(4, 43, d)
#define BOOST_PP_REPEAT_3_45(m,d) BOOST_PP_REPEAT_3_44(m, d) m(4, 44, d)
#define BOOST_PP_REPEAT_3_46(m,d) BOOST_PP_REPEAT_3_45(m, d) m(4, 45, d)
#define BOOST_PP_REPEAT_3_47(m,d) BOOST_PP_REPEAT_3_46(m, d) m(4, 46, d)
#define BOOST_PP_REPEAT_3_48(m,d) BOOST_PP_REPEAT_3_47(m, d) m(4, 47, d)
#define BOOST_PP_REPEAT_3_49(m,d) BOOST_PP_REPEAT_3_48(m, d) m(4, 48, d)
#define BOOST_PP_REPEAT_3_50(m,d) BOOST_PP_REPEAT_3_49(m, d) m(4, 49, d)
#define BOOST_PP_REPEAT_3_51(m,d) BOOST_PP_REPEAT_3_50(m, d) m(4, 50, d)
#define BOOST_PP_REPEAT_3_52(m,d) BOOST_PP_REPEAT_3_51(m, d) m(4, 51, d)
#define BOOST_PP_REPEAT_3_53(m,d) BOOST_PP_REPEAT_3_52(m, d) m(4, 52, d)
#define BOOST_PP_REPEAT_3_54(m,d) BOOST_PP_REPEAT_3_53(m, d) m(4, 53, d)
#define BOOST_PP_REPEAT_3_55(m,d) BOOST_PP_REPEAT_3_54(m, d) m(4, 54, d)
#define BOOST_PP_REPEAT_3_56(m,d) BOOST_PP_REPEAT_3_55(m, d) m(4, 55, d)
#define BOOST_PP_REPEAT_3_57(m,d) BOOST_PP_REPEAT_3_56(m, d) m(4, 56, d)
#define BOOST_PP_REPEAT_3_58(m,d) BOOST_PP_REPEAT_3_57(m, d) m(4, 57, d)
#define BOOST_PP_REPEAT_3_59(m,d) BOOST_PP_REPEAT_3_58(m, d) m(4, 58, d)
#define BOOST_PP_REPEAT_3_60(m,d) BOOST_PP_REPEAT_3_59(m, d) m(4, 59, d)
#define BOOST_PP_REPEAT_3_61(m,d) BOOST_PP_REPEAT_3_60(m, d) m(4, 60, d)
#define BOOST_PP_REPEAT_3_62(m,d) BOOST_PP_REPEAT_3_61(m, d) m(4, 61, d)
#define BOOST_PP_REPEAT_3_63(m,d) BOOST_PP_REPEAT_3_62(m, d) m(4, 62, d)
#define BOOST_PP_REPEAT_3_64(m,d) BOOST_PP_REPEAT_3_63(m, d) m(4, 63, d)
#define BOOST_PP_REPEAT_3_65(m,d) BOOST_PP_REPEAT_3_64(m, d) m(4, 64, d)
#define BOOST_PP_REPEAT_3_66(m,d) BOOST_PP_REPEAT_3_65(m, d) m(4, 65, d)
#define BOOST_PP_REPEAT_3_67(m,d) BOOST_PP_REPEAT_3_66(m, d) m(4, 66, d)
#define BOOST_PP_REPEAT_3_68(m,d) BOOST_PP_REPEAT_3_67(m, d) m(4, 67, d)
#define BOOST_PP_REPEAT_3_69(m,d) BOOST_PP_REPEAT_3_68(m, d) m(4, 68, d)
#define BOOST_PP_REPEAT_3_70(m,d) BOOST_PP_REPEAT_3_69(m, d) m(4, 69, d)
#define BOOST_PP_REPEAT_3_71(m,d) BOOST_PP_REPEAT_3_70(m, d) m(4, 70, d)
#define BOOST_PP_REPEAT_3_72(m,d) BOOST_PP_REPEAT_3_71(m, d) m(4, 71, d)
#define BOOST_PP_REPEAT_3_73(m,d) BOOST_PP_REPEAT_3_72(m, d) m(4, 72, d)
#define BOOST_PP_REPEAT_3_74(m,d) BOOST_PP_REPEAT_3_73(m, d) m(4, 73, d)
#define BOOST_PP_REPEAT_3_75(m,d) BOOST_PP_REPEAT_3_74(m, d) m(4, 74, d)
#define BOOST_PP_REPEAT_3_76(m,d) BOOST_PP_REPEAT_3_75(m, d) m(4, 75, d)
#define BOOST_PP_REPEAT_3_77(m,d) BOOST_PP_REPEAT_3_76(m, d) m(4, 76, d)
#define BOOST_PP_REPEAT_3_78(m,d) BOOST_PP_REPEAT_3_77(m, d) m(4, 77, d)
#define BOOST_PP_REPEAT_3_79(m,d) BOOST_PP_REPEAT_3_78(m, d) m(4, 78, d)
#define BOOST_PP_REPEAT_3_80(m,d) BOOST_PP_REPEAT_3_79(m, d) m(4, 79, d)
#define BOOST_PP_REPEAT_3_81(m,d) BOOST_PP_REPEAT_3_80(m, d) m(4, 80, d)
#define BOOST_PP_REPEAT_3_82(m,d) BOOST_PP_REPEAT_3_81(m, d) m(4, 81, d)
#define BOOST_PP_REPEAT_3_83(m,d) BOOST_PP_REPEAT_3_82(m, d) m(4, 82, d)
#define BOOST_PP_REPEAT_3_84(m,d) BOOST_PP_REPEAT_3_83(m, d) m(4, 83, d)
#define BOOST_PP_REPEAT_3_85(m,d) BOOST_PP_REPEAT_3_84(m, d) m(4, 84, d)
#define BOOST_PP_REPEAT_3_86(m,d) BOOST_PP_REPEAT_3_85(m, d) m(4, 85, d)
#define BOOST_PP_REPEAT_3_87(m,d) BOOST_PP_REPEAT_3_86(m, d) m(4, 86, d)
#define BOOST_PP_REPEAT_3_88(m,d) BOOST_PP_REPEAT_3_87(m, d) m(4, 87, d)
#define BOOST_PP_REPEAT_3_89(m,d) BOOST_PP_REPEAT_3_88(m, d) m(4, 88, d)
#define BOOST_PP_REPEAT_3_90(m,d) BOOST_PP_REPEAT_3_89(m, d) m(4, 89, d)
#define BOOST_PP_REPEAT_3_91(m,d) BOOST_PP_REPEAT_3_90(m, d) m(4, 90, d)
#define BOOST_PP_REPEAT_3_92(m,d) BOOST_PP_REPEAT_3_91(m, d) m(4, 91, d)
#define BOOST_PP_REPEAT_3_93(m,d) BOOST_PP_REPEAT_3_92(m, d) m(4, 92, d)
#define BOOST_PP_REPEAT_3_94(m,d) BOOST_PP_REPEAT_3_93(m, d) m(4, 93, d)
#define BOOST_PP_REPEAT_3_95(m,d) BOOST_PP_REPEAT_3_94(m, d) m(4, 94, d)
#define BOOST_PP_REPEAT_3_96(m,d) BOOST_PP_REPEAT_3_95(m, d) m(4, 95, d)
#define BOOST_PP_REPEAT_3_97(m,d) BOOST_PP_REPEAT_3_96(m, d) m(4, 96, d)
#define BOOST_PP_REPEAT_3_98(m,d) BOOST_PP_REPEAT_3_97(m, d) m(4, 97, d)
#define BOOST_PP_REPEAT_3_99(m,d) BOOST_PP_REPEAT_3_98(m, d) m(4, 98, d)
#define BOOST_PP_REPEAT_3_100(m,d) BOOST_PP_REPEAT_3_99(m, d) m(4, 99, d)
#define BOOST_PP_REPEAT_3_101(m,d) BOOST_PP_REPEAT_3_100(m, d) m(4, 100, d)
#define BOOST_PP_REPEAT_3_102(m,d) BOOST_PP_REPEAT_3_101(m, d) m(4, 101, d)
#define BOOST_PP_REPEAT_3_103(m,d) BOOST_PP_REPEAT_3_102(m, d) m(4, 102, d)
#define BOOST_PP_REPEAT_3_104(m,d) BOOST_PP_REPEAT_3_103(m, d) m(4, 103, d)
#define BOOST_PP_REPEAT_3_105(m,d) BOOST_PP_REPEAT_3_104(m, d) m(4, 104, d)
#define BOOST_PP_REPEAT_3_106(m,d) BOOST_PP_REPEAT_3_105(m, d) m(4, 105, d)
#define BOOST_PP_REPEAT_3_107(m,d) BOOST_PP_REPEAT_3_106(m, d) m(4, 106, d)
#define BOOST_PP_REPEAT_3_108(m,d) BOOST_PP_REPEAT_3_107(m, d) m(4, 107, d)
#define BOOST_PP_REPEAT_3_109(m,d) BOOST_PP_REPEAT_3_108(m, d) m(4, 108, d)
#define BOOST_PP_REPEAT_3_110(m,d) BOOST_PP_REPEAT_3_109(m, d) m(4, 109, d)
#define BOOST_PP_REPEAT_3_111(m,d) BOOST_PP_REPEAT_3_110(m, d) m(4, 110, d)
#define BOOST_PP_REPEAT_3_112(m,d) BOOST_PP_REPEAT_3_111(m, d) m(4, 111, d)
#define BOOST_PP_REPEAT_3_113(m,d) BOOST_PP_REPEAT_3_112(m, d) m(4, 112, d)
#define BOOST_PP_REPEAT_3_114(m,d) BOOST_PP_REPEAT_3_113(m, d) m(4, 113, d)
#define BOOST_PP_REPEAT_3_115(m,d) BOOST_PP_REPEAT_3_114(m, d) m(4, 114, d)
#define BOOST_PP_REPEAT_3_116(m,d) BOOST_PP_REPEAT_3_115(m, d) m(4, 115, d)
#define BOOST_PP_REPEAT_3_117(m,d) BOOST_PP_REPEAT_3_116(m, d) m(4, 116, d)
#define BOOST_PP_REPEAT_3_118(m,d) BOOST_PP_REPEAT_3_117(m, d) m(4, 117, d)
#define BOOST_PP_REPEAT_3_119(m,d) BOOST_PP_REPEAT_3_118(m, d) m(4, 118, d)
#define BOOST_PP_REPEAT_3_120(m,d) BOOST_PP_REPEAT_3_119(m, d) m(4, 119, d)
#define BOOST_PP_REPEAT_3_121(m,d) BOOST_PP_REPEAT_3_120(m, d) m(4, 120, d)
#define BOOST_PP_REPEAT_3_122(m,d) BOOST_PP_REPEAT_3_121(m, d) m(4, 121, d)
#define BOOST_PP_REPEAT_3_123(m,d) BOOST_PP_REPEAT_3_122(m, d) m(4, 122, d)
#define BOOST_PP_REPEAT_3_124(m,d) BOOST_PP_REPEAT_3_123(m, d) m(4, 123, d)
#define BOOST_PP_REPEAT_3_125(m,d) BOOST_PP_REPEAT_3_124(m, d) m(4, 124, d)
#define BOOST_PP_REPEAT_3_126(m,d) BOOST_PP_REPEAT_3_125(m, d) m(4, 125, d)
#define BOOST_PP_REPEAT_3_127(m,d) BOOST_PP_REPEAT_3_126(m, d) m(4, 126, d)
#define BOOST_PP_REPEAT_3_128(m,d) BOOST_PP_REPEAT_3_127(m, d) m(4, 127, d)
#define BOOST_PP_REPEAT_3_129(m,d) BOOST_PP_REPEAT_3_128(m, d) m(4, 128, d)
#define BOOST_PP_REPEAT_3_130(m,d) BOOST_PP_REPEAT_3_129(m, d) m(4, 129, d)
#define BOOST_PP_REPEAT_3_131(m,d) BOOST_PP_REPEAT_3_130(m, d) m(4, 130, d)
#define BOOST_PP_REPEAT_3_132(m,d) BOOST_PP_REPEAT_3_131(m, d) m(4, 131, d)
#define BOOST_PP_REPEAT_3_133(m,d) BOOST_PP_REPEAT_3_132(m, d) m(4, 132, d)
#define BOOST_PP_REPEAT_3_134(m,d) BOOST_PP_REPEAT_3_133(m, d) m(4, 133, d)
#define BOOST_PP_REPEAT_3_135(m,d) BOOST_PP_REPEAT_3_134(m, d) m(4, 134, d)
#define BOOST_PP_REPEAT_3_136(m,d) BOOST_PP_REPEAT_3_135(m, d) m(4, 135, d)
#define BOOST_PP_REPEAT_3_137(m,d) BOOST_PP_REPEAT_3_136(m, d) m(4, 136, d)
#define BOOST_PP_REPEAT_3_138(m,d) BOOST_PP_REPEAT_3_137(m, d) m(4, 137, d)
#define BOOST_PP_REPEAT_3_139(m,d) BOOST_PP_REPEAT_3_138(m, d) m(4, 138, d)
#define BOOST_PP_REPEAT_3_140(m,d) BOOST_PP_REPEAT_3_139(m, d) m(4, 139, d)
#define BOOST_PP_REPEAT_3_141(m,d) BOOST_PP_REPEAT_3_140(m, d) m(4, 140, d)
#define BOOST_PP_REPEAT_3_142(m,d) BOOST_PP_REPEAT_3_141(m, d) m(4, 141, d)
#define BOOST_PP_REPEAT_3_143(m,d) BOOST_PP_REPEAT_3_142(m, d) m(4, 142, d)
#define BOOST_PP_REPEAT_3_144(m,d) BOOST_PP_REPEAT_3_143(m, d) m(4, 143, d)
#define BOOST_PP_REPEAT_3_145(m,d) BOOST_PP_REPEAT_3_144(m, d) m(4, 144, d)
#define BOOST_PP_REPEAT_3_146(m,d) BOOST_PP_REPEAT_3_145(m, d) m(4, 145, d)
#define BOOST_PP_REPEAT_3_147(m,d) BOOST_PP_REPEAT_3_146(m, d) m(4, 146, d)
#define BOOST_PP_REPEAT_3_148(m,d) BOOST_PP_REPEAT_3_147(m, d) m(4, 147, d)
#define BOOST_PP_REPEAT_3_149(m,d) BOOST_PP_REPEAT_3_148(m, d) m(4, 148, d)
#define BOOST_PP_REPEAT_3_150(m,d) BOOST_PP_REPEAT_3_149(m, d) m(4, 149, d)
#define BOOST_PP_REPEAT_3_151(m,d) BOOST_PP_REPEAT_3_150(m, d) m(4, 150, d)
#define BOOST_PP_REPEAT_3_152(m,d) BOOST_PP_REPEAT_3_151(m, d) m(4, 151, d)
#define BOOST_PP_REPEAT_3_153(m,d) BOOST_PP_REPEAT_3_152(m, d) m(4, 152, d)
#define BOOST_PP_REPEAT_3_154(m,d) BOOST_PP_REPEAT_3_153(m, d) m(4, 153, d)
#define BOOST_PP_REPEAT_3_155(m,d) BOOST_PP_REPEAT_3_154(m, d) m(4, 154, d)
#define BOOST_PP_REPEAT_3_156(m,d) BOOST_PP_REPEAT_3_155(m, d) m(4, 155, d)
#define BOOST_PP_REPEAT_3_157(m,d) BOOST_PP_REPEAT_3_156(m, d) m(4, 156, d)
#define BOOST_PP_REPEAT_3_158(m,d) BOOST_PP_REPEAT_3_157(m, d) m(4, 157, d)
#define BOOST_PP_REPEAT_3_159(m,d) BOOST_PP_REPEAT_3_158(m, d) m(4, 158, d)
#define BOOST_PP_REPEAT_3_160(m,d) BOOST_PP_REPEAT_3_159(m, d) m(4, 159, d)
#define BOOST_PP_REPEAT_3_161(m,d) BOOST_PP_REPEAT_3_160(m, d) m(4, 160, d)
#define BOOST_PP_REPEAT_3_162(m,d) BOOST_PP_REPEAT_3_161(m, d) m(4, 161, d)
#define BOOST_PP_REPEAT_3_163(m,d) BOOST_PP_REPEAT_3_162(m, d) m(4, 162, d)
#define BOOST_PP_REPEAT_3_164(m,d) BOOST_PP_REPEAT_3_163(m, d) m(4, 163, d)
#define BOOST_PP_REPEAT_3_165(m,d) BOOST_PP_REPEAT_3_164(m, d) m(4, 164, d)
#define BOOST_PP_REPEAT_3_166(m,d) BOOST_PP_REPEAT_3_165(m, d) m(4, 165, d)
#define BOOST_PP_REPEAT_3_167(m,d) BOOST_PP_REPEAT_3_166(m, d) m(4, 166, d)
#define BOOST_PP_REPEAT_3_168(m,d) BOOST_PP_REPEAT_3_167(m, d) m(4, 167, d)
#define BOOST_PP_REPEAT_3_169(m,d) BOOST_PP_REPEAT_3_168(m, d) m(4, 168, d)
#define BOOST_PP_REPEAT_3_170(m,d) BOOST_PP_REPEAT_3_169(m, d) m(4, 169, d)
#define BOOST_PP_REPEAT_3_171(m,d) BOOST_PP_REPEAT_3_170(m, d) m(4, 170, d)
#define BOOST_PP_REPEAT_3_172(m,d) BOOST_PP_REPEAT_3_171(m, d) m(4, 171, d)
#define BOOST_PP_REPEAT_3_173(m,d) BOOST_PP_REPEAT_3_172(m, d) m(4, 172, d)
#define BOOST_PP_REPEAT_3_174(m,d) BOOST_PP_REPEAT_3_173(m, d) m(4, 173, d)
#define BOOST_PP_REPEAT_3_175(m,d) BOOST_PP_REPEAT_3_174(m, d) m(4, 174, d)
#define BOOST_PP_REPEAT_3_176(m,d) BOOST_PP_REPEAT_3_175(m, d) m(4, 175, d)
#define BOOST_PP_REPEAT_3_177(m,d) BOOST_PP_REPEAT_3_176(m, d) m(4, 176, d)
#define BOOST_PP_REPEAT_3_178(m,d) BOOST_PP_REPEAT_3_177(m, d) m(4, 177, d)
#define BOOST_PP_REPEAT_3_179(m,d) BOOST_PP_REPEAT_3_178(m, d) m(4, 178, d)
#define BOOST_PP_REPEAT_3_180(m,d) BOOST_PP_REPEAT_3_179(m, d) m(4, 179, d)
#define BOOST_PP_REPEAT_3_181(m,d) BOOST_PP_REPEAT_3_180(m, d) m(4, 180, d)
#define BOOST_PP_REPEAT_3_182(m,d) BOOST_PP_REPEAT_3_181(m, d) m(4, 181, d)
#define BOOST_PP_REPEAT_3_183(m,d) BOOST_PP_REPEAT_3_182(m, d) m(4, 182, d)
#define BOOST_PP_REPEAT_3_184(m,d) BOOST_PP_REPEAT_3_183(m, d) m(4, 183, d)
#define BOOST_PP_REPEAT_3_185(m,d) BOOST_PP_REPEAT_3_184(m, d) m(4, 184, d)
#define BOOST_PP_REPEAT_3_186(m,d) BOOST_PP_REPEAT_3_185(m, d) m(4, 185, d)
#define BOOST_PP_REPEAT_3_187(m,d) BOOST_PP_REPEAT_3_186(m, d) m(4, 186, d)
#define BOOST_PP_REPEAT_3_188(m,d) BOOST_PP_REPEAT_3_187(m, d) m(4, 187, d)
#define BOOST_PP_REPEAT_3_189(m,d) BOOST_PP_REPEAT_3_188(m, d) m(4, 188, d)
#define BOOST_PP_REPEAT_3_190(m,d) BOOST_PP_REPEAT_3_189(m, d) m(4, 189, d)
#define BOOST_PP_REPEAT_3_191(m,d) BOOST_PP_REPEAT_3_190(m, d) m(4, 190, d)
#define BOOST_PP_REPEAT_3_192(m,d) BOOST_PP_REPEAT_3_191(m, d) m(4, 191, d)
#define BOOST_PP_REPEAT_3_193(m,d) BOOST_PP_REPEAT_3_192(m, d) m(4, 192, d)
#define BOOST_PP_REPEAT_3_194(m,d) BOOST_PP_REPEAT_3_193(m, d) m(4, 193, d)
#define BOOST_PP_REPEAT_3_195(m,d) BOOST_PP_REPEAT_3_194(m, d) m(4, 194, d)
#define BOOST_PP_REPEAT_3_196(m,d) BOOST_PP_REPEAT_3_195(m, d) m(4, 195, d)
#define BOOST_PP_REPEAT_3_197(m,d) BOOST_PP_REPEAT_3_196(m, d) m(4, 196, d)
#define BOOST_PP_REPEAT_3_198(m,d) BOOST_PP_REPEAT_3_197(m, d) m(4, 197, d)
#define BOOST_PP_REPEAT_3_199(m,d) BOOST_PP_REPEAT_3_198(m, d) m(4, 198, d)
#define BOOST_PP_REPEAT_3_200(m,d) BOOST_PP_REPEAT_3_199(m, d) m(4, 199, d)
#define BOOST_PP_REPEAT_3_201(m,d) BOOST_PP_REPEAT_3_200(m, d) m(4, 200, d)
#define BOOST_PP_REPEAT_3_202(m,d) BOOST_PP_REPEAT_3_201(m, d) m(4, 201, d)
#define BOOST_PP_REPEAT_3_203(m,d) BOOST_PP_REPEAT_3_202(m, d) m(4, 202, d)
#define BOOST_PP_REPEAT_3_204(m,d) BOOST_PP_REPEAT_3_203(m, d) m(4, 203, d)
#define BOOST_PP_REPEAT_3_205(m,d) BOOST_PP_REPEAT_3_204(m, d) m(4, 204, d)
#define BOOST_PP_REPEAT_3_206(m,d) BOOST_PP_REPEAT_3_205(m, d) m(4, 205, d)
#define BOOST_PP_REPEAT_3_207(m,d) BOOST_PP_REPEAT_3_206(m, d) m(4, 206, d)
#define BOOST_PP_REPEAT_3_208(m,d) BOOST_PP_REPEAT_3_207(m, d) m(4, 207, d)
#define BOOST_PP_REPEAT_3_209(m,d) BOOST_PP_REPEAT_3_208(m, d) m(4, 208, d)
#define BOOST_PP_REPEAT_3_210(m,d) BOOST_PP_REPEAT_3_209(m, d) m(4, 209, d)
#define BOOST_PP_REPEAT_3_211(m,d) BOOST_PP_REPEAT_3_210(m, d) m(4, 210, d)
#define BOOST_PP_REPEAT_3_212(m,d) BOOST_PP_REPEAT_3_211(m, d) m(4, 211, d)
#define BOOST_PP_REPEAT_3_213(m,d) BOOST_PP_REPEAT_3_212(m, d) m(4, 212, d)
#define BOOST_PP_REPEAT_3_214(m,d) BOOST_PP_REPEAT_3_213(m, d) m(4, 213, d)
#define BOOST_PP_REPEAT_3_215(m,d) BOOST_PP_REPEAT_3_214(m, d) m(4, 214, d)
#define BOOST_PP_REPEAT_3_216(m,d) BOOST_PP_REPEAT_3_215(m, d) m(4, 215, d)
#define BOOST_PP_REPEAT_3_217(m,d) BOOST_PP_REPEAT_3_216(m, d) m(4, 216, d)
#define BOOST_PP_REPEAT_3_218(m,d) BOOST_PP_REPEAT_3_217(m, d) m(4, 217, d)
#define BOOST_PP_REPEAT_3_219(m,d) BOOST_PP_REPEAT_3_218(m, d) m(4, 218, d)
#define BOOST_PP_REPEAT_3_220(m,d) BOOST_PP_REPEAT_3_219(m, d) m(4, 219, d)
#define BOOST_PP_REPEAT_3_221(m,d) BOOST_PP_REPEAT_3_220(m, d) m(4, 220, d)
#define BOOST_PP_REPEAT_3_222(m,d) BOOST_PP_REPEAT_3_221(m, d) m(4, 221, d)
#define BOOST_PP_REPEAT_3_223(m,d) BOOST_PP_REPEAT_3_222(m, d) m(4, 222, d)
#define BOOST_PP_REPEAT_3_224(m,d) BOOST_PP_REPEAT_3_223(m, d) m(4, 223, d)
#define BOOST_PP_REPEAT_3_225(m,d) BOOST_PP_REPEAT_3_224(m, d) m(4, 224, d)
#define BOOST_PP_REPEAT_3_226(m,d) BOOST_PP_REPEAT_3_225(m, d) m(4, 225, d)
#define BOOST_PP_REPEAT_3_227(m,d) BOOST_PP_REPEAT_3_226(m, d) m(4, 226, d)
#define BOOST_PP_REPEAT_3_228(m,d) BOOST_PP_REPEAT_3_227(m, d) m(4, 227, d)
#define BOOST_PP_REPEAT_3_229(m,d) BOOST_PP_REPEAT_3_228(m, d) m(4, 228, d)
#define BOOST_PP_REPEAT_3_230(m,d) BOOST_PP_REPEAT_3_229(m, d) m(4, 229, d)
#define BOOST_PP_REPEAT_3_231(m,d) BOOST_PP_REPEAT_3_230(m, d) m(4, 230, d)
#define BOOST_PP_REPEAT_3_232(m,d) BOOST_PP_REPEAT_3_231(m, d) m(4, 231, d)
#define BOOST_PP_REPEAT_3_233(m,d) BOOST_PP_REPEAT_3_232(m, d) m(4, 232, d)
#define BOOST_PP_REPEAT_3_234(m,d) BOOST_PP_REPEAT_3_233(m, d) m(4, 233, d)
#define BOOST_PP_REPEAT_3_235(m,d) BOOST_PP_REPEAT_3_234(m, d) m(4, 234, d)
#define BOOST_PP_REPEAT_3_236(m,d) BOOST_PP_REPEAT_3_235(m, d) m(4, 235, d)
#define BOOST_PP_REPEAT_3_237(m,d) BOOST_PP_REPEAT_3_236(m, d) m(4, 236, d)
#define BOOST_PP_REPEAT_3_238(m,d) BOOST_PP_REPEAT_3_237(m, d) m(4, 237, d)
#define BOOST_PP_REPEAT_3_239(m,d) BOOST_PP_REPEAT_3_238(m, d) m(4, 238, d)
#define BOOST_PP_REPEAT_3_240(m,d) BOOST_PP_REPEAT_3_239(m, d) m(4, 239, d)
#define BOOST_PP_REPEAT_3_241(m,d) BOOST_PP_REPEAT_3_240(m, d) m(4, 240, d)
#define BOOST_PP_REPEAT_3_242(m,d) BOOST_PP_REPEAT_3_241(m, d) m(4, 241, d)
#define BOOST_PP_REPEAT_3_243(m,d) BOOST_PP_REPEAT_3_242(m, d) m(4, 242, d)
#define BOOST_PP_REPEAT_3_244(m,d) BOOST_PP_REPEAT_3_243(m, d) m(4, 243, d)
#define BOOST_PP_REPEAT_3_245(m,d) BOOST_PP_REPEAT_3_244(m, d) m(4, 244, d)
#define BOOST_PP_REPEAT_3_246(m,d) BOOST_PP_REPEAT_3_245(m, d) m(4, 245, d)
#define BOOST_PP_REPEAT_3_247(m,d) BOOST_PP_REPEAT_3_246(m, d) m(4, 246, d)
#define BOOST_PP_REPEAT_3_248(m,d) BOOST_PP_REPEAT_3_247(m, d) m(4, 247, d)
#define BOOST_PP_REPEAT_3_249(m,d) BOOST_PP_REPEAT_3_248(m, d) m(4, 248, d)
#define BOOST_PP_REPEAT_3_250(m,d) BOOST_PP_REPEAT_3_249(m, d) m(4, 249, d)
#define BOOST_PP_REPEAT_3_251(m,d) BOOST_PP_REPEAT_3_250(m, d) m(4, 250, d)
#define BOOST_PP_REPEAT_3_252(m,d) BOOST_PP_REPEAT_3_251(m, d) m(4, 251, d)
#define BOOST_PP_REPEAT_3_253(m,d) BOOST_PP_REPEAT_3_252(m, d) m(4, 252, d)
#define BOOST_PP_REPEAT_3_254(m,d) BOOST_PP_REPEAT_3_253(m, d) m(4, 253, d)
#define BOOST_PP_REPEAT_3_255(m,d) BOOST_PP_REPEAT_3_254(m, d) m(4, 254, d)
#define BOOST_PP_REPEAT_3_256(m,d) BOOST_PP_REPEAT_3_255(m, d) m(4, 255, d)
#define BOOST_PREPROCESSOR_INC_HPP
#define BOOST_PREPROCESSOR_ARITHMETIC_INC_HPP
#define BOOST_PP_INC(x) BOOST_PP_INC_I(x)
#define BOOST_PP_INC_I(x) BOOST_PP_INC_ ## x
#define BOOST_PP_INC_0 1
#define BOOST_PP_INC_1 2
#define BOOST_PP_INC_2 3
#define BOOST_PP_INC_3 4
#define BOOST_PP_INC_4 5
#define BOOST_PP_INC_5 6
#define BOOST_PP_INC_6 7
#define BOOST_PP_INC_7 8
#define BOOST_PP_INC_8 9
#define BOOST_PP_INC_9 10
#define BOOST_PP_INC_10 11
#define BOOST_PP_INC_11 12
#define BOOST_PP_INC_12 13
#define BOOST_PP_INC_13 14
#define BOOST_PP_INC_14 15
#define BOOST_PP_INC_15 16
#define BOOST_PP_INC_16 17
#define BOOST_PP_INC_17 18
#define BOOST_PP_INC_18 19
#define BOOST_PP_INC_19 20
#define BOOST_PP_INC_20 21
#define BOOST_PP_INC_21 22
#define BOOST_PP_INC_22 23
#define BOOST_PP_INC_23 24
#define BOOST_PP_INC_24 25
#define BOOST_PP_INC_25 26
#define BOOST_PP_INC_26 27
#define BOOST_PP_INC_27 28
#define BOOST_PP_INC_28 29
#define BOOST_PP_INC_29 30
#define BOOST_PP_INC_30 31
#define BOOST_PP_INC_31 32
#define BOOST_PP_INC_32 33
#define BOOST_PP_INC_33 34
#define BOOST_PP_INC_34 35
#define BOOST_PP_INC_35 36
#define BOOST_PP_INC_36 37
#define BOOST_PP_INC_37 38
#define BOOST_PP_INC_38 39
#define BOOST_PP_INC_39 40
#define BOOST_PP_INC_40 41
#define BOOST_PP_INC_41 42
#define BOOST_PP_INC_42 43
#define BOOST_PP_INC_43 44
#define BOOST_PP_INC_44 45
#define BOOST_PP_INC_45 46
#define BOOST_PP_INC_46 47
#define BOOST_PP_INC_47 48
#define BOOST_PP_INC_48 49
#define BOOST_PP_INC_49 50
#define BOOST_PP_INC_50 51
#define BOOST_PP_INC_51 52
#define BOOST_PP_INC_52 53
#define BOOST_PP_INC_53 54
#define BOOST_PP_INC_54 55
#define BOOST_PP_INC_55 56
#define BOOST_PP_INC_56 57
#define BOOST_PP_INC_57 58
#define BOOST_PP_INC_58 59
#define BOOST_PP_INC_59 60
#define BOOST_PP_INC_60 61
#define BOOST_PP_INC_61 62
#define BOOST_PP_INC_62 63
#define BOOST_PP_INC_63 64
#define BOOST_PP_INC_64 65
#define BOOST_PP_INC_65 66
#define BOOST_PP_INC_66 67
#define BOOST_PP_INC_67 68
#define BOOST_PP_INC_68 69
#define BOOST_PP_INC_69 70
#define BOOST_PP_INC_70 71
#define BOOST_PP_INC_71 72
#define BOOST_PP_INC_72 73
#define BOOST_PP_INC_73 74
#define BOOST_PP_INC_74 75
#define BOOST_PP_INC_75 76
#define BOOST_PP_INC_76 77
#define BOOST_PP_INC_77 78
#define BOOST_PP_INC_78 79
#define BOOST_PP_INC_79 80
#define BOOST_PP_INC_80 81
#define BOOST_PP_INC_81 82
#define BOOST_PP_INC_82 83
#define BOOST_PP_INC_83 84
#define BOOST_PP_INC_84 85
#define BOOST_PP_INC_85 86
#define BOOST_PP_INC_86 87
#define BOOST_PP_INC_87 88
#define BOOST_PP_INC_88 89
#define BOOST_PP_INC_89 90
#define BOOST_PP_INC_90 91
#define BOOST_PP_INC_91 92
#define BOOST_PP_INC_92 93
#define BOOST_PP_INC_93 94
#define BOOST_PP_INC_94 95
#define BOOST_PP_INC_95 96
#define BOOST_PP_INC_96 97
#define BOOST_PP_INC_97 98
#define BOOST_PP_INC_98 99
#define BOOST_PP_INC_99 100
#define BOOST_PP_INC_100 101
#define BOOST_PP_INC_101 102
#define BOOST_PP_INC_102 103
#define BOOST_PP_INC_103 104
#define BOOST_PP_INC_104 105
#define BOOST_PP_INC_105 106
#define BOOST_PP_INC_106 107
#define BOOST_PP_INC_107 108
#define BOOST_PP_INC_108 109
#define BOOST_PP_INC_109 110
#define BOOST_PP_INC_110 111
#define BOOST_PP_INC_111 112
#define BOOST_PP_INC_112 113
#define BOOST_PP_INC_113 114
#define BOOST_PP_INC_114 115
#define BOOST_PP_INC_115 116
#define BOOST_PP_INC_116 117
#define BOOST_PP_INC_117 118
#define BOOST_PP_INC_118 119
#define BOOST_PP_INC_119 120
#define BOOST_PP_INC_120 121
#define BOOST_PP_INC_121 122
#define BOOST_PP_INC_122 123
#define BOOST_PP_INC_123 124
#define BOOST_PP_INC_124 125
#define BOOST_PP_INC_125 126
#define BOOST_PP_INC_126 127
#define BOOST_PP_INC_127 128
#define BOOST_PP_INC_128 129
#define BOOST_PP_INC_129 130
#define BOOST_PP_INC_130 131
#define BOOST_PP_INC_131 132
#define BOOST_PP_INC_132 133
#define BOOST_PP_INC_133 134
#define BOOST_PP_INC_134 135
#define BOOST_PP_INC_135 136
#define BOOST_PP_INC_136 137
#define BOOST_PP_INC_137 138
#define BOOST_PP_INC_138 139
#define BOOST_PP_INC_139 140
#define BOOST_PP_INC_140 141
#define BOOST_PP_INC_141 142
#define BOOST_PP_INC_142 143
#define BOOST_PP_INC_143 144
#define BOOST_PP_INC_144 145
#define BOOST_PP_INC_145 146
#define BOOST_PP_INC_146 147
#define BOOST_PP_INC_147 148
#define BOOST_PP_INC_148 149
#define BOOST_PP_INC_149 150
#define BOOST_PP_INC_150 151
#define BOOST_PP_INC_151 152
#define BOOST_PP_INC_152 153
#define BOOST_PP_INC_153 154
#define BOOST_PP_INC_154 155
#define BOOST_PP_INC_155 156
#define BOOST_PP_INC_156 157
#define BOOST_PP_INC_157 158
#define BOOST_PP_INC_158 159
#define BOOST_PP_INC_159 160
#define BOOST_PP_INC_160 161
#define BOOST_PP_INC_161 162
#define BOOST_PP_INC_162 163
#define BOOST_PP_INC_163 164
#define BOOST_PP_INC_164 165
#define BOOST_PP_INC_165 166
#define BOOST_PP_INC_166 167
#define BOOST_PP_INC_167 168
#define BOOST_PP_INC_168 169
#define BOOST_PP_INC_169 170
#define BOOST_PP_INC_170 171
#define BOOST_PP_INC_171 172
#define BOOST_PP_INC_172 173
#define BOOST_PP_INC_173 174
#define BOOST_PP_INC_174 175
#define BOOST_PP_INC_175 176
#define BOOST_PP_INC_176 177
#define BOOST_PP_INC_177 178
#define BOOST_PP_INC_178 179
#define BOOST_PP_INC_179 180
#define BOOST_PP_INC_180 181
#define BOOST_PP_INC_181 182
#define BOOST_PP_INC_182 183
#define BOOST_PP_INC_183 184
#define BOOST_PP_INC_184 185
#define BOOST_PP_INC_185 186
#define BOOST_PP_INC_186 187
#define BOOST_PP_INC_187 188
#define BOOST_PP_INC_188 189
#define BOOST_PP_INC_189 190
#define BOOST_PP_INC_190 191
#define BOOST_PP_INC_191 192
#define BOOST_PP_INC_192 193
#define BOOST_PP_INC_193 194
#define BOOST_PP_INC_194 195
#define BOOST_PP_INC_195 196
#define BOOST_PP_INC_196 197
#define BOOST_PP_INC_197 198
#define BOOST_PP_INC_198 199
#define BOOST_PP_INC_199 200
#define BOOST_PP_INC_200 201
#define BOOST_PP_INC_201 202
#define BOOST_PP_INC_202 203
#define BOOST_PP_INC_203 204
#define BOOST_PP_INC_204 205
#define BOOST_PP_INC_205 206
#define BOOST_PP_INC_206 207
#define BOOST_PP_INC_207 208
#define BOOST_PP_INC_208 209
#define BOOST_PP_INC_209 210
#define BOOST_PP_INC_210 211
#define BOOST_PP_INC_211 212
#define BOOST_PP_INC_212 213
#define BOOST_PP_INC_213 214
#define BOOST_PP_INC_214 215
#define BOOST_PP_INC_215 216
#define BOOST_PP_INC_216 217
#define BOOST_PP_INC_217 218
#define BOOST_PP_INC_218 219
#define BOOST_PP_INC_219 220
#define BOOST_PP_INC_220 221
#define BOOST_PP_INC_221 222
#define BOOST_PP_INC_222 223
#define BOOST_PP_INC_223 224
#define BOOST_PP_INC_224 225
#define BOOST_PP_INC_225 226
#define BOOST_PP_INC_226 227
#define BOOST_PP_INC_227 228
#define BOOST_PP_INC_228 229
#define BOOST_PP_INC_229 230
#define BOOST_PP_INC_230 231
#define BOOST_PP_INC_231 232
#define BOOST_PP_INC_232 233
#define BOOST_PP_INC_233 234
#define BOOST_PP_INC_234 235
#define BOOST_PP_INC_235 236
#define BOOST_PP_INC_236 237
#define BOOST_PP_INC_237 238
#define BOOST_PP_INC_238 239
#define BOOST_PP_INC_239 240
#define BOOST_PP_INC_240 241
#define BOOST_PP_INC_241 242
#define BOOST_PP_INC_242 243
#define BOOST_PP_INC_243 244
#define BOOST_PP_INC_244 245
#define BOOST_PP_INC_245 246
#define BOOST_PP_INC_246 247
#define BOOST_PP_INC_247 248
#define BOOST_PP_INC_248 249
#define BOOST_PP_INC_249 250
#define BOOST_PP_INC_250 251
#define BOOST_PP_INC_251 252
#define BOOST_PP_INC_252 253
#define BOOST_PP_INC_253 254
#define BOOST_PP_INC_254 255
#define BOOST_PP_INC_255 256
#define BOOST_PP_INC_256 256
#define BOOST_MPL_PP_AUX_PARAM_FUNC(unused,i,param) BOOST_PP_COMMA_IF(i) BOOST_PP_CAT(param, BOOST_PP_INC(i))
#define BOOST_MPL_PP_PARAMS(n,param) BOOST_PP_REPEAT( n , BOOST_MPL_PP_AUX_PARAM_FUNC , param )
#define BOOST_MPL_AUX_PREPROCESSOR_ENUM_HPP_INCLUDED
#define BOOST_MPL_PP_AUX_ENUM_FUNC(unused,i,param) BOOST_PP_COMMA_IF(i) param
#define BOOST_MPL_PP_ENUM(n,param) BOOST_PP_REPEAT( n , BOOST_MPL_PP_AUX_ENUM_FUNC , param )
#define BOOST_MPL_AUX_PREPROCESSOR_DEF_PARAMS_TAIL_HPP_INCLUDED
#define BOOST_MPL_LIMITS_ARITY_HPP_INCLUDED
#define BOOST_MPL_LIMIT_METAFUNCTION_ARITY 5
#define BOOST_PREPROCESSOR_LOGICAL_AND_HPP
#define BOOST_PREPROCESSOR_LOGICAL_BITAND_HPP
#define BOOST_PP_BITAND(x,y) BOOST_PP_BITAND_I(x, y)
#define BOOST_PP_BITAND_I(x,y) BOOST_PP_BITAND_ ## x ## y
#define BOOST_PP_BITAND_00 0
#define BOOST_PP_BITAND_01 0
#define BOOST_PP_BITAND_10 0
#define BOOST_PP_BITAND_11 1
#define BOOST_PP_AND(p,q) BOOST_PP_BITAND(BOOST_PP_BOOL(p), BOOST_PP_BOOL(q))
#define BOOST_PREPROCESSOR_IDENTITY_HPP
#define BOOST_PREPROCESSOR_FACILITIES_IDENTITY_HPP
#define BOOST_PP_IDENTITY(item) item BOOST_PP_EMPTY
#define BOOST_PREPROCESSOR_EMPTY_HPP
#define BOOST_PREPROCESSOR_ARITHMETIC_ADD_HPP
#define BOOST_PREPROCESSOR_ARITHMETIC_DEC_HPP
#define BOOST_PP_DEC(x) BOOST_PP_DEC_I(x)
#define BOOST_PP_DEC_I(x) BOOST_PP_DEC_ ## x
#define BOOST_PP_DEC_0 0
#define BOOST_PP_DEC_1 0
#define BOOST_PP_DEC_2 1
#define BOOST_PP_DEC_3 2
#define BOOST_PP_DEC_4 3
#define BOOST_PP_DEC_5 4
#define BOOST_PP_DEC_6 5
#define BOOST_PP_DEC_7 6
#define BOOST_PP_DEC_8 7
#define BOOST_PP_DEC_9 8
#define BOOST_PP_DEC_10 9
#define BOOST_PP_DEC_11 10
#define BOOST_PP_DEC_12 11
#define BOOST_PP_DEC_13 12
#define BOOST_PP_DEC_14 13
#define BOOST_PP_DEC_15 14
#define BOOST_PP_DEC_16 15
#define BOOST_PP_DEC_17 16
#define BOOST_PP_DEC_18 17
#define BOOST_PP_DEC_19 18
#define BOOST_PP_DEC_20 19
#define BOOST_PP_DEC_21 20
#define BOOST_PP_DEC_22 21
#define BOOST_PP_DEC_23 22
#define BOOST_PP_DEC_24 23
#define BOOST_PP_DEC_25 24
#define BOOST_PP_DEC_26 25
#define BOOST_PP_DEC_27 26
#define BOOST_PP_DEC_28 27
#define BOOST_PP_DEC_29 28
#define BOOST_PP_DEC_30 29
#define BOOST_PP_DEC_31 30
#define BOOST_PP_DEC_32 31
#define BOOST_PP_DEC_33 32
#define BOOST_PP_DEC_34 33
#define BOOST_PP_DEC_35 34
#define BOOST_PP_DEC_36 35
#define BOOST_PP_DEC_37 36
#define BOOST_PP_DEC_38 37
#define BOOST_PP_DEC_39 38
#define BOOST_PP_DEC_40 39
#define BOOST_PP_DEC_41 40
#define BOOST_PP_DEC_42 41
#define BOOST_PP_DEC_43 42
#define BOOST_PP_DEC_44 43
#define BOOST_PP_DEC_45 44
#define BOOST_PP_DEC_46 45
#define BOOST_PP_DEC_47 46
#define BOOST_PP_DEC_48 47
#define BOOST_PP_DEC_49 48
#define BOOST_PP_DEC_50 49
#define BOOST_PP_DEC_51 50
#define BOOST_PP_DEC_52 51
#define BOOST_PP_DEC_53 52
#define BOOST_PP_DEC_54 53
#define BOOST_PP_DEC_55 54
#define BOOST_PP_DEC_56 55
#define BOOST_PP_DEC_57 56
#define BOOST_PP_DEC_58 57
#define BOOST_PP_DEC_59 58
#define BOOST_PP_DEC_60 59
#define BOOST_PP_DEC_61 60
#define BOOST_PP_DEC_62 61
#define BOOST_PP_DEC_63 62
#define BOOST_PP_DEC_64 63
#define BOOST_PP_DEC_65 64
#define BOOST_PP_DEC_66 65
#define BOOST_PP_DEC_67 66
#define BOOST_PP_DEC_68 67
#define BOOST_PP_DEC_69 68
#define BOOST_PP_DEC_70 69
#define BOOST_PP_DEC_71 70
#define BOOST_PP_DEC_72 71
#define BOOST_PP_DEC_73 72
#define BOOST_PP_DEC_74 73
#define BOOST_PP_DEC_75 74
#define BOOST_PP_DEC_76 75
#define BOOST_PP_DEC_77 76
#define BOOST_PP_DEC_78 77
#define BOOST_PP_DEC_79 78
#define BOOST_PP_DEC_80 79
#define BOOST_PP_DEC_81 80
#define BOOST_PP_DEC_82 81
#define BOOST_PP_DEC_83 82
#define BOOST_PP_DEC_84 83
#define BOOST_PP_DEC_85 84
#define BOOST_PP_DEC_86 85
#define BOOST_PP_DEC_87 86
#define BOOST_PP_DEC_88 87
#define BOOST_PP_DEC_89 88
#define BOOST_PP_DEC_90 89
#define BOOST_PP_DEC_91 90
#define BOOST_PP_DEC_92 91
#define BOOST_PP_DEC_93 92
#define BOOST_PP_DEC_94 93
#define BOOST_PP_DEC_95 94
#define BOOST_PP_DEC_96 95
#define BOOST_PP_DEC_97 96
#define BOOST_PP_DEC_98 97
#define BOOST_PP_DEC_99 98
#define BOOST_PP_DEC_100 99
#define BOOST_PP_DEC_101 100
#define BOOST_PP_DEC_102 101
#define BOOST_PP_DEC_103 102
#define BOOST_PP_DEC_104 103
#define BOOST_PP_DEC_105 104
#define BOOST_PP_DEC_106 105
#define BOOST_PP_DEC_107 106
#define BOOST_PP_DEC_108 107
#define BOOST_PP_DEC_109 108
#define BOOST_PP_DEC_110 109
#define BOOST_PP_DEC_111 110
#define BOOST_PP_DEC_112 111
#define BOOST_PP_DEC_113 112
#define BOOST_PP_DEC_114 113
#define BOOST_PP_DEC_115 114
#define BOOST_PP_DEC_116 115
#define BOOST_PP_DEC_117 116
#define BOOST_PP_DEC_118 117
#define BOOST_PP_DEC_119 118
#define BOOST_PP_DEC_120 119
#define BOOST_PP_DEC_121 120
#define BOOST_PP_DEC_122 121
#define BOOST_PP_DEC_123 122
#define BOOST_PP_DEC_124 123
#define BOOST_PP_DEC_125 124
#define BOOST_PP_DEC_126 125
#define BOOST_PP_DEC_127 126
#define BOOST_PP_DEC_128 127
#define BOOST_PP_DEC_129 128
#define BOOST_PP_DEC_130 129
#define BOOST_PP_DEC_131 130
#define BOOST_PP_DEC_132 131
#define BOOST_PP_DEC_133 132
#define BOOST_PP_DEC_134 133
#define BOOST_PP_DEC_135 134
#define BOOST_PP_DEC_136 135
#define BOOST_PP_DEC_137 136
#define BOOST_PP_DEC_138 137
#define BOOST_PP_DEC_139 138
#define BOOST_PP_DEC_140 139
#define BOOST_PP_DEC_141 140
#define BOOST_PP_DEC_142 141
#define BOOST_PP_DEC_143 142
#define BOOST_PP_DEC_144 143
#define BOOST_PP_DEC_145 144
#define BOOST_PP_DEC_146 145
#define BOOST_PP_DEC_147 146
#define BOOST_PP_DEC_148 147
#define BOOST_PP_DEC_149 148
#define BOOST_PP_DEC_150 149
#define BOOST_PP_DEC_151 150
#define BOOST_PP_DEC_152 151
#define BOOST_PP_DEC_153 152
#define BOOST_PP_DEC_154 153
#define BOOST_PP_DEC_155 154
#define BOOST_PP_DEC_156 155
#define BOOST_PP_DEC_157 156
#define BOOST_PP_DEC_158 157
#define BOOST_PP_DEC_159 158
#define BOOST_PP_DEC_160 159
#define BOOST_PP_DEC_161 160
#define BOOST_PP_DEC_162 161
#define BOOST_PP_DEC_163 162
#define BOOST_PP_DEC_164 163
#define BOOST_PP_DEC_165 164
#define BOOST_PP_DEC_166 165
#define BOOST_PP_DEC_167 166
#define BOOST_PP_DEC_168 167
#define BOOST_PP_DEC_169 168
#define BOOST_PP_DEC_170 169
#define BOOST_PP_DEC_171 170
#define BOOST_PP_DEC_172 171
#define BOOST_PP_DEC_173 172
#define BOOST_PP_DEC_174 173
#define BOOST_PP_DEC_175 174
#define BOOST_PP_DEC_176 175
#define BOOST_PP_DEC_177 176
#define BOOST_PP_DEC_178 177
#define BOOST_PP_DEC_179 178
#define BOOST_PP_DEC_180 179
#define BOOST_PP_DEC_181 180
#define BOOST_PP_DEC_182 181
#define BOOST_PP_DEC_183 182
#define BOOST_PP_DEC_184 183
#define BOOST_PP_DEC_185 184
#define BOOST_PP_DEC_186 185
#define BOOST_PP_DEC_187 186
#define BOOST_PP_DEC_188 187
#define BOOST_PP_DEC_189 188
#define BOOST_PP_DEC_190 189
#define BOOST_PP_DEC_191 190
#define BOOST_PP_DEC_192 191
#define BOOST_PP_DEC_193 192
#define BOOST_PP_DEC_194 193
#define BOOST_PP_DEC_195 194
#define BOOST_PP_DEC_196 195
#define BOOST_PP_DEC_197 196
#define BOOST_PP_DEC_198 197
#define BOOST_PP_DEC_199 198
#define BOOST_PP_DEC_200 199
#define BOOST_PP_DEC_201 200
#define BOOST_PP_DEC_202 201
#define BOOST_PP_DEC_203 202
#define BOOST_PP_DEC_204 203
#define BOOST_PP_DEC_205 204
#define BOOST_PP_DEC_206 205
#define BOOST_PP_DEC_207 206
#define BOOST_PP_DEC_208 207
#define BOOST_PP_DEC_209 208
#define BOOST_PP_DEC_210 209
#define BOOST_PP_DEC_211 210
#define BOOST_PP_DEC_212 211
#define BOOST_PP_DEC_213 212
#define BOOST_PP_DEC_214 213
#define BOOST_PP_DEC_215 214
#define BOOST_PP_DEC_216 215
#define BOOST_PP_DEC_217 216
#define BOOST_PP_DEC_218 217
#define BOOST_PP_DEC_219 218
#define BOOST_PP_DEC_220 219
#define BOOST_PP_DEC_221 220
#define BOOST_PP_DEC_222 221
#define BOOST_PP_DEC_223 222
#define BOOST_PP_DEC_224 223
#define BOOST_PP_DEC_225 224
#define BOOST_PP_DEC_226 225
#define BOOST_PP_DEC_227 226
#define BOOST_PP_DEC_228 227
#define BOOST_PP_DEC_229 228
#define BOOST_PP_DEC_230 229
#define BOOST_PP_DEC_231 230
#define BOOST_PP_DEC_232 231
#define BOOST_PP_DEC_233 232
#define BOOST_PP_DEC_234 233
#define BOOST_PP_DEC_235 234
#define BOOST_PP_DEC_236 235
#define BOOST_PP_DEC_237 236
#define BOOST_PP_DEC_238 237
#define BOOST_PP_DEC_239 238
#define BOOST_PP_DEC_240 239
#define BOOST_PP_DEC_241 240
#define BOOST_PP_DEC_242 241
#define BOOST_PP_DEC_243 242
#define BOOST_PP_DEC_244 243
#define BOOST_PP_DEC_245 244
#define BOOST_PP_DEC_246 245
#define BOOST_PP_DEC_247 246
#define BOOST_PP_DEC_248 247
#define BOOST_PP_DEC_249 248
#define BOOST_PP_DEC_250 249
#define BOOST_PP_DEC_251 250
#define BOOST_PP_DEC_252 251
#define BOOST_PP_DEC_253 252
#define BOOST_PP_DEC_254 253
#define BOOST_PP_DEC_255 254
#define BOOST_PP_DEC_256 255
#define BOOST_PREPROCESSOR_CONTROL_WHILE_HPP
#define BOOST_PREPROCESSOR_LIST_FOLD_LEFT_HPP
#define BOOST_PP_LIST_FOLD_LEFT BOOST_PP_CAT(BOOST_PP_LIST_FOLD_LEFT_, BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256))
#define BOOST_PP_LIST_FOLD_LEFT_257(o,s,l) BOOST_PP_ERROR(0x0004)
#define BOOST_PP_LIST_FOLD_LEFT_D(d,o,s,l) BOOST_PP_LIST_FOLD_LEFT_ ## d(o, s, l)
#define BOOST_PP_LIST_FOLD_LEFT_2ND BOOST_PP_LIST_FOLD_LEFT
#define BOOST_PP_LIST_FOLD_LEFT_2ND_D BOOST_PP_LIST_FOLD_LEFT_D
#define BOOST_PREPROCESSOR_LIST_DETAIL_FOLD_LEFT_HPP
#define BOOST_PREPROCESSOR_CONTROL_EXPR_IIF_HPP
#define BOOST_PP_EXPR_IIF(bit,expr) BOOST_PP_EXPR_IIF_I(bit, expr)
#define BOOST_PP_EXPR_IIF_I(bit,expr) BOOST_PP_EXPR_IIF_ ## bit(expr)
#define BOOST_PP_EXPR_IIF_0(expr)
#define BOOST_PP_EXPR_IIF_1(expr) expr
#define BOOST_PREPROCESSOR_LIST_ADT_HPP
#define BOOST_PREPROCESSOR_DETAIL_IS_BINARY_HPP
#define BOOST_PREPROCESSOR_DETAIL_CHECK_HPP
#define BOOST_PP_CHECK(x,type) BOOST_PP_CHECK_D(x, type)
#define BOOST_PP_CHECK_D(x,type) BOOST_PP_CHECK_1(BOOST_PP_CAT(BOOST_PP_CHECK_RESULT_, type x))
#define BOOST_PP_CHECK_1(chk) BOOST_PP_CHECK_2(chk)
#define BOOST_PP_CHECK_2(res,_) res
#define BOOST_PP_CHECK_RESULT_1 1, BOOST_PP_NIL
#define BOOST_PP_IS_BINARY(x) BOOST_PP_CHECK(x, BOOST_PP_IS_BINARY_CHECK)
#define BOOST_PP_IS_BINARY_CHECK(a,b) 1
#define BOOST_PP_CHECK_RESULT_BOOST_PP_IS_BINARY_CHECK 0, BOOST_PP_NIL
#define BOOST_PREPROCESSOR_LOGICAL_COMPL_HPP
#define BOOST_PP_COMPL(x) BOOST_PP_COMPL_I(x)
#define BOOST_PP_COMPL_I(x) BOOST_PP_COMPL_ ## x
#define BOOST_PP_COMPL_0 1
#define BOOST_PP_COMPL_1 0
#define BOOST_PP_LIST_CONS(head,tail) (head, tail)
#define BOOST_PP_LIST_NIL BOOST_PP_NIL
#define BOOST_PP_LIST_FIRST(list) BOOST_PP_LIST_FIRST_D(list)
#define BOOST_PP_LIST_FIRST_D(list) BOOST_PP_LIST_FIRST_I list
#define BOOST_PP_LIST_FIRST_I(head,tail) head
#define BOOST_PP_LIST_REST(list) BOOST_PP_LIST_REST_D(list)
#define BOOST_PP_LIST_REST_D(list) BOOST_PP_LIST_REST_I list
#define BOOST_PP_LIST_REST_I(head,tail) tail
#define BOOST_PP_LIST_IS_CONS(list) BOOST_PP_IS_BINARY(list)
#define BOOST_PP_LIST_IS_NIL(list) BOOST_PP_COMPL(BOOST_PP_IS_BINARY(list))
#define BOOST_PP_LIST_FOLD_LEFT_1(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_2, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(2, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_2(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_3, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(3, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_3(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_4, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(4, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_4(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_5, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(5, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_5(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_6, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(6, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_6(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_7, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(7, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_7(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_8, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(8, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_8(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_9, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(9, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_9(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_10, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(10, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_10(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_11, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(11, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_11(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_12, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(12, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_12(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_13, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(13, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_13(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_14, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(14, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_14(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_15, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(15, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_15(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_16, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(16, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_16(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_17, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(17, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_17(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_18, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(18, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_18(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_19, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(19, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_19(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_20, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(20, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_20(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_21, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(21, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_21(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_22, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(22, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_22(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_23, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(23, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_23(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_24, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(24, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_24(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_25, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(25, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_25(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_26, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(26, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_26(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_27, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(27, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_27(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_28, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(28, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_28(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_29, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(29, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_29(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_30, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(30, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_30(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_31, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(31, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_31(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_32, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(32, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_32(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_33, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(33, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_33(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_34, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(34, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_34(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_35, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(35, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_35(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_36, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(36, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_36(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_37, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(37, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_37(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_38, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(38, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_38(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_39, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(39, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_39(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_40, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(40, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_40(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_41, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(41, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_41(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_42, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(42, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_42(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_43, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(43, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_43(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_44, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(44, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_44(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_45, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(45, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_45(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_46, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(46, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_46(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_47, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(47, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_47(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_48, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(48, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_48(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_49, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(49, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_49(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_50, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(50, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_50(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_51, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(51, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_51(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_52, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(52, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_52(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_53, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(53, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_53(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_54, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(54, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_54(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_55, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(55, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_55(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_56, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(56, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_56(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_57, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(57, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_57(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_58, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(58, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_58(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_59, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(59, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_59(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_60, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(60, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_60(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_61, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(61, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_61(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_62, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(62, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_62(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_63, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(63, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_63(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_64, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(64, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_64(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_65, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(65, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_65(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_66, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(66, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_66(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_67, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(67, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_67(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_68, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(68, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_68(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_69, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(69, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_69(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_70, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(70, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_70(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_71, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(71, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_71(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_72, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(72, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_72(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_73, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(73, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_73(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_74, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(74, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_74(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_75, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(75, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_75(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_76, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(76, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_76(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_77, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(77, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_77(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_78, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(78, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_78(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_79, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(79, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_79(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_80, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(80, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_80(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_81, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(81, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_81(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_82, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(82, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_82(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_83, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(83, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_83(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_84, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(84, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_84(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_85, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(85, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_85(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_86, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(86, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_86(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_87, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(87, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_87(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_88, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(88, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_88(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_89, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(89, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_89(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_90, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(90, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_90(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_91, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(91, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_91(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_92, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(92, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_92(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_93, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(93, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_93(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_94, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(94, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_94(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_95, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(95, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_95(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_96, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(96, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_96(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_97, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(97, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_97(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_98, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(98, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_98(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_99, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(99, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_99(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_100, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(100, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_100(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_101, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(101, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_101(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_102, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(102, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_102(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_103, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(103, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_103(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_104, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(104, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_104(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_105, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(105, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_105(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_106, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(106, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_106(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_107, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(107, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_107(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_108, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(108, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_108(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_109, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(109, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_109(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_110, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(110, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_110(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_111, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(111, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_111(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_112, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(112, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_112(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_113, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(113, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_113(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_114, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(114, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_114(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_115, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(115, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_115(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_116, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(116, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_116(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_117, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(117, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_117(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_118, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(118, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_118(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_119, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(119, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_119(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_120, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(120, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_120(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_121, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(121, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_121(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_122, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(122, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_122(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_123, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(123, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_123(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_124, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(124, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_124(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_125, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(125, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_125(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_126, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(126, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_126(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_127, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(127, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_127(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_128, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(128, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_128(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_129, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(129, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_129(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_130, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(130, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_130(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_131, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(131, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_131(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_132, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(132, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_132(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_133, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(133, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_133(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_134, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(134, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_134(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_135, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(135, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_135(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_136, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(136, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_136(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_137, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(137, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_137(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_138, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(138, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_138(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_139, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(139, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_139(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_140, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(140, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_140(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_141, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(141, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_141(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_142, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(142, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_142(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_143, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(143, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_143(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_144, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(144, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_144(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_145, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(145, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_145(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_146, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(146, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_146(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_147, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(147, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_147(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_148, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(148, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_148(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_149, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(149, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_149(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_150, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(150, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_150(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_151, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(151, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_151(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_152, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(152, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_152(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_153, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(153, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_153(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_154, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(154, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_154(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_155, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(155, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_155(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_156, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(156, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_156(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_157, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(157, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_157(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_158, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(158, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_158(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_159, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(159, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_159(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_160, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(160, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_160(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_161, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(161, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_161(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_162, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(162, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_162(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_163, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(163, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_163(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_164, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(164, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_164(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_165, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(165, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_165(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_166, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(166, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_166(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_167, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(167, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_167(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_168, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(168, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_168(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_169, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(169, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_169(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_170, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(170, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_170(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_171, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(171, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_171(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_172, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(172, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_172(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_173, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(173, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_173(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_174, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(174, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_174(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_175, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(175, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_175(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_176, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(176, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_176(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_177, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(177, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_177(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_178, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(178, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_178(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_179, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(179, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_179(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_180, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(180, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_180(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_181, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(181, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_181(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_182, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(182, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_182(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_183, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(183, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_183(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_184, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(184, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_184(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_185, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(185, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_185(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_186, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(186, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_186(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_187, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(187, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_187(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_188, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(188, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_188(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_189, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(189, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_189(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_190, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(190, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_190(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_191, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(191, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_191(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_192, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(192, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_192(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_193, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(193, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_193(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_194, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(194, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_194(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_195, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(195, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_195(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_196, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(196, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_196(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_197, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(197, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_197(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_198, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(198, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_198(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_199, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(199, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_199(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_200, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(200, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_200(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_201, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(201, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_201(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_202, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(202, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_202(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_203, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(203, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_203(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_204, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(204, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_204(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_205, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(205, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_205(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_206, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(206, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_206(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_207, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(207, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_207(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_208, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(208, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_208(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_209, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(209, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_209(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_210, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(210, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_210(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_211, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(211, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_211(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_212, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(212, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_212(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_213, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(213, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_213(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_214, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(214, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_214(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_215, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(215, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_215(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_216, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(216, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_216(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_217, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(217, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_217(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_218, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(218, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_218(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_219, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(219, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_219(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_220, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(220, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_220(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_221, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(221, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_221(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_222, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(222, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_222(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_223, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(223, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_223(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_224, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(224, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_224(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_225, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(225, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_225(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_226, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(226, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_226(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_227, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(227, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_227(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_228, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(228, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_228(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_229, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(229, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_229(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_230, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(230, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_230(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_231, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(231, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_231(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_232, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(232, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_232(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_233, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(233, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_233(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_234, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(234, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_234(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_235, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(235, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_235(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_236, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(236, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_236(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_237, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(237, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_237(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_238, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(238, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_238(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_239, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(239, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_239(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_240, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(240, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_240(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_241, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(241, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_241(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_242, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(242, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_242(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_243, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(243, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_243(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_244, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(244, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_244(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_245, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(245, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_245(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_246, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(246, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_246(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_247, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(247, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_247(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_248, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(248, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_248(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_249, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(249, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_249(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_250, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(250, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_250(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_251, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(251, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_251(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_252, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(252, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_252(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_253, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(253, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_253(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_254, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(254, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_254(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_255, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(255, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_255(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_256, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(256, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_256(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_257, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(257, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_NIL 1
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_1(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_2(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_3(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_4(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_5(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_6(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_7(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_8(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_9(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_10(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_11(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_12(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_13(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_14(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_15(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_16(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_17(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_18(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_19(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_20(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_21(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_22(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_23(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_24(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_25(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_26(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_27(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_28(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_29(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_30(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_31(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_32(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_33(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_34(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_35(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_36(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_37(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_38(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_39(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_40(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_41(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_42(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_43(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_44(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_45(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_46(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_47(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_48(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_49(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_50(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_51(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_52(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_53(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_54(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_55(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_56(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_57(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_58(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_59(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_60(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_61(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_62(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_63(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_64(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_65(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_66(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_67(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_68(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_69(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_70(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_71(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_72(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_73(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_74(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_75(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_76(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_77(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_78(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_79(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_80(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_81(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_82(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_83(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_84(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_85(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_86(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_87(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_88(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_89(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_90(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_91(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_92(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_93(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_94(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_95(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_96(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_97(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_98(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_99(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_100(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_101(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_102(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_103(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_104(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_105(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_106(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_107(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_108(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_109(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_110(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_111(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_112(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_113(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_114(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_115(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_116(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_117(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_118(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_119(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_120(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_121(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_122(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_123(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_124(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_125(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_126(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_127(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_128(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_129(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_130(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_131(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_132(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_133(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_134(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_135(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_136(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_137(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_138(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_139(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_140(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_141(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_142(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_143(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_144(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_145(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_146(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_147(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_148(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_149(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_150(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_151(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_152(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_153(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_154(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_155(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_156(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_157(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_158(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_159(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_160(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_161(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_162(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_163(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_164(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_165(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_166(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_167(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_168(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_169(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_170(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_171(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_172(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_173(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_174(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_175(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_176(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_177(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_178(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_179(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_180(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_181(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_182(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_183(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_184(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_185(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_186(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_187(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_188(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_189(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_190(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_191(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_192(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_193(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_194(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_195(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_196(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_197(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_198(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_199(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_200(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_201(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_202(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_203(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_204(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_205(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_206(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_207(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_208(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_209(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_210(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_211(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_212(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_213(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_214(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_215(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_216(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_217(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_218(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_219(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_220(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_221(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_222(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_223(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_224(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_225(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_226(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_227(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_228(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_229(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_230(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_231(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_232(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_233(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_234(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_235(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_236(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_237(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_238(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_239(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_240(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_241(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_242(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_243(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_244(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_245(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_246(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_247(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_248(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_249(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_250(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_251(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_252(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_253(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_254(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_255(o,s,l) 0
#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_256(o,s,l) 0
#define BOOST_PREPROCESSOR_LIST_FOLD_RIGHT_HPP
#define BOOST_PP_LIST_FOLD_RIGHT BOOST_PP_CAT(BOOST_PP_LIST_FOLD_RIGHT_, BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256))
#define BOOST_PP_LIST_FOLD_RIGHT_257(o,s,l) BOOST_PP_ERROR(0x0004)
#define BOOST_PP_LIST_FOLD_RIGHT_D(d,o,s,l) BOOST_PP_LIST_FOLD_RIGHT_ ## d(o, s, l)
#define BOOST_PP_LIST_FOLD_RIGHT_2ND BOOST_PP_LIST_FOLD_RIGHT
#define BOOST_PP_LIST_FOLD_RIGHT_2ND_D BOOST_PP_LIST_FOLD_RIGHT_D
#define BOOST_PREPROCESSOR_LIST_DETAIL_FOLD_RIGHT_HPP
#define BOOST_PREPROCESSOR_LIST_REVERSE_HPP
#define BOOST_PP_LIST_REVERSE(list) BOOST_PP_LIST_FOLD_LEFT(BOOST_PP_LIST_REVERSE_O, BOOST_PP_NIL, list)
#define BOOST_PP_LIST_REVERSE_O(d,s,x) (x, s)
#define BOOST_PP_LIST_REVERSE_D(d,list) BOOST_PP_LIST_FOLD_LEFT_ ## d(BOOST_PP_LIST_REVERSE_O, BOOST_PP_NIL, list)
#define BOOST_PP_LIST_FOLD_RIGHT_1(o,s,l) BOOST_PP_LIST_FOLD_LEFT_1(o, s, BOOST_PP_LIST_REVERSE_D(1, l))
#define BOOST_PP_LIST_FOLD_RIGHT_2(o,s,l) BOOST_PP_LIST_FOLD_LEFT_2(o, s, BOOST_PP_LIST_REVERSE_D(2, l))
#define BOOST_PP_LIST_FOLD_RIGHT_3(o,s,l) BOOST_PP_LIST_FOLD_LEFT_3(o, s, BOOST_PP_LIST_REVERSE_D(3, l))
#define BOOST_PP_LIST_FOLD_RIGHT_4(o,s,l) BOOST_PP_LIST_FOLD_LEFT_4(o, s, BOOST_PP_LIST_REVERSE_D(4, l))
#define BOOST_PP_LIST_FOLD_RIGHT_5(o,s,l) BOOST_PP_LIST_FOLD_LEFT_5(o, s, BOOST_PP_LIST_REVERSE_D(5, l))
#define BOOST_PP_LIST_FOLD_RIGHT_6(o,s,l) BOOST_PP_LIST_FOLD_LEFT_6(o, s, BOOST_PP_LIST_REVERSE_D(6, l))
#define BOOST_PP_LIST_FOLD_RIGHT_7(o,s,l) BOOST_PP_LIST_FOLD_LEFT_7(o, s, BOOST_PP_LIST_REVERSE_D(7, l))
#define BOOST_PP_LIST_FOLD_RIGHT_8(o,s,l) BOOST_PP_LIST_FOLD_LEFT_8(o, s, BOOST_PP_LIST_REVERSE_D(8, l))
#define BOOST_PP_LIST_FOLD_RIGHT_9(o,s,l) BOOST_PP_LIST_FOLD_LEFT_9(o, s, BOOST_PP_LIST_REVERSE_D(9, l))
#define BOOST_PP_LIST_FOLD_RIGHT_10(o,s,l) BOOST_PP_LIST_FOLD_LEFT_10(o, s, BOOST_PP_LIST_REVERSE_D(10, l))
#define BOOST_PP_LIST_FOLD_RIGHT_11(o,s,l) BOOST_PP_LIST_FOLD_LEFT_11(o, s, BOOST_PP_LIST_REVERSE_D(11, l))
#define BOOST_PP_LIST_FOLD_RIGHT_12(o,s,l) BOOST_PP_LIST_FOLD_LEFT_12(o, s, BOOST_PP_LIST_REVERSE_D(12, l))
#define BOOST_PP_LIST_FOLD_RIGHT_13(o,s,l) BOOST_PP_LIST_FOLD_LEFT_13(o, s, BOOST_PP_LIST_REVERSE_D(13, l))
#define BOOST_PP_LIST_FOLD_RIGHT_14(o,s,l) BOOST_PP_LIST_FOLD_LEFT_14(o, s, BOOST_PP_LIST_REVERSE_D(14, l))
#define BOOST_PP_LIST_FOLD_RIGHT_15(o,s,l) BOOST_PP_LIST_FOLD_LEFT_15(o, s, BOOST_PP_LIST_REVERSE_D(15, l))
#define BOOST_PP_LIST_FOLD_RIGHT_16(o,s,l) BOOST_PP_LIST_FOLD_LEFT_16(o, s, BOOST_PP_LIST_REVERSE_D(16, l))
#define BOOST_PP_LIST_FOLD_RIGHT_17(o,s,l) BOOST_PP_LIST_FOLD_LEFT_17(o, s, BOOST_PP_LIST_REVERSE_D(17, l))
#define BOOST_PP_LIST_FOLD_RIGHT_18(o,s,l) BOOST_PP_LIST_FOLD_LEFT_18(o, s, BOOST_PP_LIST_REVERSE_D(18, l))
#define BOOST_PP_LIST_FOLD_RIGHT_19(o,s,l) BOOST_PP_LIST_FOLD_LEFT_19(o, s, BOOST_PP_LIST_REVERSE_D(19, l))
#define BOOST_PP_LIST_FOLD_RIGHT_20(o,s,l) BOOST_PP_LIST_FOLD_LEFT_20(o, s, BOOST_PP_LIST_REVERSE_D(20, l))
#define BOOST_PP_LIST_FOLD_RIGHT_21(o,s,l) BOOST_PP_LIST_FOLD_LEFT_21(o, s, BOOST_PP_LIST_REVERSE_D(21, l))
#define BOOST_PP_LIST_FOLD_RIGHT_22(o,s,l) BOOST_PP_LIST_FOLD_LEFT_22(o, s, BOOST_PP_LIST_REVERSE_D(22, l))
#define BOOST_PP_LIST_FOLD_RIGHT_23(o,s,l) BOOST_PP_LIST_FOLD_LEFT_23(o, s, BOOST_PP_LIST_REVERSE_D(23, l))
#define BOOST_PP_LIST_FOLD_RIGHT_24(o,s,l) BOOST_PP_LIST_FOLD_LEFT_24(o, s, BOOST_PP_LIST_REVERSE_D(24, l))
#define BOOST_PP_LIST_FOLD_RIGHT_25(o,s,l) BOOST_PP_LIST_FOLD_LEFT_25(o, s, BOOST_PP_LIST_REVERSE_D(25, l))
#define BOOST_PP_LIST_FOLD_RIGHT_26(o,s,l) BOOST_PP_LIST_FOLD_LEFT_26(o, s, BOOST_PP_LIST_REVERSE_D(26, l))
#define BOOST_PP_LIST_FOLD_RIGHT_27(o,s,l) BOOST_PP_LIST_FOLD_LEFT_27(o, s, BOOST_PP_LIST_REVERSE_D(27, l))
#define BOOST_PP_LIST_FOLD_RIGHT_28(o,s,l) BOOST_PP_LIST_FOLD_LEFT_28(o, s, BOOST_PP_LIST_REVERSE_D(28, l))
#define BOOST_PP_LIST_FOLD_RIGHT_29(o,s,l) BOOST_PP_LIST_FOLD_LEFT_29(o, s, BOOST_PP_LIST_REVERSE_D(29, l))
#define BOOST_PP_LIST_FOLD_RIGHT_30(o,s,l) BOOST_PP_LIST_FOLD_LEFT_30(o, s, BOOST_PP_LIST_REVERSE_D(30, l))
#define BOOST_PP_LIST_FOLD_RIGHT_31(o,s,l) BOOST_PP_LIST_FOLD_LEFT_31(o, s, BOOST_PP_LIST_REVERSE_D(31, l))
#define BOOST_PP_LIST_FOLD_RIGHT_32(o,s,l) BOOST_PP_LIST_FOLD_LEFT_32(o, s, BOOST_PP_LIST_REVERSE_D(32, l))
#define BOOST_PP_LIST_FOLD_RIGHT_33(o,s,l) BOOST_PP_LIST_FOLD_LEFT_33(o, s, BOOST_PP_LIST_REVERSE_D(33, l))
#define BOOST_PP_LIST_FOLD_RIGHT_34(o,s,l) BOOST_PP_LIST_FOLD_LEFT_34(o, s, BOOST_PP_LIST_REVERSE_D(34, l))
#define BOOST_PP_LIST_FOLD_RIGHT_35(o,s,l) BOOST_PP_LIST_FOLD_LEFT_35(o, s, BOOST_PP_LIST_REVERSE_D(35, l))
#define BOOST_PP_LIST_FOLD_RIGHT_36(o,s,l) BOOST_PP_LIST_FOLD_LEFT_36(o, s, BOOST_PP_LIST_REVERSE_D(36, l))
#define BOOST_PP_LIST_FOLD_RIGHT_37(o,s,l) BOOST_PP_LIST_FOLD_LEFT_37(o, s, BOOST_PP_LIST_REVERSE_D(37, l))
#define BOOST_PP_LIST_FOLD_RIGHT_38(o,s,l) BOOST_PP_LIST_FOLD_LEFT_38(o, s, BOOST_PP_LIST_REVERSE_D(38, l))
#define BOOST_PP_LIST_FOLD_RIGHT_39(o,s,l) BOOST_PP_LIST_FOLD_LEFT_39(o, s, BOOST_PP_LIST_REVERSE_D(39, l))
#define BOOST_PP_LIST_FOLD_RIGHT_40(o,s,l) BOOST_PP_LIST_FOLD_LEFT_40(o, s, BOOST_PP_LIST_REVERSE_D(40, l))
#define BOOST_PP_LIST_FOLD_RIGHT_41(o,s,l) BOOST_PP_LIST_FOLD_LEFT_41(o, s, BOOST_PP_LIST_REVERSE_D(41, l))
#define BOOST_PP_LIST_FOLD_RIGHT_42(o,s,l) BOOST_PP_LIST_FOLD_LEFT_42(o, s, BOOST_PP_LIST_REVERSE_D(42, l))
#define BOOST_PP_LIST_FOLD_RIGHT_43(o,s,l) BOOST_PP_LIST_FOLD_LEFT_43(o, s, BOOST_PP_LIST_REVERSE_D(43, l))
#define BOOST_PP_LIST_FOLD_RIGHT_44(o,s,l) BOOST_PP_LIST_FOLD_LEFT_44(o, s, BOOST_PP_LIST_REVERSE_D(44, l))
#define BOOST_PP_LIST_FOLD_RIGHT_45(o,s,l) BOOST_PP_LIST_FOLD_LEFT_45(o, s, BOOST_PP_LIST_REVERSE_D(45, l))
#define BOOST_PP_LIST_FOLD_RIGHT_46(o,s,l) BOOST_PP_LIST_FOLD_LEFT_46(o, s, BOOST_PP_LIST_REVERSE_D(46, l))
#define BOOST_PP_LIST_FOLD_RIGHT_47(o,s,l) BOOST_PP_LIST_FOLD_LEFT_47(o, s, BOOST_PP_LIST_REVERSE_D(47, l))
#define BOOST_PP_LIST_FOLD_RIGHT_48(o,s,l) BOOST_PP_LIST_FOLD_LEFT_48(o, s, BOOST_PP_LIST_REVERSE_D(48, l))
#define BOOST_PP_LIST_FOLD_RIGHT_49(o,s,l) BOOST_PP_LIST_FOLD_LEFT_49(o, s, BOOST_PP_LIST_REVERSE_D(49, l))
#define BOOST_PP_LIST_FOLD_RIGHT_50(o,s,l) BOOST_PP_LIST_FOLD_LEFT_50(o, s, BOOST_PP_LIST_REVERSE_D(50, l))
#define BOOST_PP_LIST_FOLD_RIGHT_51(o,s,l) BOOST_PP_LIST_FOLD_LEFT_51(o, s, BOOST_PP_LIST_REVERSE_D(51, l))
#define BOOST_PP_LIST_FOLD_RIGHT_52(o,s,l) BOOST_PP_LIST_FOLD_LEFT_52(o, s, BOOST_PP_LIST_REVERSE_D(52, l))
#define BOOST_PP_LIST_FOLD_RIGHT_53(o,s,l) BOOST_PP_LIST_FOLD_LEFT_53(o, s, BOOST_PP_LIST_REVERSE_D(53, l))
#define BOOST_PP_LIST_FOLD_RIGHT_54(o,s,l) BOOST_PP_LIST_FOLD_LEFT_54(o, s, BOOST_PP_LIST_REVERSE_D(54, l))
#define BOOST_PP_LIST_FOLD_RIGHT_55(o,s,l) BOOST_PP_LIST_FOLD_LEFT_55(o, s, BOOST_PP_LIST_REVERSE_D(55, l))
#define BOOST_PP_LIST_FOLD_RIGHT_56(o,s,l) BOOST_PP_LIST_FOLD_LEFT_56(o, s, BOOST_PP_LIST_REVERSE_D(56, l))
#define BOOST_PP_LIST_FOLD_RIGHT_57(o,s,l) BOOST_PP_LIST_FOLD_LEFT_57(o, s, BOOST_PP_LIST_REVERSE_D(57, l))
#define BOOST_PP_LIST_FOLD_RIGHT_58(o,s,l) BOOST_PP_LIST_FOLD_LEFT_58(o, s, BOOST_PP_LIST_REVERSE_D(58, l))
#define BOOST_PP_LIST_FOLD_RIGHT_59(o,s,l) BOOST_PP_LIST_FOLD_LEFT_59(o, s, BOOST_PP_LIST_REVERSE_D(59, l))
#define BOOST_PP_LIST_FOLD_RIGHT_60(o,s,l) BOOST_PP_LIST_FOLD_LEFT_60(o, s, BOOST_PP_LIST_REVERSE_D(60, l))
#define BOOST_PP_LIST_FOLD_RIGHT_61(o,s,l) BOOST_PP_LIST_FOLD_LEFT_61(o, s, BOOST_PP_LIST_REVERSE_D(61, l))
#define BOOST_PP_LIST_FOLD_RIGHT_62(o,s,l) BOOST_PP_LIST_FOLD_LEFT_62(o, s, BOOST_PP_LIST_REVERSE_D(62, l))
#define BOOST_PP_LIST_FOLD_RIGHT_63(o,s,l) BOOST_PP_LIST_FOLD_LEFT_63(o, s, BOOST_PP_LIST_REVERSE_D(63, l))
#define BOOST_PP_LIST_FOLD_RIGHT_64(o,s,l) BOOST_PP_LIST_FOLD_LEFT_64(o, s, BOOST_PP_LIST_REVERSE_D(64, l))
#define BOOST_PP_LIST_FOLD_RIGHT_65(o,s,l) BOOST_PP_LIST_FOLD_LEFT_65(o, s, BOOST_PP_LIST_REVERSE_D(65, l))
#define BOOST_PP_LIST_FOLD_RIGHT_66(o,s,l) BOOST_PP_LIST_FOLD_LEFT_66(o, s, BOOST_PP_LIST_REVERSE_D(66, l))
#define BOOST_PP_LIST_FOLD_RIGHT_67(o,s,l) BOOST_PP_LIST_FOLD_LEFT_67(o, s, BOOST_PP_LIST_REVERSE_D(67, l))
#define BOOST_PP_LIST_FOLD_RIGHT_68(o,s,l) BOOST_PP_LIST_FOLD_LEFT_68(o, s, BOOST_PP_LIST_REVERSE_D(68, l))
#define BOOST_PP_LIST_FOLD_RIGHT_69(o,s,l) BOOST_PP_LIST_FOLD_LEFT_69(o, s, BOOST_PP_LIST_REVERSE_D(69, l))
#define BOOST_PP_LIST_FOLD_RIGHT_70(o,s,l) BOOST_PP_LIST_FOLD_LEFT_70(o, s, BOOST_PP_LIST_REVERSE_D(70, l))
#define BOOST_PP_LIST_FOLD_RIGHT_71(o,s,l) BOOST_PP_LIST_FOLD_LEFT_71(o, s, BOOST_PP_LIST_REVERSE_D(71, l))
#define BOOST_PP_LIST_FOLD_RIGHT_72(o,s,l) BOOST_PP_LIST_FOLD_LEFT_72(o, s, BOOST_PP_LIST_REVERSE_D(72, l))
#define BOOST_PP_LIST_FOLD_RIGHT_73(o,s,l) BOOST_PP_LIST_FOLD_LEFT_73(o, s, BOOST_PP_LIST_REVERSE_D(73, l))
#define BOOST_PP_LIST_FOLD_RIGHT_74(o,s,l) BOOST_PP_LIST_FOLD_LEFT_74(o, s, BOOST_PP_LIST_REVERSE_D(74, l))
#define BOOST_PP_LIST_FOLD_RIGHT_75(o,s,l) BOOST_PP_LIST_FOLD_LEFT_75(o, s, BOOST_PP_LIST_REVERSE_D(75, l))
#define BOOST_PP_LIST_FOLD_RIGHT_76(o,s,l) BOOST_PP_LIST_FOLD_LEFT_76(o, s, BOOST_PP_LIST_REVERSE_D(76, l))
#define BOOST_PP_LIST_FOLD_RIGHT_77(o,s,l) BOOST_PP_LIST_FOLD_LEFT_77(o, s, BOOST_PP_LIST_REVERSE_D(77, l))
#define BOOST_PP_LIST_FOLD_RIGHT_78(o,s,l) BOOST_PP_LIST_FOLD_LEFT_78(o, s, BOOST_PP_LIST_REVERSE_D(78, l))
#define BOOST_PP_LIST_FOLD_RIGHT_79(o,s,l) BOOST_PP_LIST_FOLD_LEFT_79(o, s, BOOST_PP_LIST_REVERSE_D(79, l))
#define BOOST_PP_LIST_FOLD_RIGHT_80(o,s,l) BOOST_PP_LIST_FOLD_LEFT_80(o, s, BOOST_PP_LIST_REVERSE_D(80, l))
#define BOOST_PP_LIST_FOLD_RIGHT_81(o,s,l) BOOST_PP_LIST_FOLD_LEFT_81(o, s, BOOST_PP_LIST_REVERSE_D(81, l))
#define BOOST_PP_LIST_FOLD_RIGHT_82(o,s,l) BOOST_PP_LIST_FOLD_LEFT_82(o, s, BOOST_PP_LIST_REVERSE_D(82, l))
#define BOOST_PP_LIST_FOLD_RIGHT_83(o,s,l) BOOST_PP_LIST_FOLD_LEFT_83(o, s, BOOST_PP_LIST_REVERSE_D(83, l))
#define BOOST_PP_LIST_FOLD_RIGHT_84(o,s,l) BOOST_PP_LIST_FOLD_LEFT_84(o, s, BOOST_PP_LIST_REVERSE_D(84, l))
#define BOOST_PP_LIST_FOLD_RIGHT_85(o,s,l) BOOST_PP_LIST_FOLD_LEFT_85(o, s, BOOST_PP_LIST_REVERSE_D(85, l))
#define BOOST_PP_LIST_FOLD_RIGHT_86(o,s,l) BOOST_PP_LIST_FOLD_LEFT_86(o, s, BOOST_PP_LIST_REVERSE_D(86, l))
#define BOOST_PP_LIST_FOLD_RIGHT_87(o,s,l) BOOST_PP_LIST_FOLD_LEFT_87(o, s, BOOST_PP_LIST_REVERSE_D(87, l))
#define BOOST_PP_LIST_FOLD_RIGHT_88(o,s,l) BOOST_PP_LIST_FOLD_LEFT_88(o, s, BOOST_PP_LIST_REVERSE_D(88, l))
#define BOOST_PP_LIST_FOLD_RIGHT_89(o,s,l) BOOST_PP_LIST_FOLD_LEFT_89(o, s, BOOST_PP_LIST_REVERSE_D(89, l))
#define BOOST_PP_LIST_FOLD_RIGHT_90(o,s,l) BOOST_PP_LIST_FOLD_LEFT_90(o, s, BOOST_PP_LIST_REVERSE_D(90, l))
#define BOOST_PP_LIST_FOLD_RIGHT_91(o,s,l) BOOST_PP_LIST_FOLD_LEFT_91(o, s, BOOST_PP_LIST_REVERSE_D(91, l))
#define BOOST_PP_LIST_FOLD_RIGHT_92(o,s,l) BOOST_PP_LIST_FOLD_LEFT_92(o, s, BOOST_PP_LIST_REVERSE_D(92, l))
#define BOOST_PP_LIST_FOLD_RIGHT_93(o,s,l) BOOST_PP_LIST_FOLD_LEFT_93(o, s, BOOST_PP_LIST_REVERSE_D(93, l))
#define BOOST_PP_LIST_FOLD_RIGHT_94(o,s,l) BOOST_PP_LIST_FOLD_LEFT_94(o, s, BOOST_PP_LIST_REVERSE_D(94, l))
#define BOOST_PP_LIST_FOLD_RIGHT_95(o,s,l) BOOST_PP_LIST_FOLD_LEFT_95(o, s, BOOST_PP_LIST_REVERSE_D(95, l))
#define BOOST_PP_LIST_FOLD_RIGHT_96(o,s,l) BOOST_PP_LIST_FOLD_LEFT_96(o, s, BOOST_PP_LIST_REVERSE_D(96, l))
#define BOOST_PP_LIST_FOLD_RIGHT_97(o,s,l) BOOST_PP_LIST_FOLD_LEFT_97(o, s, BOOST_PP_LIST_REVERSE_D(97, l))
#define BOOST_PP_LIST_FOLD_RIGHT_98(o,s,l) BOOST_PP_LIST_FOLD_LEFT_98(o, s, BOOST_PP_LIST_REVERSE_D(98, l))
#define BOOST_PP_LIST_FOLD_RIGHT_99(o,s,l) BOOST_PP_LIST_FOLD_LEFT_99(o, s, BOOST_PP_LIST_REVERSE_D(99, l))
#define BOOST_PP_LIST_FOLD_RIGHT_100(o,s,l) BOOST_PP_LIST_FOLD_LEFT_100(o, s, BOOST_PP_LIST_REVERSE_D(100, l))
#define BOOST_PP_LIST_FOLD_RIGHT_101(o,s,l) BOOST_PP_LIST_FOLD_LEFT_101(o, s, BOOST_PP_LIST_REVERSE_D(101, l))
#define BOOST_PP_LIST_FOLD_RIGHT_102(o,s,l) BOOST_PP_LIST_FOLD_LEFT_102(o, s, BOOST_PP_LIST_REVERSE_D(102, l))
#define BOOST_PP_LIST_FOLD_RIGHT_103(o,s,l) BOOST_PP_LIST_FOLD_LEFT_103(o, s, BOOST_PP_LIST_REVERSE_D(103, l))
#define BOOST_PP_LIST_FOLD_RIGHT_104(o,s,l) BOOST_PP_LIST_FOLD_LEFT_104(o, s, BOOST_PP_LIST_REVERSE_D(104, l))
#define BOOST_PP_LIST_FOLD_RIGHT_105(o,s,l) BOOST_PP_LIST_FOLD_LEFT_105(o, s, BOOST_PP_LIST_REVERSE_D(105, l))
#define BOOST_PP_LIST_FOLD_RIGHT_106(o,s,l) BOOST_PP_LIST_FOLD_LEFT_106(o, s, BOOST_PP_LIST_REVERSE_D(106, l))
#define BOOST_PP_LIST_FOLD_RIGHT_107(o,s,l) BOOST_PP_LIST_FOLD_LEFT_107(o, s, BOOST_PP_LIST_REVERSE_D(107, l))
#define BOOST_PP_LIST_FOLD_RIGHT_108(o,s,l) BOOST_PP_LIST_FOLD_LEFT_108(o, s, BOOST_PP_LIST_REVERSE_D(108, l))
#define BOOST_PP_LIST_FOLD_RIGHT_109(o,s,l) BOOST_PP_LIST_FOLD_LEFT_109(o, s, BOOST_PP_LIST_REVERSE_D(109, l))
#define BOOST_PP_LIST_FOLD_RIGHT_110(o,s,l) BOOST_PP_LIST_FOLD_LEFT_110(o, s, BOOST_PP_LIST_REVERSE_D(110, l))
#define BOOST_PP_LIST_FOLD_RIGHT_111(o,s,l) BOOST_PP_LIST_FOLD_LEFT_111(o, s, BOOST_PP_LIST_REVERSE_D(111, l))
#define BOOST_PP_LIST_FOLD_RIGHT_112(o,s,l) BOOST_PP_LIST_FOLD_LEFT_112(o, s, BOOST_PP_LIST_REVERSE_D(112, l))
#define BOOST_PP_LIST_FOLD_RIGHT_113(o,s,l) BOOST_PP_LIST_FOLD_LEFT_113(o, s, BOOST_PP_LIST_REVERSE_D(113, l))
#define BOOST_PP_LIST_FOLD_RIGHT_114(o,s,l) BOOST_PP_LIST_FOLD_LEFT_114(o, s, BOOST_PP_LIST_REVERSE_D(114, l))
#define BOOST_PP_LIST_FOLD_RIGHT_115(o,s,l) BOOST_PP_LIST_FOLD_LEFT_115(o, s, BOOST_PP_LIST_REVERSE_D(115, l))
#define BOOST_PP_LIST_FOLD_RIGHT_116(o,s,l) BOOST_PP_LIST_FOLD_LEFT_116(o, s, BOOST_PP_LIST_REVERSE_D(116, l))
#define BOOST_PP_LIST_FOLD_RIGHT_117(o,s,l) BOOST_PP_LIST_FOLD_LEFT_117(o, s, BOOST_PP_LIST_REVERSE_D(117, l))
#define BOOST_PP_LIST_FOLD_RIGHT_118(o,s,l) BOOST_PP_LIST_FOLD_LEFT_118(o, s, BOOST_PP_LIST_REVERSE_D(118, l))
#define BOOST_PP_LIST_FOLD_RIGHT_119(o,s,l) BOOST_PP_LIST_FOLD_LEFT_119(o, s, BOOST_PP_LIST_REVERSE_D(119, l))
#define BOOST_PP_LIST_FOLD_RIGHT_120(o,s,l) BOOST_PP_LIST_FOLD_LEFT_120(o, s, BOOST_PP_LIST_REVERSE_D(120, l))
#define BOOST_PP_LIST_FOLD_RIGHT_121(o,s,l) BOOST_PP_LIST_FOLD_LEFT_121(o, s, BOOST_PP_LIST_REVERSE_D(121, l))
#define BOOST_PP_LIST_FOLD_RIGHT_122(o,s,l) BOOST_PP_LIST_FOLD_LEFT_122(o, s, BOOST_PP_LIST_REVERSE_D(122, l))
#define BOOST_PP_LIST_FOLD_RIGHT_123(o,s,l) BOOST_PP_LIST_FOLD_LEFT_123(o, s, BOOST_PP_LIST_REVERSE_D(123, l))
#define BOOST_PP_LIST_FOLD_RIGHT_124(o,s,l) BOOST_PP_LIST_FOLD_LEFT_124(o, s, BOOST_PP_LIST_REVERSE_D(124, l))
#define BOOST_PP_LIST_FOLD_RIGHT_125(o,s,l) BOOST_PP_LIST_FOLD_LEFT_125(o, s, BOOST_PP_LIST_REVERSE_D(125, l))
#define BOOST_PP_LIST_FOLD_RIGHT_126(o,s,l) BOOST_PP_LIST_FOLD_LEFT_126(o, s, BOOST_PP_LIST_REVERSE_D(126, l))
#define BOOST_PP_LIST_FOLD_RIGHT_127(o,s,l) BOOST_PP_LIST_FOLD_LEFT_127(o, s, BOOST_PP_LIST_REVERSE_D(127, l))
#define BOOST_PP_LIST_FOLD_RIGHT_128(o,s,l) BOOST_PP_LIST_FOLD_LEFT_128(o, s, BOOST_PP_LIST_REVERSE_D(128, l))
#define BOOST_PP_LIST_FOLD_RIGHT_129(o,s,l) BOOST_PP_LIST_FOLD_LEFT_129(o, s, BOOST_PP_LIST_REVERSE_D(129, l))
#define BOOST_PP_LIST_FOLD_RIGHT_130(o,s,l) BOOST_PP_LIST_FOLD_LEFT_130(o, s, BOOST_PP_LIST_REVERSE_D(130, l))
#define BOOST_PP_LIST_FOLD_RIGHT_131(o,s,l) BOOST_PP_LIST_FOLD_LEFT_131(o, s, BOOST_PP_LIST_REVERSE_D(131, l))
#define BOOST_PP_LIST_FOLD_RIGHT_132(o,s,l) BOOST_PP_LIST_FOLD_LEFT_132(o, s, BOOST_PP_LIST_REVERSE_D(132, l))
#define BOOST_PP_LIST_FOLD_RIGHT_133(o,s,l) BOOST_PP_LIST_FOLD_LEFT_133(o, s, BOOST_PP_LIST_REVERSE_D(133, l))
#define BOOST_PP_LIST_FOLD_RIGHT_134(o,s,l) BOOST_PP_LIST_FOLD_LEFT_134(o, s, BOOST_PP_LIST_REVERSE_D(134, l))
#define BOOST_PP_LIST_FOLD_RIGHT_135(o,s,l) BOOST_PP_LIST_FOLD_LEFT_135(o, s, BOOST_PP_LIST_REVERSE_D(135, l))
#define BOOST_PP_LIST_FOLD_RIGHT_136(o,s,l) BOOST_PP_LIST_FOLD_LEFT_136(o, s, BOOST_PP_LIST_REVERSE_D(136, l))
#define BOOST_PP_LIST_FOLD_RIGHT_137(o,s,l) BOOST_PP_LIST_FOLD_LEFT_137(o, s, BOOST_PP_LIST_REVERSE_D(137, l))
#define BOOST_PP_LIST_FOLD_RIGHT_138(o,s,l) BOOST_PP_LIST_FOLD_LEFT_138(o, s, BOOST_PP_LIST_REVERSE_D(138, l))
#define BOOST_PP_LIST_FOLD_RIGHT_139(o,s,l) BOOST_PP_LIST_FOLD_LEFT_139(o, s, BOOST_PP_LIST_REVERSE_D(139, l))
#define BOOST_PP_LIST_FOLD_RIGHT_140(o,s,l) BOOST_PP_LIST_FOLD_LEFT_140(o, s, BOOST_PP_LIST_REVERSE_D(140, l))
#define BOOST_PP_LIST_FOLD_RIGHT_141(o,s,l) BOOST_PP_LIST_FOLD_LEFT_141(o, s, BOOST_PP_LIST_REVERSE_D(141, l))
#define BOOST_PP_LIST_FOLD_RIGHT_142(o,s,l) BOOST_PP_LIST_FOLD_LEFT_142(o, s, BOOST_PP_LIST_REVERSE_D(142, l))
#define BOOST_PP_LIST_FOLD_RIGHT_143(o,s,l) BOOST_PP_LIST_FOLD_LEFT_143(o, s, BOOST_PP_LIST_REVERSE_D(143, l))
#define BOOST_PP_LIST_FOLD_RIGHT_144(o,s,l) BOOST_PP_LIST_FOLD_LEFT_144(o, s, BOOST_PP_LIST_REVERSE_D(144, l))
#define BOOST_PP_LIST_FOLD_RIGHT_145(o,s,l) BOOST_PP_LIST_FOLD_LEFT_145(o, s, BOOST_PP_LIST_REVERSE_D(145, l))
#define BOOST_PP_LIST_FOLD_RIGHT_146(o,s,l) BOOST_PP_LIST_FOLD_LEFT_146(o, s, BOOST_PP_LIST_REVERSE_D(146, l))
#define BOOST_PP_LIST_FOLD_RIGHT_147(o,s,l) BOOST_PP_LIST_FOLD_LEFT_147(o, s, BOOST_PP_LIST_REVERSE_D(147, l))
#define BOOST_PP_LIST_FOLD_RIGHT_148(o,s,l) BOOST_PP_LIST_FOLD_LEFT_148(o, s, BOOST_PP_LIST_REVERSE_D(148, l))
#define BOOST_PP_LIST_FOLD_RIGHT_149(o,s,l) BOOST_PP_LIST_FOLD_LEFT_149(o, s, BOOST_PP_LIST_REVERSE_D(149, l))
#define BOOST_PP_LIST_FOLD_RIGHT_150(o,s,l) BOOST_PP_LIST_FOLD_LEFT_150(o, s, BOOST_PP_LIST_REVERSE_D(150, l))
#define BOOST_PP_LIST_FOLD_RIGHT_151(o,s,l) BOOST_PP_LIST_FOLD_LEFT_151(o, s, BOOST_PP_LIST_REVERSE_D(151, l))
#define BOOST_PP_LIST_FOLD_RIGHT_152(o,s,l) BOOST_PP_LIST_FOLD_LEFT_152(o, s, BOOST_PP_LIST_REVERSE_D(152, l))
#define BOOST_PP_LIST_FOLD_RIGHT_153(o,s,l) BOOST_PP_LIST_FOLD_LEFT_153(o, s, BOOST_PP_LIST_REVERSE_D(153, l))
#define BOOST_PP_LIST_FOLD_RIGHT_154(o,s,l) BOOST_PP_LIST_FOLD_LEFT_154(o, s, BOOST_PP_LIST_REVERSE_D(154, l))
#define BOOST_PP_LIST_FOLD_RIGHT_155(o,s,l) BOOST_PP_LIST_FOLD_LEFT_155(o, s, BOOST_PP_LIST_REVERSE_D(155, l))
#define BOOST_PP_LIST_FOLD_RIGHT_156(o,s,l) BOOST_PP_LIST_FOLD_LEFT_156(o, s, BOOST_PP_LIST_REVERSE_D(156, l))
#define BOOST_PP_LIST_FOLD_RIGHT_157(o,s,l) BOOST_PP_LIST_FOLD_LEFT_157(o, s, BOOST_PP_LIST_REVERSE_D(157, l))
#define BOOST_PP_LIST_FOLD_RIGHT_158(o,s,l) BOOST_PP_LIST_FOLD_LEFT_158(o, s, BOOST_PP_LIST_REVERSE_D(158, l))
#define BOOST_PP_LIST_FOLD_RIGHT_159(o,s,l) BOOST_PP_LIST_FOLD_LEFT_159(o, s, BOOST_PP_LIST_REVERSE_D(159, l))
#define BOOST_PP_LIST_FOLD_RIGHT_160(o,s,l) BOOST_PP_LIST_FOLD_LEFT_160(o, s, BOOST_PP_LIST_REVERSE_D(160, l))
#define BOOST_PP_LIST_FOLD_RIGHT_161(o,s,l) BOOST_PP_LIST_FOLD_LEFT_161(o, s, BOOST_PP_LIST_REVERSE_D(161, l))
#define BOOST_PP_LIST_FOLD_RIGHT_162(o,s,l) BOOST_PP_LIST_FOLD_LEFT_162(o, s, BOOST_PP_LIST_REVERSE_D(162, l))
#define BOOST_PP_LIST_FOLD_RIGHT_163(o,s,l) BOOST_PP_LIST_FOLD_LEFT_163(o, s, BOOST_PP_LIST_REVERSE_D(163, l))
#define BOOST_PP_LIST_FOLD_RIGHT_164(o,s,l) BOOST_PP_LIST_FOLD_LEFT_164(o, s, BOOST_PP_LIST_REVERSE_D(164, l))
#define BOOST_PP_LIST_FOLD_RIGHT_165(o,s,l) BOOST_PP_LIST_FOLD_LEFT_165(o, s, BOOST_PP_LIST_REVERSE_D(165, l))
#define BOOST_PP_LIST_FOLD_RIGHT_166(o,s,l) BOOST_PP_LIST_FOLD_LEFT_166(o, s, BOOST_PP_LIST_REVERSE_D(166, l))
#define BOOST_PP_LIST_FOLD_RIGHT_167(o,s,l) BOOST_PP_LIST_FOLD_LEFT_167(o, s, BOOST_PP_LIST_REVERSE_D(167, l))
#define BOOST_PP_LIST_FOLD_RIGHT_168(o,s,l) BOOST_PP_LIST_FOLD_LEFT_168(o, s, BOOST_PP_LIST_REVERSE_D(168, l))
#define BOOST_PP_LIST_FOLD_RIGHT_169(o,s,l) BOOST_PP_LIST_FOLD_LEFT_169(o, s, BOOST_PP_LIST_REVERSE_D(169, l))
#define BOOST_PP_LIST_FOLD_RIGHT_170(o,s,l) BOOST_PP_LIST_FOLD_LEFT_170(o, s, BOOST_PP_LIST_REVERSE_D(170, l))
#define BOOST_PP_LIST_FOLD_RIGHT_171(o,s,l) BOOST_PP_LIST_FOLD_LEFT_171(o, s, BOOST_PP_LIST_REVERSE_D(171, l))
#define BOOST_PP_LIST_FOLD_RIGHT_172(o,s,l) BOOST_PP_LIST_FOLD_LEFT_172(o, s, BOOST_PP_LIST_REVERSE_D(172, l))
#define BOOST_PP_LIST_FOLD_RIGHT_173(o,s,l) BOOST_PP_LIST_FOLD_LEFT_173(o, s, BOOST_PP_LIST_REVERSE_D(173, l))
#define BOOST_PP_LIST_FOLD_RIGHT_174(o,s,l) BOOST_PP_LIST_FOLD_LEFT_174(o, s, BOOST_PP_LIST_REVERSE_D(174, l))
#define BOOST_PP_LIST_FOLD_RIGHT_175(o,s,l) BOOST_PP_LIST_FOLD_LEFT_175(o, s, BOOST_PP_LIST_REVERSE_D(175, l))
#define BOOST_PP_LIST_FOLD_RIGHT_176(o,s,l) BOOST_PP_LIST_FOLD_LEFT_176(o, s, BOOST_PP_LIST_REVERSE_D(176, l))
#define BOOST_PP_LIST_FOLD_RIGHT_177(o,s,l) BOOST_PP_LIST_FOLD_LEFT_177(o, s, BOOST_PP_LIST_REVERSE_D(177, l))
#define BOOST_PP_LIST_FOLD_RIGHT_178(o,s,l) BOOST_PP_LIST_FOLD_LEFT_178(o, s, BOOST_PP_LIST_REVERSE_D(178, l))
#define BOOST_PP_LIST_FOLD_RIGHT_179(o,s,l) BOOST_PP_LIST_FOLD_LEFT_179(o, s, BOOST_PP_LIST_REVERSE_D(179, l))
#define BOOST_PP_LIST_FOLD_RIGHT_180(o,s,l) BOOST_PP_LIST_FOLD_LEFT_180(o, s, BOOST_PP_LIST_REVERSE_D(180, l))
#define BOOST_PP_LIST_FOLD_RIGHT_181(o,s,l) BOOST_PP_LIST_FOLD_LEFT_181(o, s, BOOST_PP_LIST_REVERSE_D(181, l))
#define BOOST_PP_LIST_FOLD_RIGHT_182(o,s,l) BOOST_PP_LIST_FOLD_LEFT_182(o, s, BOOST_PP_LIST_REVERSE_D(182, l))
#define BOOST_PP_LIST_FOLD_RIGHT_183(o,s,l) BOOST_PP_LIST_FOLD_LEFT_183(o, s, BOOST_PP_LIST_REVERSE_D(183, l))
#define BOOST_PP_LIST_FOLD_RIGHT_184(o,s,l) BOOST_PP_LIST_FOLD_LEFT_184(o, s, BOOST_PP_LIST_REVERSE_D(184, l))
#define BOOST_PP_LIST_FOLD_RIGHT_185(o,s,l) BOOST_PP_LIST_FOLD_LEFT_185(o, s, BOOST_PP_LIST_REVERSE_D(185, l))
#define BOOST_PP_LIST_FOLD_RIGHT_186(o,s,l) BOOST_PP_LIST_FOLD_LEFT_186(o, s, BOOST_PP_LIST_REVERSE_D(186, l))
#define BOOST_PP_LIST_FOLD_RIGHT_187(o,s,l) BOOST_PP_LIST_FOLD_LEFT_187(o, s, BOOST_PP_LIST_REVERSE_D(187, l))
#define BOOST_PP_LIST_FOLD_RIGHT_188(o,s,l) BOOST_PP_LIST_FOLD_LEFT_188(o, s, BOOST_PP_LIST_REVERSE_D(188, l))
#define BOOST_PP_LIST_FOLD_RIGHT_189(o,s,l) BOOST_PP_LIST_FOLD_LEFT_189(o, s, BOOST_PP_LIST_REVERSE_D(189, l))
#define BOOST_PP_LIST_FOLD_RIGHT_190(o,s,l) BOOST_PP_LIST_FOLD_LEFT_190(o, s, BOOST_PP_LIST_REVERSE_D(190, l))
#define BOOST_PP_LIST_FOLD_RIGHT_191(o,s,l) BOOST_PP_LIST_FOLD_LEFT_191(o, s, BOOST_PP_LIST_REVERSE_D(191, l))
#define BOOST_PP_LIST_FOLD_RIGHT_192(o,s,l) BOOST_PP_LIST_FOLD_LEFT_192(o, s, BOOST_PP_LIST_REVERSE_D(192, l))
#define BOOST_PP_LIST_FOLD_RIGHT_193(o,s,l) BOOST_PP_LIST_FOLD_LEFT_193(o, s, BOOST_PP_LIST_REVERSE_D(193, l))
#define BOOST_PP_LIST_FOLD_RIGHT_194(o,s,l) BOOST_PP_LIST_FOLD_LEFT_194(o, s, BOOST_PP_LIST_REVERSE_D(194, l))
#define BOOST_PP_LIST_FOLD_RIGHT_195(o,s,l) BOOST_PP_LIST_FOLD_LEFT_195(o, s, BOOST_PP_LIST_REVERSE_D(195, l))
#define BOOST_PP_LIST_FOLD_RIGHT_196(o,s,l) BOOST_PP_LIST_FOLD_LEFT_196(o, s, BOOST_PP_LIST_REVERSE_D(196, l))
#define BOOST_PP_LIST_FOLD_RIGHT_197(o,s,l) BOOST_PP_LIST_FOLD_LEFT_197(o, s, BOOST_PP_LIST_REVERSE_D(197, l))
#define BOOST_PP_LIST_FOLD_RIGHT_198(o,s,l) BOOST_PP_LIST_FOLD_LEFT_198(o, s, BOOST_PP_LIST_REVERSE_D(198, l))
#define BOOST_PP_LIST_FOLD_RIGHT_199(o,s,l) BOOST_PP_LIST_FOLD_LEFT_199(o, s, BOOST_PP_LIST_REVERSE_D(199, l))
#define BOOST_PP_LIST_FOLD_RIGHT_200(o,s,l) BOOST_PP_LIST_FOLD_LEFT_200(o, s, BOOST_PP_LIST_REVERSE_D(200, l))
#define BOOST_PP_LIST_FOLD_RIGHT_201(o,s,l) BOOST_PP_LIST_FOLD_LEFT_201(o, s, BOOST_PP_LIST_REVERSE_D(201, l))
#define BOOST_PP_LIST_FOLD_RIGHT_202(o,s,l) BOOST_PP_LIST_FOLD_LEFT_202(o, s, BOOST_PP_LIST_REVERSE_D(202, l))
#define BOOST_PP_LIST_FOLD_RIGHT_203(o,s,l) BOOST_PP_LIST_FOLD_LEFT_203(o, s, BOOST_PP_LIST_REVERSE_D(203, l))
#define BOOST_PP_LIST_FOLD_RIGHT_204(o,s,l) BOOST_PP_LIST_FOLD_LEFT_204(o, s, BOOST_PP_LIST_REVERSE_D(204, l))
#define BOOST_PP_LIST_FOLD_RIGHT_205(o,s,l) BOOST_PP_LIST_FOLD_LEFT_205(o, s, BOOST_PP_LIST_REVERSE_D(205, l))
#define BOOST_PP_LIST_FOLD_RIGHT_206(o,s,l) BOOST_PP_LIST_FOLD_LEFT_206(o, s, BOOST_PP_LIST_REVERSE_D(206, l))
#define BOOST_PP_LIST_FOLD_RIGHT_207(o,s,l) BOOST_PP_LIST_FOLD_LEFT_207(o, s, BOOST_PP_LIST_REVERSE_D(207, l))
#define BOOST_PP_LIST_FOLD_RIGHT_208(o,s,l) BOOST_PP_LIST_FOLD_LEFT_208(o, s, BOOST_PP_LIST_REVERSE_D(208, l))
#define BOOST_PP_LIST_FOLD_RIGHT_209(o,s,l) BOOST_PP_LIST_FOLD_LEFT_209(o, s, BOOST_PP_LIST_REVERSE_D(209, l))
#define BOOST_PP_LIST_FOLD_RIGHT_210(o,s,l) BOOST_PP_LIST_FOLD_LEFT_210(o, s, BOOST_PP_LIST_REVERSE_D(210, l))
#define BOOST_PP_LIST_FOLD_RIGHT_211(o,s,l) BOOST_PP_LIST_FOLD_LEFT_211(o, s, BOOST_PP_LIST_REVERSE_D(211, l))
#define BOOST_PP_LIST_FOLD_RIGHT_212(o,s,l) BOOST_PP_LIST_FOLD_LEFT_212(o, s, BOOST_PP_LIST_REVERSE_D(212, l))
#define BOOST_PP_LIST_FOLD_RIGHT_213(o,s,l) BOOST_PP_LIST_FOLD_LEFT_213(o, s, BOOST_PP_LIST_REVERSE_D(213, l))
#define BOOST_PP_LIST_FOLD_RIGHT_214(o,s,l) BOOST_PP_LIST_FOLD_LEFT_214(o, s, BOOST_PP_LIST_REVERSE_D(214, l))
#define BOOST_PP_LIST_FOLD_RIGHT_215(o,s,l) BOOST_PP_LIST_FOLD_LEFT_215(o, s, BOOST_PP_LIST_REVERSE_D(215, l))
#define BOOST_PP_LIST_FOLD_RIGHT_216(o,s,l) BOOST_PP_LIST_FOLD_LEFT_216(o, s, BOOST_PP_LIST_REVERSE_D(216, l))
#define BOOST_PP_LIST_FOLD_RIGHT_217(o,s,l) BOOST_PP_LIST_FOLD_LEFT_217(o, s, BOOST_PP_LIST_REVERSE_D(217, l))
#define BOOST_PP_LIST_FOLD_RIGHT_218(o,s,l) BOOST_PP_LIST_FOLD_LEFT_218(o, s, BOOST_PP_LIST_REVERSE_D(218, l))
#define BOOST_PP_LIST_FOLD_RIGHT_219(o,s,l) BOOST_PP_LIST_FOLD_LEFT_219(o, s, BOOST_PP_LIST_REVERSE_D(219, l))
#define BOOST_PP_LIST_FOLD_RIGHT_220(o,s,l) BOOST_PP_LIST_FOLD_LEFT_220(o, s, BOOST_PP_LIST_REVERSE_D(220, l))
#define BOOST_PP_LIST_FOLD_RIGHT_221(o,s,l) BOOST_PP_LIST_FOLD_LEFT_221(o, s, BOOST_PP_LIST_REVERSE_D(221, l))
#define BOOST_PP_LIST_FOLD_RIGHT_222(o,s,l) BOOST_PP_LIST_FOLD_LEFT_222(o, s, BOOST_PP_LIST_REVERSE_D(222, l))
#define BOOST_PP_LIST_FOLD_RIGHT_223(o,s,l) BOOST_PP_LIST_FOLD_LEFT_223(o, s, BOOST_PP_LIST_REVERSE_D(223, l))
#define BOOST_PP_LIST_FOLD_RIGHT_224(o,s,l) BOOST_PP_LIST_FOLD_LEFT_224(o, s, BOOST_PP_LIST_REVERSE_D(224, l))
#define BOOST_PP_LIST_FOLD_RIGHT_225(o,s,l) BOOST_PP_LIST_FOLD_LEFT_225(o, s, BOOST_PP_LIST_REVERSE_D(225, l))
#define BOOST_PP_LIST_FOLD_RIGHT_226(o,s,l) BOOST_PP_LIST_FOLD_LEFT_226(o, s, BOOST_PP_LIST_REVERSE_D(226, l))
#define BOOST_PP_LIST_FOLD_RIGHT_227(o,s,l) BOOST_PP_LIST_FOLD_LEFT_227(o, s, BOOST_PP_LIST_REVERSE_D(227, l))
#define BOOST_PP_LIST_FOLD_RIGHT_228(o,s,l) BOOST_PP_LIST_FOLD_LEFT_228(o, s, BOOST_PP_LIST_REVERSE_D(228, l))
#define BOOST_PP_LIST_FOLD_RIGHT_229(o,s,l) BOOST_PP_LIST_FOLD_LEFT_229(o, s, BOOST_PP_LIST_REVERSE_D(229, l))
#define BOOST_PP_LIST_FOLD_RIGHT_230(o,s,l) BOOST_PP_LIST_FOLD_LEFT_230(o, s, BOOST_PP_LIST_REVERSE_D(230, l))
#define BOOST_PP_LIST_FOLD_RIGHT_231(o,s,l) BOOST_PP_LIST_FOLD_LEFT_231(o, s, BOOST_PP_LIST_REVERSE_D(231, l))
#define BOOST_PP_LIST_FOLD_RIGHT_232(o,s,l) BOOST_PP_LIST_FOLD_LEFT_232(o, s, BOOST_PP_LIST_REVERSE_D(232, l))
#define BOOST_PP_LIST_FOLD_RIGHT_233(o,s,l) BOOST_PP_LIST_FOLD_LEFT_233(o, s, BOOST_PP_LIST_REVERSE_D(233, l))
#define BOOST_PP_LIST_FOLD_RIGHT_234(o,s,l) BOOST_PP_LIST_FOLD_LEFT_234(o, s, BOOST_PP_LIST_REVERSE_D(234, l))
#define BOOST_PP_LIST_FOLD_RIGHT_235(o,s,l) BOOST_PP_LIST_FOLD_LEFT_235(o, s, BOOST_PP_LIST_REVERSE_D(235, l))
#define BOOST_PP_LIST_FOLD_RIGHT_236(o,s,l) BOOST_PP_LIST_FOLD_LEFT_236(o, s, BOOST_PP_LIST_REVERSE_D(236, l))
#define BOOST_PP_LIST_FOLD_RIGHT_237(o,s,l) BOOST_PP_LIST_FOLD_LEFT_237(o, s, BOOST_PP_LIST_REVERSE_D(237, l))
#define BOOST_PP_LIST_FOLD_RIGHT_238(o,s,l) BOOST_PP_LIST_FOLD_LEFT_238(o, s, BOOST_PP_LIST_REVERSE_D(238, l))
#define BOOST_PP_LIST_FOLD_RIGHT_239(o,s,l) BOOST_PP_LIST_FOLD_LEFT_239(o, s, BOOST_PP_LIST_REVERSE_D(239, l))
#define BOOST_PP_LIST_FOLD_RIGHT_240(o,s,l) BOOST_PP_LIST_FOLD_LEFT_240(o, s, BOOST_PP_LIST_REVERSE_D(240, l))
#define BOOST_PP_LIST_FOLD_RIGHT_241(o,s,l) BOOST_PP_LIST_FOLD_LEFT_241(o, s, BOOST_PP_LIST_REVERSE_D(241, l))
#define BOOST_PP_LIST_FOLD_RIGHT_242(o,s,l) BOOST_PP_LIST_FOLD_LEFT_242(o, s, BOOST_PP_LIST_REVERSE_D(242, l))
#define BOOST_PP_LIST_FOLD_RIGHT_243(o,s,l) BOOST_PP_LIST_FOLD_LEFT_243(o, s, BOOST_PP_LIST_REVERSE_D(243, l))
#define BOOST_PP_LIST_FOLD_RIGHT_244(o,s,l) BOOST_PP_LIST_FOLD_LEFT_244(o, s, BOOST_PP_LIST_REVERSE_D(244, l))
#define BOOST_PP_LIST_FOLD_RIGHT_245(o,s,l) BOOST_PP_LIST_FOLD_LEFT_245(o, s, BOOST_PP_LIST_REVERSE_D(245, l))
#define BOOST_PP_LIST_FOLD_RIGHT_246(o,s,l) BOOST_PP_LIST_FOLD_LEFT_246(o, s, BOOST_PP_LIST_REVERSE_D(246, l))
#define BOOST_PP_LIST_FOLD_RIGHT_247(o,s,l) BOOST_PP_LIST_FOLD_LEFT_247(o, s, BOOST_PP_LIST_REVERSE_D(247, l))
#define BOOST_PP_LIST_FOLD_RIGHT_248(o,s,l) BOOST_PP_LIST_FOLD_LEFT_248(o, s, BOOST_PP_LIST_REVERSE_D(248, l))
#define BOOST_PP_LIST_FOLD_RIGHT_249(o,s,l) BOOST_PP_LIST_FOLD_LEFT_249(o, s, BOOST_PP_LIST_REVERSE_D(249, l))
#define BOOST_PP_LIST_FOLD_RIGHT_250(o,s,l) BOOST_PP_LIST_FOLD_LEFT_250(o, s, BOOST_PP_LIST_REVERSE_D(250, l))
#define BOOST_PP_LIST_FOLD_RIGHT_251(o,s,l) BOOST_PP_LIST_FOLD_LEFT_251(o, s, BOOST_PP_LIST_REVERSE_D(251, l))
#define BOOST_PP_LIST_FOLD_RIGHT_252(o,s,l) BOOST_PP_LIST_FOLD_LEFT_252(o, s, BOOST_PP_LIST_REVERSE_D(252, l))
#define BOOST_PP_LIST_FOLD_RIGHT_253(o,s,l) BOOST_PP_LIST_FOLD_LEFT_253(o, s, BOOST_PP_LIST_REVERSE_D(253, l))
#define BOOST_PP_LIST_FOLD_RIGHT_254(o,s,l) BOOST_PP_LIST_FOLD_LEFT_254(o, s, BOOST_PP_LIST_REVERSE_D(254, l))
#define BOOST_PP_LIST_FOLD_RIGHT_255(o,s,l) BOOST_PP_LIST_FOLD_LEFT_255(o, s, BOOST_PP_LIST_REVERSE_D(255, l))
#define BOOST_PP_LIST_FOLD_RIGHT_256(o,s,l) BOOST_PP_LIST_FOLD_LEFT_256(o, s, BOOST_PP_LIST_REVERSE_D(256, l))
#define BOOST_PP_WHILE BOOST_PP_CAT(BOOST_PP_WHILE_, BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256))
#define BOOST_PP_WHILE_P(n) BOOST_PP_BITAND(BOOST_PP_CAT(BOOST_PP_WHILE_CHECK_, BOOST_PP_WHILE_ ## n(BOOST_PP_WHILE_F, BOOST_PP_NIL, BOOST_PP_NIL)), BOOST_PP_CAT(BOOST_PP_LIST_FOLD_LEFT_CHECK_, BOOST_PP_LIST_FOLD_LEFT_ ## n(BOOST_PP_NIL, BOOST_PP_NIL, BOOST_PP_NIL)))
#define BOOST_PP_WHILE_F(d,_) 0
#define BOOST_PREPROCESSOR_CONTROL_DETAIL_WHILE_HPP
#define BOOST_PP_WHILE_1(p,o,s) BOOST_PP_WHILE_1_C(BOOST_PP_BOOL(p(2, s)), p, o, s)
#define BOOST_PP_WHILE_2(p,o,s) BOOST_PP_WHILE_2_C(BOOST_PP_BOOL(p(3, s)), p, o, s)
#define BOOST_PP_WHILE_3(p,o,s) BOOST_PP_WHILE_3_C(BOOST_PP_BOOL(p(4, s)), p, o, s)
#define BOOST_PP_WHILE_4(p,o,s) BOOST_PP_WHILE_4_C(BOOST_PP_BOOL(p(5, s)), p, o, s)
#define BOOST_PP_WHILE_5(p,o,s) BOOST_PP_WHILE_5_C(BOOST_PP_BOOL(p(6, s)), p, o, s)
#define BOOST_PP_WHILE_6(p,o,s) BOOST_PP_WHILE_6_C(BOOST_PP_BOOL(p(7, s)), p, o, s)
#define BOOST_PP_WHILE_7(p,o,s) BOOST_PP_WHILE_7_C(BOOST_PP_BOOL(p(8, s)), p, o, s)
#define BOOST_PP_WHILE_8(p,o,s) BOOST_PP_WHILE_8_C(BOOST_PP_BOOL(p(9, s)), p, o, s)
#define BOOST_PP_WHILE_9(p,o,s) BOOST_PP_WHILE_9_C(BOOST_PP_BOOL(p(10, s)), p, o, s)
#define BOOST_PP_WHILE_10(p,o,s) BOOST_PP_WHILE_10_C(BOOST_PP_BOOL(p(11, s)), p, o, s)
#define BOOST_PP_WHILE_11(p,o,s) BOOST_PP_WHILE_11_C(BOOST_PP_BOOL(p(12, s)), p, o, s)
#define BOOST_PP_WHILE_12(p,o,s) BOOST_PP_WHILE_12_C(BOOST_PP_BOOL(p(13, s)), p, o, s)
#define BOOST_PP_WHILE_13(p,o,s) BOOST_PP_WHILE_13_C(BOOST_PP_BOOL(p(14, s)), p, o, s)
#define BOOST_PP_WHILE_14(p,o,s) BOOST_PP_WHILE_14_C(BOOST_PP_BOOL(p(15, s)), p, o, s)
#define BOOST_PP_WHILE_15(p,o,s) BOOST_PP_WHILE_15_C(BOOST_PP_BOOL(p(16, s)), p, o, s)
#define BOOST_PP_WHILE_16(p,o,s) BOOST_PP_WHILE_16_C(BOOST_PP_BOOL(p(17, s)), p, o, s)
#define BOOST_PP_WHILE_17(p,o,s) BOOST_PP_WHILE_17_C(BOOST_PP_BOOL(p(18, s)), p, o, s)
#define BOOST_PP_WHILE_18(p,o,s) BOOST_PP_WHILE_18_C(BOOST_PP_BOOL(p(19, s)), p, o, s)
#define BOOST_PP_WHILE_19(p,o,s) BOOST_PP_WHILE_19_C(BOOST_PP_BOOL(p(20, s)), p, o, s)
#define BOOST_PP_WHILE_20(p,o,s) BOOST_PP_WHILE_20_C(BOOST_PP_BOOL(p(21, s)), p, o, s)
#define BOOST_PP_WHILE_21(p,o,s) BOOST_PP_WHILE_21_C(BOOST_PP_BOOL(p(22, s)), p, o, s)
#define BOOST_PP_WHILE_22(p,o,s) BOOST_PP_WHILE_22_C(BOOST_PP_BOOL(p(23, s)), p, o, s)
#define BOOST_PP_WHILE_23(p,o,s) BOOST_PP_WHILE_23_C(BOOST_PP_BOOL(p(24, s)), p, o, s)
#define BOOST_PP_WHILE_24(p,o,s) BOOST_PP_WHILE_24_C(BOOST_PP_BOOL(p(25, s)), p, o, s)
#define BOOST_PP_WHILE_25(p,o,s) BOOST_PP_WHILE_25_C(BOOST_PP_BOOL(p(26, s)), p, o, s)
#define BOOST_PP_WHILE_26(p,o,s) BOOST_PP_WHILE_26_C(BOOST_PP_BOOL(p(27, s)), p, o, s)
#define BOOST_PP_WHILE_27(p,o,s) BOOST_PP_WHILE_27_C(BOOST_PP_BOOL(p(28, s)), p, o, s)
#define BOOST_PP_WHILE_28(p,o,s) BOOST_PP_WHILE_28_C(BOOST_PP_BOOL(p(29, s)), p, o, s)
#define BOOST_PP_WHILE_29(p,o,s) BOOST_PP_WHILE_29_C(BOOST_PP_BOOL(p(30, s)), p, o, s)
#define BOOST_PP_WHILE_30(p,o,s) BOOST_PP_WHILE_30_C(BOOST_PP_BOOL(p(31, s)), p, o, s)
#define BOOST_PP_WHILE_31(p,o,s) BOOST_PP_WHILE_31_C(BOOST_PP_BOOL(p(32, s)), p, o, s)
#define BOOST_PP_WHILE_32(p,o,s) BOOST_PP_WHILE_32_C(BOOST_PP_BOOL(p(33, s)), p, o, s)
#define BOOST_PP_WHILE_33(p,o,s) BOOST_PP_WHILE_33_C(BOOST_PP_BOOL(p(34, s)), p, o, s)
#define BOOST_PP_WHILE_34(p,o,s) BOOST_PP_WHILE_34_C(BOOST_PP_BOOL(p(35, s)), p, o, s)
#define BOOST_PP_WHILE_35(p,o,s) BOOST_PP_WHILE_35_C(BOOST_PP_BOOL(p(36, s)), p, o, s)
#define BOOST_PP_WHILE_36(p,o,s) BOOST_PP_WHILE_36_C(BOOST_PP_BOOL(p(37, s)), p, o, s)
#define BOOST_PP_WHILE_37(p,o,s) BOOST_PP_WHILE_37_C(BOOST_PP_BOOL(p(38, s)), p, o, s)
#define BOOST_PP_WHILE_38(p,o,s) BOOST_PP_WHILE_38_C(BOOST_PP_BOOL(p(39, s)), p, o, s)
#define BOOST_PP_WHILE_39(p,o,s) BOOST_PP_WHILE_39_C(BOOST_PP_BOOL(p(40, s)), p, o, s)
#define BOOST_PP_WHILE_40(p,o,s) BOOST_PP_WHILE_40_C(BOOST_PP_BOOL(p(41, s)), p, o, s)
#define BOOST_PP_WHILE_41(p,o,s) BOOST_PP_WHILE_41_C(BOOST_PP_BOOL(p(42, s)), p, o, s)
#define BOOST_PP_WHILE_42(p,o,s) BOOST_PP_WHILE_42_C(BOOST_PP_BOOL(p(43, s)), p, o, s)
#define BOOST_PP_WHILE_43(p,o,s) BOOST_PP_WHILE_43_C(BOOST_PP_BOOL(p(44, s)), p, o, s)
#define BOOST_PP_WHILE_44(p,o,s) BOOST_PP_WHILE_44_C(BOOST_PP_BOOL(p(45, s)), p, o, s)
#define BOOST_PP_WHILE_45(p,o,s) BOOST_PP_WHILE_45_C(BOOST_PP_BOOL(p(46, s)), p, o, s)
#define BOOST_PP_WHILE_46(p,o,s) BOOST_PP_WHILE_46_C(BOOST_PP_BOOL(p(47, s)), p, o, s)
#define BOOST_PP_WHILE_47(p,o,s) BOOST_PP_WHILE_47_C(BOOST_PP_BOOL(p(48, s)), p, o, s)
#define BOOST_PP_WHILE_48(p,o,s) BOOST_PP_WHILE_48_C(BOOST_PP_BOOL(p(49, s)), p, o, s)
#define BOOST_PP_WHILE_49(p,o,s) BOOST_PP_WHILE_49_C(BOOST_PP_BOOL(p(50, s)), p, o, s)
#define BOOST_PP_WHILE_50(p,o,s) BOOST_PP_WHILE_50_C(BOOST_PP_BOOL(p(51, s)), p, o, s)
#define BOOST_PP_WHILE_51(p,o,s) BOOST_PP_WHILE_51_C(BOOST_PP_BOOL(p(52, s)), p, o, s)
#define BOOST_PP_WHILE_52(p,o,s) BOOST_PP_WHILE_52_C(BOOST_PP_BOOL(p(53, s)), p, o, s)
#define BOOST_PP_WHILE_53(p,o,s) BOOST_PP_WHILE_53_C(BOOST_PP_BOOL(p(54, s)), p, o, s)
#define BOOST_PP_WHILE_54(p,o,s) BOOST_PP_WHILE_54_C(BOOST_PP_BOOL(p(55, s)), p, o, s)
#define BOOST_PP_WHILE_55(p,o,s) BOOST_PP_WHILE_55_C(BOOST_PP_BOOL(p(56, s)), p, o, s)
#define BOOST_PP_WHILE_56(p,o,s) BOOST_PP_WHILE_56_C(BOOST_PP_BOOL(p(57, s)), p, o, s)
#define BOOST_PP_WHILE_57(p,o,s) BOOST_PP_WHILE_57_C(BOOST_PP_BOOL(p(58, s)), p, o, s)
#define BOOST_PP_WHILE_58(p,o,s) BOOST_PP_WHILE_58_C(BOOST_PP_BOOL(p(59, s)), p, o, s)
#define BOOST_PP_WHILE_59(p,o,s) BOOST_PP_WHILE_59_C(BOOST_PP_BOOL(p(60, s)), p, o, s)
#define BOOST_PP_WHILE_60(p,o,s) BOOST_PP_WHILE_60_C(BOOST_PP_BOOL(p(61, s)), p, o, s)
#define BOOST_PP_WHILE_61(p,o,s) BOOST_PP_WHILE_61_C(BOOST_PP_BOOL(p(62, s)), p, o, s)
#define BOOST_PP_WHILE_62(p,o,s) BOOST_PP_WHILE_62_C(BOOST_PP_BOOL(p(63, s)), p, o, s)
#define BOOST_PP_WHILE_63(p,o,s) BOOST_PP_WHILE_63_C(BOOST_PP_BOOL(p(64, s)), p, o, s)
#define BOOST_PP_WHILE_64(p,o,s) BOOST_PP_WHILE_64_C(BOOST_PP_BOOL(p(65, s)), p, o, s)
#define BOOST_PP_WHILE_65(p,o,s) BOOST_PP_WHILE_65_C(BOOST_PP_BOOL(p(66, s)), p, o, s)
#define BOOST_PP_WHILE_66(p,o,s) BOOST_PP_WHILE_66_C(BOOST_PP_BOOL(p(67, s)), p, o, s)
#define BOOST_PP_WHILE_67(p,o,s) BOOST_PP_WHILE_67_C(BOOST_PP_BOOL(p(68, s)), p, o, s)
#define BOOST_PP_WHILE_68(p,o,s) BOOST_PP_WHILE_68_C(BOOST_PP_BOOL(p(69, s)), p, o, s)
#define BOOST_PP_WHILE_69(p,o,s) BOOST_PP_WHILE_69_C(BOOST_PP_BOOL(p(70, s)), p, o, s)
#define BOOST_PP_WHILE_70(p,o,s) BOOST_PP_WHILE_70_C(BOOST_PP_BOOL(p(71, s)), p, o, s)
#define BOOST_PP_WHILE_71(p,o,s) BOOST_PP_WHILE_71_C(BOOST_PP_BOOL(p(72, s)), p, o, s)
#define BOOST_PP_WHILE_72(p,o,s) BOOST_PP_WHILE_72_C(BOOST_PP_BOOL(p(73, s)), p, o, s)
#define BOOST_PP_WHILE_73(p,o,s) BOOST_PP_WHILE_73_C(BOOST_PP_BOOL(p(74, s)), p, o, s)
#define BOOST_PP_WHILE_74(p,o,s) BOOST_PP_WHILE_74_C(BOOST_PP_BOOL(p(75, s)), p, o, s)
#define BOOST_PP_WHILE_75(p,o,s) BOOST_PP_WHILE_75_C(BOOST_PP_BOOL(p(76, s)), p, o, s)
#define BOOST_PP_WHILE_76(p,o,s) BOOST_PP_WHILE_76_C(BOOST_PP_BOOL(p(77, s)), p, o, s)
#define BOOST_PP_WHILE_77(p,o,s) BOOST_PP_WHILE_77_C(BOOST_PP_BOOL(p(78, s)), p, o, s)
#define BOOST_PP_WHILE_78(p,o,s) BOOST_PP_WHILE_78_C(BOOST_PP_BOOL(p(79, s)), p, o, s)
#define BOOST_PP_WHILE_79(p,o,s) BOOST_PP_WHILE_79_C(BOOST_PP_BOOL(p(80, s)), p, o, s)
#define BOOST_PP_WHILE_80(p,o,s) BOOST_PP_WHILE_80_C(BOOST_PP_BOOL(p(81, s)), p, o, s)
#define BOOST_PP_WHILE_81(p,o,s) BOOST_PP_WHILE_81_C(BOOST_PP_BOOL(p(82, s)), p, o, s)
#define BOOST_PP_WHILE_82(p,o,s) BOOST_PP_WHILE_82_C(BOOST_PP_BOOL(p(83, s)), p, o, s)
#define BOOST_PP_WHILE_83(p,o,s) BOOST_PP_WHILE_83_C(BOOST_PP_BOOL(p(84, s)), p, o, s)
#define BOOST_PP_WHILE_84(p,o,s) BOOST_PP_WHILE_84_C(BOOST_PP_BOOL(p(85, s)), p, o, s)
#define BOOST_PP_WHILE_85(p,o,s) BOOST_PP_WHILE_85_C(BOOST_PP_BOOL(p(86, s)), p, o, s)
#define BOOST_PP_WHILE_86(p,o,s) BOOST_PP_WHILE_86_C(BOOST_PP_BOOL(p(87, s)), p, o, s)
#define BOOST_PP_WHILE_87(p,o,s) BOOST_PP_WHILE_87_C(BOOST_PP_BOOL(p(88, s)), p, o, s)
#define BOOST_PP_WHILE_88(p,o,s) BOOST_PP_WHILE_88_C(BOOST_PP_BOOL(p(89, s)), p, o, s)
#define BOOST_PP_WHILE_89(p,o,s) BOOST_PP_WHILE_89_C(BOOST_PP_BOOL(p(90, s)), p, o, s)
#define BOOST_PP_WHILE_90(p,o,s) BOOST_PP_WHILE_90_C(BOOST_PP_BOOL(p(91, s)), p, o, s)
#define BOOST_PP_WHILE_91(p,o,s) BOOST_PP_WHILE_91_C(BOOST_PP_BOOL(p(92, s)), p, o, s)
#define BOOST_PP_WHILE_92(p,o,s) BOOST_PP_WHILE_92_C(BOOST_PP_BOOL(p(93, s)), p, o, s)
#define BOOST_PP_WHILE_93(p,o,s) BOOST_PP_WHILE_93_C(BOOST_PP_BOOL(p(94, s)), p, o, s)
#define BOOST_PP_WHILE_94(p,o,s) BOOST_PP_WHILE_94_C(BOOST_PP_BOOL(p(95, s)), p, o, s)
#define BOOST_PP_WHILE_95(p,o,s) BOOST_PP_WHILE_95_C(BOOST_PP_BOOL(p(96, s)), p, o, s)
#define BOOST_PP_WHILE_96(p,o,s) BOOST_PP_WHILE_96_C(BOOST_PP_BOOL(p(97, s)), p, o, s)
#define BOOST_PP_WHILE_97(p,o,s) BOOST_PP_WHILE_97_C(BOOST_PP_BOOL(p(98, s)), p, o, s)
#define BOOST_PP_WHILE_98(p,o,s) BOOST_PP_WHILE_98_C(BOOST_PP_BOOL(p(99, s)), p, o, s)
#define BOOST_PP_WHILE_99(p,o,s) BOOST_PP_WHILE_99_C(BOOST_PP_BOOL(p(100, s)), p, o, s)
#define BOOST_PP_WHILE_100(p,o,s) BOOST_PP_WHILE_100_C(BOOST_PP_BOOL(p(101, s)), p, o, s)
#define BOOST_PP_WHILE_101(p,o,s) BOOST_PP_WHILE_101_C(BOOST_PP_BOOL(p(102, s)), p, o, s)
#define BOOST_PP_WHILE_102(p,o,s) BOOST_PP_WHILE_102_C(BOOST_PP_BOOL(p(103, s)), p, o, s)
#define BOOST_PP_WHILE_103(p,o,s) BOOST_PP_WHILE_103_C(BOOST_PP_BOOL(p(104, s)), p, o, s)
#define BOOST_PP_WHILE_104(p,o,s) BOOST_PP_WHILE_104_C(BOOST_PP_BOOL(p(105, s)), p, o, s)
#define BOOST_PP_WHILE_105(p,o,s) BOOST_PP_WHILE_105_C(BOOST_PP_BOOL(p(106, s)), p, o, s)
#define BOOST_PP_WHILE_106(p,o,s) BOOST_PP_WHILE_106_C(BOOST_PP_BOOL(p(107, s)), p, o, s)
#define BOOST_PP_WHILE_107(p,o,s) BOOST_PP_WHILE_107_C(BOOST_PP_BOOL(p(108, s)), p, o, s)
#define BOOST_PP_WHILE_108(p,o,s) BOOST_PP_WHILE_108_C(BOOST_PP_BOOL(p(109, s)), p, o, s)
#define BOOST_PP_WHILE_109(p,o,s) BOOST_PP_WHILE_109_C(BOOST_PP_BOOL(p(110, s)), p, o, s)
#define BOOST_PP_WHILE_110(p,o,s) BOOST_PP_WHILE_110_C(BOOST_PP_BOOL(p(111, s)), p, o, s)
#define BOOST_PP_WHILE_111(p,o,s) BOOST_PP_WHILE_111_C(BOOST_PP_BOOL(p(112, s)), p, o, s)
#define BOOST_PP_WHILE_112(p,o,s) BOOST_PP_WHILE_112_C(BOOST_PP_BOOL(p(113, s)), p, o, s)
#define BOOST_PP_WHILE_113(p,o,s) BOOST_PP_WHILE_113_C(BOOST_PP_BOOL(p(114, s)), p, o, s)
#define BOOST_PP_WHILE_114(p,o,s) BOOST_PP_WHILE_114_C(BOOST_PP_BOOL(p(115, s)), p, o, s)
#define BOOST_PP_WHILE_115(p,o,s) BOOST_PP_WHILE_115_C(BOOST_PP_BOOL(p(116, s)), p, o, s)
#define BOOST_PP_WHILE_116(p,o,s) BOOST_PP_WHILE_116_C(BOOST_PP_BOOL(p(117, s)), p, o, s)
#define BOOST_PP_WHILE_117(p,o,s) BOOST_PP_WHILE_117_C(BOOST_PP_BOOL(p(118, s)), p, o, s)
#define BOOST_PP_WHILE_118(p,o,s) BOOST_PP_WHILE_118_C(BOOST_PP_BOOL(p(119, s)), p, o, s)
#define BOOST_PP_WHILE_119(p,o,s) BOOST_PP_WHILE_119_C(BOOST_PP_BOOL(p(120, s)), p, o, s)
#define BOOST_PP_WHILE_120(p,o,s) BOOST_PP_WHILE_120_C(BOOST_PP_BOOL(p(121, s)), p, o, s)
#define BOOST_PP_WHILE_121(p,o,s) BOOST_PP_WHILE_121_C(BOOST_PP_BOOL(p(122, s)), p, o, s)
#define BOOST_PP_WHILE_122(p,o,s) BOOST_PP_WHILE_122_C(BOOST_PP_BOOL(p(123, s)), p, o, s)
#define BOOST_PP_WHILE_123(p,o,s) BOOST_PP_WHILE_123_C(BOOST_PP_BOOL(p(124, s)), p, o, s)
#define BOOST_PP_WHILE_124(p,o,s) BOOST_PP_WHILE_124_C(BOOST_PP_BOOL(p(125, s)), p, o, s)
#define BOOST_PP_WHILE_125(p,o,s) BOOST_PP_WHILE_125_C(BOOST_PP_BOOL(p(126, s)), p, o, s)
#define BOOST_PP_WHILE_126(p,o,s) BOOST_PP_WHILE_126_C(BOOST_PP_BOOL(p(127, s)), p, o, s)
#define BOOST_PP_WHILE_127(p,o,s) BOOST_PP_WHILE_127_C(BOOST_PP_BOOL(p(128, s)), p, o, s)
#define BOOST_PP_WHILE_128(p,o,s) BOOST_PP_WHILE_128_C(BOOST_PP_BOOL(p(129, s)), p, o, s)
#define BOOST_PP_WHILE_129(p,o,s) BOOST_PP_WHILE_129_C(BOOST_PP_BOOL(p(130, s)), p, o, s)
#define BOOST_PP_WHILE_130(p,o,s) BOOST_PP_WHILE_130_C(BOOST_PP_BOOL(p(131, s)), p, o, s)
#define BOOST_PP_WHILE_131(p,o,s) BOOST_PP_WHILE_131_C(BOOST_PP_BOOL(p(132, s)), p, o, s)
#define BOOST_PP_WHILE_132(p,o,s) BOOST_PP_WHILE_132_C(BOOST_PP_BOOL(p(133, s)), p, o, s)
#define BOOST_PP_WHILE_133(p,o,s) BOOST_PP_WHILE_133_C(BOOST_PP_BOOL(p(134, s)), p, o, s)
#define BOOST_PP_WHILE_134(p,o,s) BOOST_PP_WHILE_134_C(BOOST_PP_BOOL(p(135, s)), p, o, s)
#define BOOST_PP_WHILE_135(p,o,s) BOOST_PP_WHILE_135_C(BOOST_PP_BOOL(p(136, s)), p, o, s)
#define BOOST_PP_WHILE_136(p,o,s) BOOST_PP_WHILE_136_C(BOOST_PP_BOOL(p(137, s)), p, o, s)
#define BOOST_PP_WHILE_137(p,o,s) BOOST_PP_WHILE_137_C(BOOST_PP_BOOL(p(138, s)), p, o, s)
#define BOOST_PP_WHILE_138(p,o,s) BOOST_PP_WHILE_138_C(BOOST_PP_BOOL(p(139, s)), p, o, s)
#define BOOST_PP_WHILE_139(p,o,s) BOOST_PP_WHILE_139_C(BOOST_PP_BOOL(p(140, s)), p, o, s)
#define BOOST_PP_WHILE_140(p,o,s) BOOST_PP_WHILE_140_C(BOOST_PP_BOOL(p(141, s)), p, o, s)
#define BOOST_PP_WHILE_141(p,o,s) BOOST_PP_WHILE_141_C(BOOST_PP_BOOL(p(142, s)), p, o, s)
#define BOOST_PP_WHILE_142(p,o,s) BOOST_PP_WHILE_142_C(BOOST_PP_BOOL(p(143, s)), p, o, s)
#define BOOST_PP_WHILE_143(p,o,s) BOOST_PP_WHILE_143_C(BOOST_PP_BOOL(p(144, s)), p, o, s)
#define BOOST_PP_WHILE_144(p,o,s) BOOST_PP_WHILE_144_C(BOOST_PP_BOOL(p(145, s)), p, o, s)
#define BOOST_PP_WHILE_145(p,o,s) BOOST_PP_WHILE_145_C(BOOST_PP_BOOL(p(146, s)), p, o, s)
#define BOOST_PP_WHILE_146(p,o,s) BOOST_PP_WHILE_146_C(BOOST_PP_BOOL(p(147, s)), p, o, s)
#define BOOST_PP_WHILE_147(p,o,s) BOOST_PP_WHILE_147_C(BOOST_PP_BOOL(p(148, s)), p, o, s)
#define BOOST_PP_WHILE_148(p,o,s) BOOST_PP_WHILE_148_C(BOOST_PP_BOOL(p(149, s)), p, o, s)
#define BOOST_PP_WHILE_149(p,o,s) BOOST_PP_WHILE_149_C(BOOST_PP_BOOL(p(150, s)), p, o, s)
#define BOOST_PP_WHILE_150(p,o,s) BOOST_PP_WHILE_150_C(BOOST_PP_BOOL(p(151, s)), p, o, s)
#define BOOST_PP_WHILE_151(p,o,s) BOOST_PP_WHILE_151_C(BOOST_PP_BOOL(p(152, s)), p, o, s)
#define BOOST_PP_WHILE_152(p,o,s) BOOST_PP_WHILE_152_C(BOOST_PP_BOOL(p(153, s)), p, o, s)
#define BOOST_PP_WHILE_153(p,o,s) BOOST_PP_WHILE_153_C(BOOST_PP_BOOL(p(154, s)), p, o, s)
#define BOOST_PP_WHILE_154(p,o,s) BOOST_PP_WHILE_154_C(BOOST_PP_BOOL(p(155, s)), p, o, s)
#define BOOST_PP_WHILE_155(p,o,s) BOOST_PP_WHILE_155_C(BOOST_PP_BOOL(p(156, s)), p, o, s)
#define BOOST_PP_WHILE_156(p,o,s) BOOST_PP_WHILE_156_C(BOOST_PP_BOOL(p(157, s)), p, o, s)
#define BOOST_PP_WHILE_157(p,o,s) BOOST_PP_WHILE_157_C(BOOST_PP_BOOL(p(158, s)), p, o, s)
#define BOOST_PP_WHILE_158(p,o,s) BOOST_PP_WHILE_158_C(BOOST_PP_BOOL(p(159, s)), p, o, s)
#define BOOST_PP_WHILE_159(p,o,s) BOOST_PP_WHILE_159_C(BOOST_PP_BOOL(p(160, s)), p, o, s)
#define BOOST_PP_WHILE_160(p,o,s) BOOST_PP_WHILE_160_C(BOOST_PP_BOOL(p(161, s)), p, o, s)
#define BOOST_PP_WHILE_161(p,o,s) BOOST_PP_WHILE_161_C(BOOST_PP_BOOL(p(162, s)), p, o, s)
#define BOOST_PP_WHILE_162(p,o,s) BOOST_PP_WHILE_162_C(BOOST_PP_BOOL(p(163, s)), p, o, s)
#define BOOST_PP_WHILE_163(p,o,s) BOOST_PP_WHILE_163_C(BOOST_PP_BOOL(p(164, s)), p, o, s)
#define BOOST_PP_WHILE_164(p,o,s) BOOST_PP_WHILE_164_C(BOOST_PP_BOOL(p(165, s)), p, o, s)
#define BOOST_PP_WHILE_165(p,o,s) BOOST_PP_WHILE_165_C(BOOST_PP_BOOL(p(166, s)), p, o, s)
#define BOOST_PP_WHILE_166(p,o,s) BOOST_PP_WHILE_166_C(BOOST_PP_BOOL(p(167, s)), p, o, s)
#define BOOST_PP_WHILE_167(p,o,s) BOOST_PP_WHILE_167_C(BOOST_PP_BOOL(p(168, s)), p, o, s)
#define BOOST_PP_WHILE_168(p,o,s) BOOST_PP_WHILE_168_C(BOOST_PP_BOOL(p(169, s)), p, o, s)
#define BOOST_PP_WHILE_169(p,o,s) BOOST_PP_WHILE_169_C(BOOST_PP_BOOL(p(170, s)), p, o, s)
#define BOOST_PP_WHILE_170(p,o,s) BOOST_PP_WHILE_170_C(BOOST_PP_BOOL(p(171, s)), p, o, s)
#define BOOST_PP_WHILE_171(p,o,s) BOOST_PP_WHILE_171_C(BOOST_PP_BOOL(p(172, s)), p, o, s)
#define BOOST_PP_WHILE_172(p,o,s) BOOST_PP_WHILE_172_C(BOOST_PP_BOOL(p(173, s)), p, o, s)
#define BOOST_PP_WHILE_173(p,o,s) BOOST_PP_WHILE_173_C(BOOST_PP_BOOL(p(174, s)), p, o, s)
#define BOOST_PP_WHILE_174(p,o,s) BOOST_PP_WHILE_174_C(BOOST_PP_BOOL(p(175, s)), p, o, s)
#define BOOST_PP_WHILE_175(p,o,s) BOOST_PP_WHILE_175_C(BOOST_PP_BOOL(p(176, s)), p, o, s)
#define BOOST_PP_WHILE_176(p,o,s) BOOST_PP_WHILE_176_C(BOOST_PP_BOOL(p(177, s)), p, o, s)
#define BOOST_PP_WHILE_177(p,o,s) BOOST_PP_WHILE_177_C(BOOST_PP_BOOL(p(178, s)), p, o, s)
#define BOOST_PP_WHILE_178(p,o,s) BOOST_PP_WHILE_178_C(BOOST_PP_BOOL(p(179, s)), p, o, s)
#define BOOST_PP_WHILE_179(p,o,s) BOOST_PP_WHILE_179_C(BOOST_PP_BOOL(p(180, s)), p, o, s)
#define BOOST_PP_WHILE_180(p,o,s) BOOST_PP_WHILE_180_C(BOOST_PP_BOOL(p(181, s)), p, o, s)
#define BOOST_PP_WHILE_181(p,o,s) BOOST_PP_WHILE_181_C(BOOST_PP_BOOL(p(182, s)), p, o, s)
#define BOOST_PP_WHILE_182(p,o,s) BOOST_PP_WHILE_182_C(BOOST_PP_BOOL(p(183, s)), p, o, s)
#define BOOST_PP_WHILE_183(p,o,s) BOOST_PP_WHILE_183_C(BOOST_PP_BOOL(p(184, s)), p, o, s)
#define BOOST_PP_WHILE_184(p,o,s) BOOST_PP_WHILE_184_C(BOOST_PP_BOOL(p(185, s)), p, o, s)
#define BOOST_PP_WHILE_185(p,o,s) BOOST_PP_WHILE_185_C(BOOST_PP_BOOL(p(186, s)), p, o, s)
#define BOOST_PP_WHILE_186(p,o,s) BOOST_PP_WHILE_186_C(BOOST_PP_BOOL(p(187, s)), p, o, s)
#define BOOST_PP_WHILE_187(p,o,s) BOOST_PP_WHILE_187_C(BOOST_PP_BOOL(p(188, s)), p, o, s)
#define BOOST_PP_WHILE_188(p,o,s) BOOST_PP_WHILE_188_C(BOOST_PP_BOOL(p(189, s)), p, o, s)
#define BOOST_PP_WHILE_189(p,o,s) BOOST_PP_WHILE_189_C(BOOST_PP_BOOL(p(190, s)), p, o, s)
#define BOOST_PP_WHILE_190(p,o,s) BOOST_PP_WHILE_190_C(BOOST_PP_BOOL(p(191, s)), p, o, s)
#define BOOST_PP_WHILE_191(p,o,s) BOOST_PP_WHILE_191_C(BOOST_PP_BOOL(p(192, s)), p, o, s)
#define BOOST_PP_WHILE_192(p,o,s) BOOST_PP_WHILE_192_C(BOOST_PP_BOOL(p(193, s)), p, o, s)
#define BOOST_PP_WHILE_193(p,o,s) BOOST_PP_WHILE_193_C(BOOST_PP_BOOL(p(194, s)), p, o, s)
#define BOOST_PP_WHILE_194(p,o,s) BOOST_PP_WHILE_194_C(BOOST_PP_BOOL(p(195, s)), p, o, s)
#define BOOST_PP_WHILE_195(p,o,s) BOOST_PP_WHILE_195_C(BOOST_PP_BOOL(p(196, s)), p, o, s)
#define BOOST_PP_WHILE_196(p,o,s) BOOST_PP_WHILE_196_C(BOOST_PP_BOOL(p(197, s)), p, o, s)
#define BOOST_PP_WHILE_197(p,o,s) BOOST_PP_WHILE_197_C(BOOST_PP_BOOL(p(198, s)), p, o, s)
#define BOOST_PP_WHILE_198(p,o,s) BOOST_PP_WHILE_198_C(BOOST_PP_BOOL(p(199, s)), p, o, s)
#define BOOST_PP_WHILE_199(p,o,s) BOOST_PP_WHILE_199_C(BOOST_PP_BOOL(p(200, s)), p, o, s)
#define BOOST_PP_WHILE_200(p,o,s) BOOST_PP_WHILE_200_C(BOOST_PP_BOOL(p(201, s)), p, o, s)
#define BOOST_PP_WHILE_201(p,o,s) BOOST_PP_WHILE_201_C(BOOST_PP_BOOL(p(202, s)), p, o, s)
#define BOOST_PP_WHILE_202(p,o,s) BOOST_PP_WHILE_202_C(BOOST_PP_BOOL(p(203, s)), p, o, s)
#define BOOST_PP_WHILE_203(p,o,s) BOOST_PP_WHILE_203_C(BOOST_PP_BOOL(p(204, s)), p, o, s)
#define BOOST_PP_WHILE_204(p,o,s) BOOST_PP_WHILE_204_C(BOOST_PP_BOOL(p(205, s)), p, o, s)
#define BOOST_PP_WHILE_205(p,o,s) BOOST_PP_WHILE_205_C(BOOST_PP_BOOL(p(206, s)), p, o, s)
#define BOOST_PP_WHILE_206(p,o,s) BOOST_PP_WHILE_206_C(BOOST_PP_BOOL(p(207, s)), p, o, s)
#define BOOST_PP_WHILE_207(p,o,s) BOOST_PP_WHILE_207_C(BOOST_PP_BOOL(p(208, s)), p, o, s)
#define BOOST_PP_WHILE_208(p,o,s) BOOST_PP_WHILE_208_C(BOOST_PP_BOOL(p(209, s)), p, o, s)
#define BOOST_PP_WHILE_209(p,o,s) BOOST_PP_WHILE_209_C(BOOST_PP_BOOL(p(210, s)), p, o, s)
#define BOOST_PP_WHILE_210(p,o,s) BOOST_PP_WHILE_210_C(BOOST_PP_BOOL(p(211, s)), p, o, s)
#define BOOST_PP_WHILE_211(p,o,s) BOOST_PP_WHILE_211_C(BOOST_PP_BOOL(p(212, s)), p, o, s)
#define BOOST_PP_WHILE_212(p,o,s) BOOST_PP_WHILE_212_C(BOOST_PP_BOOL(p(213, s)), p, o, s)
#define BOOST_PP_WHILE_213(p,o,s) BOOST_PP_WHILE_213_C(BOOST_PP_BOOL(p(214, s)), p, o, s)
#define BOOST_PP_WHILE_214(p,o,s) BOOST_PP_WHILE_214_C(BOOST_PP_BOOL(p(215, s)), p, o, s)
#define BOOST_PP_WHILE_215(p,o,s) BOOST_PP_WHILE_215_C(BOOST_PP_BOOL(p(216, s)), p, o, s)
#define BOOST_PP_WHILE_216(p,o,s) BOOST_PP_WHILE_216_C(BOOST_PP_BOOL(p(217, s)), p, o, s)
#define BOOST_PP_WHILE_217(p,o,s) BOOST_PP_WHILE_217_C(BOOST_PP_BOOL(p(218, s)), p, o, s)
#define BOOST_PP_WHILE_218(p,o,s) BOOST_PP_WHILE_218_C(BOOST_PP_BOOL(p(219, s)), p, o, s)
#define BOOST_PP_WHILE_219(p,o,s) BOOST_PP_WHILE_219_C(BOOST_PP_BOOL(p(220, s)), p, o, s)
#define BOOST_PP_WHILE_220(p,o,s) BOOST_PP_WHILE_220_C(BOOST_PP_BOOL(p(221, s)), p, o, s)
#define BOOST_PP_WHILE_221(p,o,s) BOOST_PP_WHILE_221_C(BOOST_PP_BOOL(p(222, s)), p, o, s)
#define BOOST_PP_WHILE_222(p,o,s) BOOST_PP_WHILE_222_C(BOOST_PP_BOOL(p(223, s)), p, o, s)
#define BOOST_PP_WHILE_223(p,o,s) BOOST_PP_WHILE_223_C(BOOST_PP_BOOL(p(224, s)), p, o, s)
#define BOOST_PP_WHILE_224(p,o,s) BOOST_PP_WHILE_224_C(BOOST_PP_BOOL(p(225, s)), p, o, s)
#define BOOST_PP_WHILE_225(p,o,s) BOOST_PP_WHILE_225_C(BOOST_PP_BOOL(p(226, s)), p, o, s)
#define BOOST_PP_WHILE_226(p,o,s) BOOST_PP_WHILE_226_C(BOOST_PP_BOOL(p(227, s)), p, o, s)
#define BOOST_PP_WHILE_227(p,o,s) BOOST_PP_WHILE_227_C(BOOST_PP_BOOL(p(228, s)), p, o, s)
#define BOOST_PP_WHILE_228(p,o,s) BOOST_PP_WHILE_228_C(BOOST_PP_BOOL(p(229, s)), p, o, s)
#define BOOST_PP_WHILE_229(p,o,s) BOOST_PP_WHILE_229_C(BOOST_PP_BOOL(p(230, s)), p, o, s)
#define BOOST_PP_WHILE_230(p,o,s) BOOST_PP_WHILE_230_C(BOOST_PP_BOOL(p(231, s)), p, o, s)
#define BOOST_PP_WHILE_231(p,o,s) BOOST_PP_WHILE_231_C(BOOST_PP_BOOL(p(232, s)), p, o, s)
#define BOOST_PP_WHILE_232(p,o,s) BOOST_PP_WHILE_232_C(BOOST_PP_BOOL(p(233, s)), p, o, s)
#define BOOST_PP_WHILE_233(p,o,s) BOOST_PP_WHILE_233_C(BOOST_PP_BOOL(p(234, s)), p, o, s)
#define BOOST_PP_WHILE_234(p,o,s) BOOST_PP_WHILE_234_C(BOOST_PP_BOOL(p(235, s)), p, o, s)
#define BOOST_PP_WHILE_235(p,o,s) BOOST_PP_WHILE_235_C(BOOST_PP_BOOL(p(236, s)), p, o, s)
#define BOOST_PP_WHILE_236(p,o,s) BOOST_PP_WHILE_236_C(BOOST_PP_BOOL(p(237, s)), p, o, s)
#define BOOST_PP_WHILE_237(p,o,s) BOOST_PP_WHILE_237_C(BOOST_PP_BOOL(p(238, s)), p, o, s)
#define BOOST_PP_WHILE_238(p,o,s) BOOST_PP_WHILE_238_C(BOOST_PP_BOOL(p(239, s)), p, o, s)
#define BOOST_PP_WHILE_239(p,o,s) BOOST_PP_WHILE_239_C(BOOST_PP_BOOL(p(240, s)), p, o, s)
#define BOOST_PP_WHILE_240(p,o,s) BOOST_PP_WHILE_240_C(BOOST_PP_BOOL(p(241, s)), p, o, s)
#define BOOST_PP_WHILE_241(p,o,s) BOOST_PP_WHILE_241_C(BOOST_PP_BOOL(p(242, s)), p, o, s)
#define BOOST_PP_WHILE_242(p,o,s) BOOST_PP_WHILE_242_C(BOOST_PP_BOOL(p(243, s)), p, o, s)
#define BOOST_PP_WHILE_243(p,o,s) BOOST_PP_WHILE_243_C(BOOST_PP_BOOL(p(244, s)), p, o, s)
#define BOOST_PP_WHILE_244(p,o,s) BOOST_PP_WHILE_244_C(BOOST_PP_BOOL(p(245, s)), p, o, s)
#define BOOST_PP_WHILE_245(p,o,s) BOOST_PP_WHILE_245_C(BOOST_PP_BOOL(p(246, s)), p, o, s)
#define BOOST_PP_WHILE_246(p,o,s) BOOST_PP_WHILE_246_C(BOOST_PP_BOOL(p(247, s)), p, o, s)
#define BOOST_PP_WHILE_247(p,o,s) BOOST_PP_WHILE_247_C(BOOST_PP_BOOL(p(248, s)), p, o, s)
#define BOOST_PP_WHILE_248(p,o,s) BOOST_PP_WHILE_248_C(BOOST_PP_BOOL(p(249, s)), p, o, s)
#define BOOST_PP_WHILE_249(p,o,s) BOOST_PP_WHILE_249_C(BOOST_PP_BOOL(p(250, s)), p, o, s)
#define BOOST_PP_WHILE_250(p,o,s) BOOST_PP_WHILE_250_C(BOOST_PP_BOOL(p(251, s)), p, o, s)
#define BOOST_PP_WHILE_251(p,o,s) BOOST_PP_WHILE_251_C(BOOST_PP_BOOL(p(252, s)), p, o, s)
#define BOOST_PP_WHILE_252(p,o,s) BOOST_PP_WHILE_252_C(BOOST_PP_BOOL(p(253, s)), p, o, s)
#define BOOST_PP_WHILE_253(p,o,s) BOOST_PP_WHILE_253_C(BOOST_PP_BOOL(p(254, s)), p, o, s)
#define BOOST_PP_WHILE_254(p,o,s) BOOST_PP_WHILE_254_C(BOOST_PP_BOOL(p(255, s)), p, o, s)
#define BOOST_PP_WHILE_255(p,o,s) BOOST_PP_WHILE_255_C(BOOST_PP_BOOL(p(256, s)), p, o, s)
#define BOOST_PP_WHILE_256(p,o,s) BOOST_PP_WHILE_256_C(BOOST_PP_BOOL(p(257, s)), p, o, s)
#define BOOST_PP_WHILE_1_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_2, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(2, s))
#define BOOST_PP_WHILE_2_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_3, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(3, s))
#define BOOST_PP_WHILE_3_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_4, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(4, s))
#define BOOST_PP_WHILE_4_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_5, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(5, s))
#define BOOST_PP_WHILE_5_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_6, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(6, s))
#define BOOST_PP_WHILE_6_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_7, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(7, s))
#define BOOST_PP_WHILE_7_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_8, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(8, s))
#define BOOST_PP_WHILE_8_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_9, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(9, s))
#define BOOST_PP_WHILE_9_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_10, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(10, s))
#define BOOST_PP_WHILE_10_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_11, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(11, s))
#define BOOST_PP_WHILE_11_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_12, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(12, s))
#define BOOST_PP_WHILE_12_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_13, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(13, s))
#define BOOST_PP_WHILE_13_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_14, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(14, s))
#define BOOST_PP_WHILE_14_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_15, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(15, s))
#define BOOST_PP_WHILE_15_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_16, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(16, s))
#define BOOST_PP_WHILE_16_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_17, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(17, s))
#define BOOST_PP_WHILE_17_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_18, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(18, s))
#define BOOST_PP_WHILE_18_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_19, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(19, s))
#define BOOST_PP_WHILE_19_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_20, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(20, s))
#define BOOST_PP_WHILE_20_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_21, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(21, s))
#define BOOST_PP_WHILE_21_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_22, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(22, s))
#define BOOST_PP_WHILE_22_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_23, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(23, s))
#define BOOST_PP_WHILE_23_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_24, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(24, s))
#define BOOST_PP_WHILE_24_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_25, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(25, s))
#define BOOST_PP_WHILE_25_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_26, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(26, s))
#define BOOST_PP_WHILE_26_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_27, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(27, s))
#define BOOST_PP_WHILE_27_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_28, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(28, s))
#define BOOST_PP_WHILE_28_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_29, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(29, s))
#define BOOST_PP_WHILE_29_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_30, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(30, s))
#define BOOST_PP_WHILE_30_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_31, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(31, s))
#define BOOST_PP_WHILE_31_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_32, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(32, s))
#define BOOST_PP_WHILE_32_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_33, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(33, s))
#define BOOST_PP_WHILE_33_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_34, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(34, s))
#define BOOST_PP_WHILE_34_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_35, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(35, s))
#define BOOST_PP_WHILE_35_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_36, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(36, s))
#define BOOST_PP_WHILE_36_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_37, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(37, s))
#define BOOST_PP_WHILE_37_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_38, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(38, s))
#define BOOST_PP_WHILE_38_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_39, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(39, s))
#define BOOST_PP_WHILE_39_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_40, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(40, s))
#define BOOST_PP_WHILE_40_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_41, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(41, s))
#define BOOST_PP_WHILE_41_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_42, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(42, s))
#define BOOST_PP_WHILE_42_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_43, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(43, s))
#define BOOST_PP_WHILE_43_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_44, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(44, s))
#define BOOST_PP_WHILE_44_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_45, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(45, s))
#define BOOST_PP_WHILE_45_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_46, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(46, s))
#define BOOST_PP_WHILE_46_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_47, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(47, s))
#define BOOST_PP_WHILE_47_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_48, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(48, s))
#define BOOST_PP_WHILE_48_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_49, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(49, s))
#define BOOST_PP_WHILE_49_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_50, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(50, s))
#define BOOST_PP_WHILE_50_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_51, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(51, s))
#define BOOST_PP_WHILE_51_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_52, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(52, s))
#define BOOST_PP_WHILE_52_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_53, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(53, s))
#define BOOST_PP_WHILE_53_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_54, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(54, s))
#define BOOST_PP_WHILE_54_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_55, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(55, s))
#define BOOST_PP_WHILE_55_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_56, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(56, s))
#define BOOST_PP_WHILE_56_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_57, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(57, s))
#define BOOST_PP_WHILE_57_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_58, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(58, s))
#define BOOST_PP_WHILE_58_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_59, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(59, s))
#define BOOST_PP_WHILE_59_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_60, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(60, s))
#define BOOST_PP_WHILE_60_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_61, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(61, s))
#define BOOST_PP_WHILE_61_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_62, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(62, s))
#define BOOST_PP_WHILE_62_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_63, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(63, s))
#define BOOST_PP_WHILE_63_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_64, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(64, s))
#define BOOST_PP_WHILE_64_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_65, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(65, s))
#define BOOST_PP_WHILE_65_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_66, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(66, s))
#define BOOST_PP_WHILE_66_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_67, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(67, s))
#define BOOST_PP_WHILE_67_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_68, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(68, s))
#define BOOST_PP_WHILE_68_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_69, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(69, s))
#define BOOST_PP_WHILE_69_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_70, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(70, s))
#define BOOST_PP_WHILE_70_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_71, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(71, s))
#define BOOST_PP_WHILE_71_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_72, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(72, s))
#define BOOST_PP_WHILE_72_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_73, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(73, s))
#define BOOST_PP_WHILE_73_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_74, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(74, s))
#define BOOST_PP_WHILE_74_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_75, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(75, s))
#define BOOST_PP_WHILE_75_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_76, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(76, s))
#define BOOST_PP_WHILE_76_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_77, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(77, s))
#define BOOST_PP_WHILE_77_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_78, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(78, s))
#define BOOST_PP_WHILE_78_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_79, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(79, s))
#define BOOST_PP_WHILE_79_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_80, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(80, s))
#define BOOST_PP_WHILE_80_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_81, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(81, s))
#define BOOST_PP_WHILE_81_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_82, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(82, s))
#define BOOST_PP_WHILE_82_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_83, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(83, s))
#define BOOST_PP_WHILE_83_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_84, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(84, s))
#define BOOST_PP_WHILE_84_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_85, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(85, s))
#define BOOST_PP_WHILE_85_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_86, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(86, s))
#define BOOST_PP_WHILE_86_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_87, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(87, s))
#define BOOST_PP_WHILE_87_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_88, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(88, s))
#define BOOST_PP_WHILE_88_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_89, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(89, s))
#define BOOST_PP_WHILE_89_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_90, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(90, s))
#define BOOST_PP_WHILE_90_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_91, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(91, s))
#define BOOST_PP_WHILE_91_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_92, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(92, s))
#define BOOST_PP_WHILE_92_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_93, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(93, s))
#define BOOST_PP_WHILE_93_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_94, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(94, s))
#define BOOST_PP_WHILE_94_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_95, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(95, s))
#define BOOST_PP_WHILE_95_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_96, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(96, s))
#define BOOST_PP_WHILE_96_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_97, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(97, s))
#define BOOST_PP_WHILE_97_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_98, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(98, s))
#define BOOST_PP_WHILE_98_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_99, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(99, s))
#define BOOST_PP_WHILE_99_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_100, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(100, s))
#define BOOST_PP_WHILE_100_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_101, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(101, s))
#define BOOST_PP_WHILE_101_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_102, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(102, s))
#define BOOST_PP_WHILE_102_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_103, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(103, s))
#define BOOST_PP_WHILE_103_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_104, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(104, s))
#define BOOST_PP_WHILE_104_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_105, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(105, s))
#define BOOST_PP_WHILE_105_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_106, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(106, s))
#define BOOST_PP_WHILE_106_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_107, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(107, s))
#define BOOST_PP_WHILE_107_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_108, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(108, s))
#define BOOST_PP_WHILE_108_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_109, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(109, s))
#define BOOST_PP_WHILE_109_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_110, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(110, s))
#define BOOST_PP_WHILE_110_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_111, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(111, s))
#define BOOST_PP_WHILE_111_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_112, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(112, s))
#define BOOST_PP_WHILE_112_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_113, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(113, s))
#define BOOST_PP_WHILE_113_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_114, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(114, s))
#define BOOST_PP_WHILE_114_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_115, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(115, s))
#define BOOST_PP_WHILE_115_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_116, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(116, s))
#define BOOST_PP_WHILE_116_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_117, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(117, s))
#define BOOST_PP_WHILE_117_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_118, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(118, s))
#define BOOST_PP_WHILE_118_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_119, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(119, s))
#define BOOST_PP_WHILE_119_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_120, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(120, s))
#define BOOST_PP_WHILE_120_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_121, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(121, s))
#define BOOST_PP_WHILE_121_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_122, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(122, s))
#define BOOST_PP_WHILE_122_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_123, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(123, s))
#define BOOST_PP_WHILE_123_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_124, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(124, s))
#define BOOST_PP_WHILE_124_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_125, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(125, s))
#define BOOST_PP_WHILE_125_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_126, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(126, s))
#define BOOST_PP_WHILE_126_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_127, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(127, s))
#define BOOST_PP_WHILE_127_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_128, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(128, s))
#define BOOST_PP_WHILE_128_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_129, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(129, s))
#define BOOST_PP_WHILE_129_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_130, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(130, s))
#define BOOST_PP_WHILE_130_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_131, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(131, s))
#define BOOST_PP_WHILE_131_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_132, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(132, s))
#define BOOST_PP_WHILE_132_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_133, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(133, s))
#define BOOST_PP_WHILE_133_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_134, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(134, s))
#define BOOST_PP_WHILE_134_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_135, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(135, s))
#define BOOST_PP_WHILE_135_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_136, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(136, s))
#define BOOST_PP_WHILE_136_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_137, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(137, s))
#define BOOST_PP_WHILE_137_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_138, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(138, s))
#define BOOST_PP_WHILE_138_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_139, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(139, s))
#define BOOST_PP_WHILE_139_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_140, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(140, s))
#define BOOST_PP_WHILE_140_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_141, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(141, s))
#define BOOST_PP_WHILE_141_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_142, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(142, s))
#define BOOST_PP_WHILE_142_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_143, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(143, s))
#define BOOST_PP_WHILE_143_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_144, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(144, s))
#define BOOST_PP_WHILE_144_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_145, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(145, s))
#define BOOST_PP_WHILE_145_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_146, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(146, s))
#define BOOST_PP_WHILE_146_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_147, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(147, s))
#define BOOST_PP_WHILE_147_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_148, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(148, s))
#define BOOST_PP_WHILE_148_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_149, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(149, s))
#define BOOST_PP_WHILE_149_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_150, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(150, s))
#define BOOST_PP_WHILE_150_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_151, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(151, s))
#define BOOST_PP_WHILE_151_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_152, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(152, s))
#define BOOST_PP_WHILE_152_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_153, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(153, s))
#define BOOST_PP_WHILE_153_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_154, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(154, s))
#define BOOST_PP_WHILE_154_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_155, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(155, s))
#define BOOST_PP_WHILE_155_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_156, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(156, s))
#define BOOST_PP_WHILE_156_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_157, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(157, s))
#define BOOST_PP_WHILE_157_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_158, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(158, s))
#define BOOST_PP_WHILE_158_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_159, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(159, s))
#define BOOST_PP_WHILE_159_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_160, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(160, s))
#define BOOST_PP_WHILE_160_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_161, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(161, s))
#define BOOST_PP_WHILE_161_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_162, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(162, s))
#define BOOST_PP_WHILE_162_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_163, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(163, s))
#define BOOST_PP_WHILE_163_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_164, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(164, s))
#define BOOST_PP_WHILE_164_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_165, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(165, s))
#define BOOST_PP_WHILE_165_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_166, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(166, s))
#define BOOST_PP_WHILE_166_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_167, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(167, s))
#define BOOST_PP_WHILE_167_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_168, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(168, s))
#define BOOST_PP_WHILE_168_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_169, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(169, s))
#define BOOST_PP_WHILE_169_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_170, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(170, s))
#define BOOST_PP_WHILE_170_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_171, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(171, s))
#define BOOST_PP_WHILE_171_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_172, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(172, s))
#define BOOST_PP_WHILE_172_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_173, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(173, s))
#define BOOST_PP_WHILE_173_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_174, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(174, s))
#define BOOST_PP_WHILE_174_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_175, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(175, s))
#define BOOST_PP_WHILE_175_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_176, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(176, s))
#define BOOST_PP_WHILE_176_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_177, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(177, s))
#define BOOST_PP_WHILE_177_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_178, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(178, s))
#define BOOST_PP_WHILE_178_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_179, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(179, s))
#define BOOST_PP_WHILE_179_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_180, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(180, s))
#define BOOST_PP_WHILE_180_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_181, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(181, s))
#define BOOST_PP_WHILE_181_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_182, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(182, s))
#define BOOST_PP_WHILE_182_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_183, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(183, s))
#define BOOST_PP_WHILE_183_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_184, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(184, s))
#define BOOST_PP_WHILE_184_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_185, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(185, s))
#define BOOST_PP_WHILE_185_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_186, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(186, s))
#define BOOST_PP_WHILE_186_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_187, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(187, s))
#define BOOST_PP_WHILE_187_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_188, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(188, s))
#define BOOST_PP_WHILE_188_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_189, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(189, s))
#define BOOST_PP_WHILE_189_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_190, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(190, s))
#define BOOST_PP_WHILE_190_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_191, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(191, s))
#define BOOST_PP_WHILE_191_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_192, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(192, s))
#define BOOST_PP_WHILE_192_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_193, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(193, s))
#define BOOST_PP_WHILE_193_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_194, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(194, s))
#define BOOST_PP_WHILE_194_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_195, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(195, s))
#define BOOST_PP_WHILE_195_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_196, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(196, s))
#define BOOST_PP_WHILE_196_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_197, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(197, s))
#define BOOST_PP_WHILE_197_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_198, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(198, s))
#define BOOST_PP_WHILE_198_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_199, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(199, s))
#define BOOST_PP_WHILE_199_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_200, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(200, s))
#define BOOST_PP_WHILE_200_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_201, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(201, s))
#define BOOST_PP_WHILE_201_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_202, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(202, s))
#define BOOST_PP_WHILE_202_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_203, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(203, s))
#define BOOST_PP_WHILE_203_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_204, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(204, s))
#define BOOST_PP_WHILE_204_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_205, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(205, s))
#define BOOST_PP_WHILE_205_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_206, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(206, s))
#define BOOST_PP_WHILE_206_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_207, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(207, s))
#define BOOST_PP_WHILE_207_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_208, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(208, s))
#define BOOST_PP_WHILE_208_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_209, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(209, s))
#define BOOST_PP_WHILE_209_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_210, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(210, s))
#define BOOST_PP_WHILE_210_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_211, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(211, s))
#define BOOST_PP_WHILE_211_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_212, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(212, s))
#define BOOST_PP_WHILE_212_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_213, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(213, s))
#define BOOST_PP_WHILE_213_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_214, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(214, s))
#define BOOST_PP_WHILE_214_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_215, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(215, s))
#define BOOST_PP_WHILE_215_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_216, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(216, s))
#define BOOST_PP_WHILE_216_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_217, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(217, s))
#define BOOST_PP_WHILE_217_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_218, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(218, s))
#define BOOST_PP_WHILE_218_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_219, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(219, s))
#define BOOST_PP_WHILE_219_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_220, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(220, s))
#define BOOST_PP_WHILE_220_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_221, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(221, s))
#define BOOST_PP_WHILE_221_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_222, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(222, s))
#define BOOST_PP_WHILE_222_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_223, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(223, s))
#define BOOST_PP_WHILE_223_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_224, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(224, s))
#define BOOST_PP_WHILE_224_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_225, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(225, s))
#define BOOST_PP_WHILE_225_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_226, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(226, s))
#define BOOST_PP_WHILE_226_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_227, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(227, s))
#define BOOST_PP_WHILE_227_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_228, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(228, s))
#define BOOST_PP_WHILE_228_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_229, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(229, s))
#define BOOST_PP_WHILE_229_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_230, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(230, s))
#define BOOST_PP_WHILE_230_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_231, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(231, s))
#define BOOST_PP_WHILE_231_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_232, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(232, s))
#define BOOST_PP_WHILE_232_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_233, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(233, s))
#define BOOST_PP_WHILE_233_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_234, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(234, s))
#define BOOST_PP_WHILE_234_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_235, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(235, s))
#define BOOST_PP_WHILE_235_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_236, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(236, s))
#define BOOST_PP_WHILE_236_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_237, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(237, s))
#define BOOST_PP_WHILE_237_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_238, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(238, s))
#define BOOST_PP_WHILE_238_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_239, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(239, s))
#define BOOST_PP_WHILE_239_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_240, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(240, s))
#define BOOST_PP_WHILE_240_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_241, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(241, s))
#define BOOST_PP_WHILE_241_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_242, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(242, s))
#define BOOST_PP_WHILE_242_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_243, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(243, s))
#define BOOST_PP_WHILE_243_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_244, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(244, s))
#define BOOST_PP_WHILE_244_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_245, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(245, s))
#define BOOST_PP_WHILE_245_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_246, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(246, s))
#define BOOST_PP_WHILE_246_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_247, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(247, s))
#define BOOST_PP_WHILE_247_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_248, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(248, s))
#define BOOST_PP_WHILE_248_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_249, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(249, s))
#define BOOST_PP_WHILE_249_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_250, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(250, s))
#define BOOST_PP_WHILE_250_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_251, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(251, s))
#define BOOST_PP_WHILE_251_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_252, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(252, s))
#define BOOST_PP_WHILE_252_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_253, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(253, s))
#define BOOST_PP_WHILE_253_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_254, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(254, s))
#define BOOST_PP_WHILE_254_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_255, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(255, s))
#define BOOST_PP_WHILE_255_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_256, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(256, s))
#define BOOST_PP_WHILE_256_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_257, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(257, s))
#define BOOST_PP_WHILE_257(p,o,s) BOOST_PP_ERROR(0x0001)
#define BOOST_PP_WHILE_CHECK_BOOST_PP_NIL 1
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_1(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_2(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_3(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_4(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_5(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_6(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_7(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_8(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_9(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_10(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_11(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_12(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_13(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_14(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_15(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_16(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_17(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_18(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_19(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_20(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_21(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_22(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_23(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_24(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_25(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_26(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_27(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_28(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_29(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_30(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_31(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_32(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_33(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_34(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_35(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_36(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_37(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_38(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_39(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_40(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_41(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_42(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_43(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_44(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_45(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_46(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_47(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_48(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_49(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_50(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_51(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_52(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_53(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_54(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_55(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_56(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_57(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_58(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_59(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_60(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_61(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_62(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_63(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_64(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_65(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_66(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_67(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_68(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_69(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_70(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_71(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_72(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_73(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_74(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_75(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_76(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_77(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_78(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_79(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_80(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_81(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_82(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_83(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_84(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_85(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_86(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_87(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_88(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_89(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_90(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_91(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_92(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_93(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_94(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_95(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_96(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_97(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_98(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_99(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_100(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_101(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_102(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_103(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_104(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_105(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_106(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_107(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_108(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_109(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_110(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_111(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_112(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_113(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_114(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_115(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_116(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_117(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_118(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_119(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_120(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_121(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_122(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_123(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_124(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_125(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_126(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_127(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_128(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_129(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_130(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_131(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_132(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_133(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_134(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_135(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_136(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_137(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_138(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_139(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_140(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_141(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_142(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_143(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_144(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_145(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_146(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_147(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_148(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_149(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_150(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_151(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_152(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_153(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_154(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_155(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_156(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_157(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_158(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_159(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_160(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_161(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_162(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_163(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_164(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_165(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_166(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_167(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_168(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_169(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_170(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_171(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_172(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_173(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_174(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_175(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_176(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_177(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_178(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_179(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_180(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_181(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_182(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_183(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_184(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_185(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_186(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_187(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_188(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_189(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_190(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_191(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_192(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_193(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_194(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_195(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_196(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_197(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_198(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_199(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_200(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_201(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_202(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_203(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_204(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_205(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_206(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_207(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_208(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_209(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_210(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_211(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_212(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_213(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_214(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_215(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_216(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_217(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_218(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_219(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_220(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_221(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_222(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_223(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_224(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_225(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_226(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_227(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_228(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_229(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_230(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_231(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_232(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_233(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_234(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_235(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_236(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_237(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_238(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_239(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_240(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_241(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_242(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_243(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_244(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_245(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_246(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_247(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_248(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_249(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_250(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_251(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_252(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_253(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_254(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_255(p,o,s) 0
#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_256(p,o,s) 0
#define BOOST_PREPROCESSOR_TUPLE_ELEM_HPP
#define BOOST_PREPROCESSOR_FACILITIES_OVERLOAD_HPP
#define BOOST_PREPROCESSOR_VARIADIC_SIZE_HPP
#define BOOST_PP_VARIADIC_SIZE(...) BOOST_PP_VARIADIC_SIZE_I(__VA_ARGS__, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,)
#define BOOST_PP_VARIADIC_SIZE_I(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62,e63,size,...) size
#define BOOST_PP_OVERLOAD(prefix,...) BOOST_PP_CAT(prefix, BOOST_PP_VARIADIC_SIZE(__VA_ARGS__))
#define BOOST_PREPROCESSOR_TUPLE_REM_HPP
#define BOOST_PP_REM(...) __VA_ARGS__
#define BOOST_PP_TUPLE_REM(size) BOOST_PP_REM
#define BOOST_PP_TUPLE_REM_0()
#define BOOST_PP_TUPLE_REM_1(e0) e0
#define BOOST_PP_TUPLE_REM_2(e0,e1) e0, e1
#define BOOST_PP_TUPLE_REM_3(e0,e1,e2) e0, e1, e2
#define BOOST_PP_TUPLE_REM_4(e0,e1,e2,e3) e0, e1, e2, e3
#define BOOST_PP_TUPLE_REM_5(e0,e1,e2,e3,e4) e0, e1, e2, e3, e4
#define BOOST_PP_TUPLE_REM_6(e0,e1,e2,e3,e4,e5) e0, e1, e2, e3, e4, e5
#define BOOST_PP_TUPLE_REM_7(e0,e1,e2,e3,e4,e5,e6) e0, e1, e2, e3, e4, e5, e6
#define BOOST_PP_TUPLE_REM_8(e0,e1,e2,e3,e4,e5,e6,e7) e0, e1, e2, e3, e4, e5, e6, e7
#define BOOST_PP_TUPLE_REM_9(e0,e1,e2,e3,e4,e5,e6,e7,e8) e0, e1, e2, e3, e4, e5, e6, e7, e8
#define BOOST_PP_TUPLE_REM_10(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9
#define BOOST_PP_TUPLE_REM_11(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10
#define BOOST_PP_TUPLE_REM_12(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11
#define BOOST_PP_TUPLE_REM_13(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12
#define BOOST_PP_TUPLE_REM_14(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13
#define BOOST_PP_TUPLE_REM_15(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14
#define BOOST_PP_TUPLE_REM_16(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15
#define BOOST_PP_TUPLE_REM_17(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16
#define BOOST_PP_TUPLE_REM_18(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17
#define BOOST_PP_TUPLE_REM_19(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18
#define BOOST_PP_TUPLE_REM_20(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19
#define BOOST_PP_TUPLE_REM_21(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20
#define BOOST_PP_TUPLE_REM_22(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21
#define BOOST_PP_TUPLE_REM_23(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22
#define BOOST_PP_TUPLE_REM_24(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23
#define BOOST_PP_TUPLE_REM_25(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24
#define BOOST_PP_TUPLE_REM_26(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25
#define BOOST_PP_TUPLE_REM_27(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26
#define BOOST_PP_TUPLE_REM_28(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27
#define BOOST_PP_TUPLE_REM_29(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28
#define BOOST_PP_TUPLE_REM_30(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29
#define BOOST_PP_TUPLE_REM_31(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30
#define BOOST_PP_TUPLE_REM_32(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31
#define BOOST_PP_TUPLE_REM_33(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32
#define BOOST_PP_TUPLE_REM_34(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33
#define BOOST_PP_TUPLE_REM_35(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34
#define BOOST_PP_TUPLE_REM_36(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35
#define BOOST_PP_TUPLE_REM_37(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36
#define BOOST_PP_TUPLE_REM_38(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37
#define BOOST_PP_TUPLE_REM_39(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38
#define BOOST_PP_TUPLE_REM_40(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39
#define BOOST_PP_TUPLE_REM_41(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40
#define BOOST_PP_TUPLE_REM_42(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41
#define BOOST_PP_TUPLE_REM_43(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42
#define BOOST_PP_TUPLE_REM_44(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43
#define BOOST_PP_TUPLE_REM_45(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44
#define BOOST_PP_TUPLE_REM_46(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45
#define BOOST_PP_TUPLE_REM_47(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46
#define BOOST_PP_TUPLE_REM_48(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47
#define BOOST_PP_TUPLE_REM_49(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48
#define BOOST_PP_TUPLE_REM_50(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49
#define BOOST_PP_TUPLE_REM_51(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50
#define BOOST_PP_TUPLE_REM_52(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51
#define BOOST_PP_TUPLE_REM_53(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52
#define BOOST_PP_TUPLE_REM_54(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53
#define BOOST_PP_TUPLE_REM_55(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54
#define BOOST_PP_TUPLE_REM_56(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55
#define BOOST_PP_TUPLE_REM_57(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56
#define BOOST_PP_TUPLE_REM_58(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57
#define BOOST_PP_TUPLE_REM_59(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58
#define BOOST_PP_TUPLE_REM_60(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59
#define BOOST_PP_TUPLE_REM_61(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60
#define BOOST_PP_TUPLE_REM_62(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61
#define BOOST_PP_TUPLE_REM_63(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62
#define BOOST_PP_TUPLE_REM_64(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62,e63) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63
#define BOOST_PP_TUPLE_REM_CTOR(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_REM_CTOR_O_, __VA_ARGS__)(__VA_ARGS__)
#define BOOST_PP_TUPLE_REM_CTOR_O_1(tuple) BOOST_PP_REM tuple
#define BOOST_PP_TUPLE_REM_CTOR_O_2(size,tuple) BOOST_PP_TUPLE_REM_CTOR_O_1(tuple)
#define BOOST_PREPROCESSOR_VARIADIC_ELEM_HPP
#define BOOST_PP_VARIADIC_ELEM(n,...) BOOST_PP_CAT(BOOST_PP_VARIADIC_ELEM_, n)(__VA_ARGS__,)
#define BOOST_PP_VARIADIC_ELEM_0(e0,...) e0
#define BOOST_PP_VARIADIC_ELEM_1(e0,e1,...) e1
#define BOOST_PP_VARIADIC_ELEM_2(e0,e1,e2,...) e2
#define BOOST_PP_VARIADIC_ELEM_3(e0,e1,e2,e3,...) e3
#define BOOST_PP_VARIADIC_ELEM_4(e0,e1,e2,e3,e4,...) e4
#define BOOST_PP_VARIADIC_ELEM_5(e0,e1,e2,e3,e4,e5,...) e5
#define BOOST_PP_VARIADIC_ELEM_6(e0,e1,e2,e3,e4,e5,e6,...) e6
#define BOOST_PP_VARIADIC_ELEM_7(e0,e1,e2,e3,e4,e5,e6,e7,...) e7
#define BOOST_PP_VARIADIC_ELEM_8(e0,e1,e2,e3,e4,e5,e6,e7,e8,...) e8
#define BOOST_PP_VARIADIC_ELEM_9(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,...) e9
#define BOOST_PP_VARIADIC_ELEM_10(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,...) e10
#define BOOST_PP_VARIADIC_ELEM_11(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,...) e11
#define BOOST_PP_VARIADIC_ELEM_12(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,...) e12
#define BOOST_PP_VARIADIC_ELEM_13(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,...) e13
#define BOOST_PP_VARIADIC_ELEM_14(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,...) e14
#define BOOST_PP_VARIADIC_ELEM_15(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,...) e15
#define BOOST_PP_VARIADIC_ELEM_16(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,...) e16
#define BOOST_PP_VARIADIC_ELEM_17(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,...) e17
#define BOOST_PP_VARIADIC_ELEM_18(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,...) e18
#define BOOST_PP_VARIADIC_ELEM_19(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,...) e19
#define BOOST_PP_VARIADIC_ELEM_20(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,...) e20
#define BOOST_PP_VARIADIC_ELEM_21(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,...) e21
#define BOOST_PP_VARIADIC_ELEM_22(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,...) e22
#define BOOST_PP_VARIADIC_ELEM_23(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,...) e23
#define BOOST_PP_VARIADIC_ELEM_24(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,...) e24
#define BOOST_PP_VARIADIC_ELEM_25(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,...) e25
#define BOOST_PP_VARIADIC_ELEM_26(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,...) e26
#define BOOST_PP_VARIADIC_ELEM_27(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,...) e27
#define BOOST_PP_VARIADIC_ELEM_28(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,...) e28
#define BOOST_PP_VARIADIC_ELEM_29(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,...) e29
#define BOOST_PP_VARIADIC_ELEM_30(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,...) e30
#define BOOST_PP_VARIADIC_ELEM_31(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,...) e31
#define BOOST_PP_VARIADIC_ELEM_32(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,...) e32
#define BOOST_PP_VARIADIC_ELEM_33(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,...) e33
#define BOOST_PP_VARIADIC_ELEM_34(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,...) e34
#define BOOST_PP_VARIADIC_ELEM_35(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,...) e35
#define BOOST_PP_VARIADIC_ELEM_36(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,...) e36
#define BOOST_PP_VARIADIC_ELEM_37(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,...) e37
#define BOOST_PP_VARIADIC_ELEM_38(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,...) e38
#define BOOST_PP_VARIADIC_ELEM_39(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,...) e39
#define BOOST_PP_VARIADIC_ELEM_40(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,...) e40
#define BOOST_PP_VARIADIC_ELEM_41(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,...) e41
#define BOOST_PP_VARIADIC_ELEM_42(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,...) e42
#define BOOST_PP_VARIADIC_ELEM_43(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,...) e43
#define BOOST_PP_VARIADIC_ELEM_44(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,...) e44
#define BOOST_PP_VARIADIC_ELEM_45(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,...) e45
#define BOOST_PP_VARIADIC_ELEM_46(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,...) e46
#define BOOST_PP_VARIADIC_ELEM_47(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,...) e47
#define BOOST_PP_VARIADIC_ELEM_48(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,...) e48
#define BOOST_PP_VARIADIC_ELEM_49(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,...) e49
#define BOOST_PP_VARIADIC_ELEM_50(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,...) e50
#define BOOST_PP_VARIADIC_ELEM_51(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,...) e51
#define BOOST_PP_VARIADIC_ELEM_52(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,...) e52
#define BOOST_PP_VARIADIC_ELEM_53(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,...) e53
#define BOOST_PP_VARIADIC_ELEM_54(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,...) e54
#define BOOST_PP_VARIADIC_ELEM_55(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,...) e55
#define BOOST_PP_VARIADIC_ELEM_56(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,...) e56
#define BOOST_PP_VARIADIC_ELEM_57(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,...) e57
#define BOOST_PP_VARIADIC_ELEM_58(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,...) e58
#define BOOST_PP_VARIADIC_ELEM_59(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,...) e59
#define BOOST_PP_VARIADIC_ELEM_60(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,...) e60
#define BOOST_PP_VARIADIC_ELEM_61(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,...) e61
#define BOOST_PP_VARIADIC_ELEM_62(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62,...) e62
#define BOOST_PP_VARIADIC_ELEM_63(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62,e63,...) e63
#define BOOST_PP_TUPLE_ELEM(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_ELEM_O_, __VA_ARGS__)(__VA_ARGS__)
#define BOOST_PP_TUPLE_ELEM_O_2(n,tuple) BOOST_PP_VARIADIC_ELEM(n, BOOST_PP_REM tuple)
#define BOOST_PP_TUPLE_ELEM_O_3(size,n,tuple) BOOST_PP_TUPLE_ELEM_O_2(n, tuple)
#define BOOST_PP_TUPLE_ELEM_1_0(a) a
#define BOOST_PP_TUPLE_ELEM_2_0(a,b) a
#define BOOST_PP_TUPLE_ELEM_2_1(a,b) b
#define BOOST_PP_TUPLE_ELEM_3_0(a,b,c) a
#define BOOST_PP_TUPLE_ELEM_3_1(a,b,c) b
#define BOOST_PP_TUPLE_ELEM_3_2(a,b,c) c
#define BOOST_PP_ADD(x,y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_ADD_P, BOOST_PP_ADD_O, (x, y)))
#define BOOST_PP_ADD_P(d,xy) BOOST_PP_TUPLE_ELEM(2, 1, xy)
#define BOOST_PP_ADD_O(d,xy) BOOST_PP_ADD_O_I xy
#define BOOST_PP_ADD_O_I(x,y) (BOOST_PP_INC(x), BOOST_PP_DEC(y))
#define BOOST_PP_ADD_D(d,x,y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_ADD_P, BOOST_PP_ADD_O, (x, y)))
#define BOOST_PREPROCESSOR_ARITHMETIC_SUB_HPP
#define BOOST_PP_SUB(x,y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_SUB_P, BOOST_PP_SUB_O, (x, y)))
#define BOOST_PP_SUB_P(d,xy) BOOST_PP_TUPLE_ELEM(2, 1, xy)
#define BOOST_PP_SUB_O(d,xy) BOOST_PP_SUB_O_I xy
#define BOOST_PP_SUB_O_I(x,y) (BOOST_PP_DEC(x), BOOST_PP_DEC(y))
#define BOOST_PP_SUB_D(d,x,y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_SUB_P, BOOST_PP_SUB_O, (x, y)))
#define BOOST_MPL_PP_AUX_TAIL_PARAM_FUNC(unused,i,op) , BOOST_PP_CAT( BOOST_PP_TUPLE_ELEM(3, 1, op) , BOOST_PP_ADD_D(1, i, BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(3, 0, op))) ) BOOST_PP_TUPLE_ELEM(3, 2, op)()
#define BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i,param,value_func) BOOST_PP_REPEAT( BOOST_PP_SUB_D(1, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, i) , BOOST_MPL_PP_AUX_TAIL_PARAM_FUNC , (i, param, value_func) )
#define BOOST_MPL_PP_DEF_PARAMS_TAIL(i,param,value) BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, BOOST_PP_IDENTITY(=value))
#define BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(i,param,value) BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, BOOST_PP_IDENTITY(=value))
#define BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED
#define BOOST_MPL_AUX_NA_PARAMS(i) BOOST_MPL_PP_ENUM(i, na)
#define BOOST_MPL_AUX_NA_SPEC_ARITY(i,name)
#define BOOST_MPL_AUX_NA_SPEC_MAIN(i,name) template<> struct name< BOOST_MPL_AUX_NA_PARAMS(i) > { template< BOOST_MPL_PP_PARAMS(i, typename T) BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(i, typename T, na) > struct apply : name< BOOST_MPL_PP_PARAMS(i, T) > { }; };
#define BOOST_MPL_AUX_NA_SPEC_LAMBDA(i,name) template< typename Tag > struct lambda< name< BOOST_MPL_AUX_NA_PARAMS(i) > , Tag BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(int_<-1>) > { typedef false_ is_le; typedef name< BOOST_MPL_AUX_NA_PARAMS(i) > result_; typedef name< BOOST_MPL_AUX_NA_PARAMS(i) > type; };
#define BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i,j,name) namespace aux { template< BOOST_MPL_PP_PARAMS(j, typename T) > struct template_arity< name< BOOST_MPL_PP_PARAMS(j, T) > > : int_<j> { }; template<> struct template_arity< name< BOOST_MPL_PP_ENUM(i, na) > > : int_<-1> { }; }
#define BOOST_MPL_AUX_NA_SPEC_ETI(i,name)
#define BOOST_MPL_AUX_NA_PARAM(param) param = na
#define BOOST_MPL_AUX_NA_SPEC_NO_ETI(i,name) BOOST_MPL_AUX_NA_SPEC_MAIN(i, name) BOOST_MPL_AUX_NA_SPEC_LAMBDA(i, name) BOOST_MPL_AUX_NA_SPEC_ARITY(i, name) BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i, i, name)
#define BOOST_MPL_AUX_NA_SPEC(i,name) BOOST_MPL_AUX_NA_SPEC_NO_ETI(i, name) BOOST_MPL_AUX_NA_SPEC_ETI(i, name)
#define BOOST_MPL_AUX_NA_SPEC2(i,j,name) BOOST_MPL_AUX_NA_SPEC_MAIN(i, name) BOOST_MPL_AUX_NA_SPEC_ETI(i, name) BOOST_MPL_AUX_NA_SPEC_LAMBDA(i, name) BOOST_MPL_AUX_NA_SPEC_ARITY(i, name) BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i, j, name)
#define BOOST_MPL_AUX_LAMBDA_SUPPORT_HPP_INCLUDED
#define BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i,name,params)
#define BOOST_MPL_AUX_LAMBDA_SUPPORT(i,name,params)
namespace boost { namespace mpl {
template<
bool C
, typename T1
, typename T2
>
struct if_c
{
typedef T1 type;
};
template<
typename T1
, typename T2
>
struct if_c<false,T1,T2>
{
typedef T2 type;
};
template<
typename T1 = na
, typename T2 = na
, typename T3 = na
>
struct if_
{
private:
typedef if_c<
static_cast<bool>(T1::value)
, T2
, T3
> almost_type_;
public:
typedef typename almost_type_::type type;
};
template<> struct if_< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : if_< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< if_< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef if_< na , na , na > result_; typedef if_< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< if_< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< if_< na , na , na > > : int_<-1> { }; }
}}
#define BOOST_TT_IS_BASE_OF_HPP_INCLUDED
#define BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED
#define BOOST_TT_INTRINSICS_HPP_INCLUDED
#define BOOST_TT_CONFIG_HPP_INCLUDED
#define BOOST_TT_DECL
#define BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION 1
#define BOOST_TT_IS_SAME_HPP_INCLUDED
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TYPE_TRAITS_INTEGRAL_CONSTANT_HPP
#define BOOST_MPL_INTEGRAL_C_HPP_INCLUDED
#define BOOST_MPL_INTEGRAL_C_FWD_HPP_INCLUDED
namespace mpl_ {
template< typename T, T N > struct integral_c;
}
namespace boost { namespace mpl { using ::mpl_::integral_c; } }
#define AUX_WRAPPER_PARAMS(N) typename T, T N
#define AUX_WRAPPER_NAME integral_c
#define AUX_WRAPPER_VALUE_TYPE T
#define AUX_WRAPPER_INST(value) AUX_WRAPPER_NAME< T, value >
namespace mpl_ {
template< typename T, T N >
struct integral_c
{
static const T value = N;
typedef integral_c type;
typedef T value_type;
typedef integral_c_tag tag;
typedef integral_c< T, static_cast<T>((value + 1)) > next;
typedef integral_c< T, static_cast<T>((value - 1)) > prior;
operator T() const ;
};
template< typename T, T N >
T const integral_c< T, N >::value;
}
#undef AUX_WRAPPER_NAME
#undef AUX_WRAPPER_PARAMS
#undef AUX_WRAPPER_INST
#undef AUX_WRAPPER_VALUE_TYPE
namespace mpl_ {
template< bool C >
struct integral_c<bool, C>
{
static const bool value = C;
typedef integral_c_tag tag;
typedef integral_c type;
typedef bool value_type;
operator bool() const ;
};
}
namespace boost{
template <class T, T val>
struct integral_constant : public mpl::integral_c<T, val>
{
typedef integral_constant<T,val> type;
};
template<> struct integral_constant<bool,true> : public mpl::true_
{
typedef integral_constant<bool,true> type;
};
template<> struct integral_constant<bool,false> : public mpl::false_
{
typedef integral_constant<bool,false> type;
};
typedef integral_constant<bool,true> true_type;
typedef integral_constant<bool,false> false_type;
}
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
template< typename T, typename U > struct is_same : public ::boost::integral_constant<bool,false> { public: };
template< typename T > struct is_same< T,T > : public ::boost::integral_constant<bool,true> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
#define BOOST_TT_IS_REFERENCE_HPP_INCLUDED
#define BOOST_TT_IS_LVALUE_REFERENCE_HPP_INCLUDED
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
template< typename T > struct is_lvalue_reference : public ::boost::integral_constant<bool,false> { public: };
template< typename T > struct is_lvalue_reference< T& > : public ::boost::integral_constant<bool,true> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
#define BOOST_TT_IS_RVALUE_REFERENCE_HPP_INCLUDED
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
template< typename T > struct is_rvalue_reference : public ::boost::integral_constant<bool,false> { public: };
template< typename T > struct is_rvalue_reference< T&& > : public ::boost::integral_constant<bool,true> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
#define BOOST_TT_ICE_HPP_INCLUDED
#define BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED
namespace boost {
namespace type_traits {
typedef char yes_type;
struct no_type
{
char padding[8];
};
}
}
#define BOOST_TT_DETAIL_ICE_OR_HPP_INCLUDED
namespace boost {
namespace type_traits {
template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false>
struct ice_or;
template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
struct ice_or
{
static const bool value = true;
};
template <>
struct ice_or<false, false, false, false, false, false, false>
{
static const bool value = false;
};
}
}
#define BOOST_TT_DETAIL_ICE_AND_HPP_INCLUDED
namespace boost {
namespace type_traits {
template <bool b1, bool b2, bool b3 = true, bool b4 = true, bool b5 = true, bool b6 = true, bool b7 = true>
struct ice_and;
template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
struct ice_and
{
static const bool value = false;
};
template <>
struct ice_and<true, true, true, true, true, true, true>
{
static const bool value = true;
};
}
}
#define BOOST_TT_DETAIL_ICE_NOT_HPP_INCLUDED
namespace boost {
namespace type_traits {
template <bool b>
struct ice_not
{
static const bool value = true;
};
template <>
struct ice_not<true>
{
static const bool value = false;
};
}
}
#define BOOST_TT_DETAIL_ICE_EQ_HPP_INCLUDED
namespace boost {
namespace type_traits {
template <int b1, int b2>
struct ice_eq
{
static const bool value = (b1 == b2);
};
template <int b1, int b2>
struct ice_ne
{
static const bool value = (b1 != b2);
};
template <int b1, int b2> bool const ice_eq<b1,b2>::value;
template <int b1, int b2> bool const ice_ne<b1,b2>::value;
}
}
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
namespace detail {
template <typename T>
struct is_reference_impl
{
static const bool value = (::boost::type_traits::ice_or< ::boost::is_lvalue_reference<T>::value, ::boost::is_rvalue_reference<T>::value >::value);
};
}
template< typename T > struct is_reference : public ::boost::integral_constant<bool,::boost::detail::is_reference_impl<T>::value> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
#define BOOST_TT_IS_VOLATILE_HPP_INCLUDED
#define BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED
namespace boost {
namespace detail {
template <typename T> struct cv_traits_imp {};
template <typename T>
struct cv_traits_imp<T*>
{
static const bool is_const = false;
static const bool is_volatile = false;
typedef T unqualified_type;
};
template <typename T>
struct cv_traits_imp<const T*>
{
static const bool is_const = true;
static const bool is_volatile = false;
typedef T unqualified_type;
};
template <typename T>
struct cv_traits_imp<volatile T*>
{
static const bool is_const = false;
static const bool is_volatile = true;
typedef T unqualified_type;
};
template <typename T>
struct cv_traits_imp<const volatile T*>
{
static const bool is_const = true;
static const bool is_volatile = true;
typedef T unqualified_type;
};
}
}
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
namespace detail{
template <class T>
struct is_volatile_rval_filter
{
static const bool value = ::boost::detail::cv_traits_imp<T*>::is_volatile;
};
template <class T>
struct is_volatile_rval_filter<T&&>
{
static const bool value = false;
};
}
template< typename T > struct is_volatile : public ::boost::integral_constant<bool,::boost::detail::is_volatile_rval_filter<T>::value> { public: };
template< typename T > struct is_volatile< T& > : public ::boost::integral_constant<bool,false> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
#define BOOST_INTEL_TT_OPTS
#define BOOST_IS_UNION(T) __is_union(T)
#define BOOST_IS_POD(T) __is_pod(T)
#define BOOST_IS_EMPTY(T) __is_empty(T)
#define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) ((__has_trivial_constructor(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile<T>::value)
#define BOOST_HAS_TRIVIAL_COPY(T) ((__has_trivial_copy(T) BOOST_INTEL_TT_OPTS) && !is_reference<T>::value && ! ::boost::is_volatile<T>::value)
#define BOOST_HAS_TRIVIAL_ASSIGN(T) ((__has_trivial_assign(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile<T>::value && ! ::boost::is_const<T>::value)
#define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) BOOST_INTEL_TT_OPTS)
#define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) BOOST_INTEL_TT_OPTS)
#define BOOST_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) BOOST_INTEL_TT_OPTS) && !is_volatile<T>::value && !is_reference<T>::value)
#define BOOST_HAS_NOTHROW_ASSIGN(T) ((__has_nothrow_assign(T) BOOST_INTEL_TT_OPTS) && !is_volatile<T>::value && !is_const<T>::value)
#define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T)
#define BOOST_IS_ABSTRACT(T) __is_abstract(T)
#define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same<T,U>::value)
#define BOOST_IS_CLASS(T) __is_class(T)
#define BOOST_IS_ENUM(T) __is_enum(T)
#define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T)
#define BOOST_ALIGNMENT_OF(T) __alignof__(T)
#define BOOST_HAS_TYPE_TRAITS_INTRINSICS
#define BOOST_TT_REMOVE_CV_HPP_INCLUDED
#define BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED
#define BOOST_TT_BROKEN_COMPILER_SPEC(T)
#define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(T) BOOST_TT_BROKEN_COMPILER_SPEC(T)
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) template< typename T > struct trait { public: typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) template<> struct trait<spec> { public: typedef result type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) };
#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) template<> struct trait ##_impl<spec> { public: typedef result type; };
#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait<spec> { public: typedef result type; };
#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) template< param1, param2 > struct trait<spec> { public: typedef result; };
#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) template< param > struct trait ##_impl<spec> { public: typedef result type; };
namespace boost {
namespace detail{
template <class T>
struct rvalue_ref_filter_rem_cv
{
typedef typename boost::detail::cv_traits_imp<T*>::unqualified_type type;
};
template <class T>
struct rvalue_ref_filter_rem_cv<T&&>
{
typedef T&& type;
};
}
template< typename T > struct remove_cv { public: typedef typename boost::detail::rvalue_ref_filter_rem_cv<T>::type type; };
template< typename T > struct remove_cv<T&> { public: typedef T& type; };
template< typename T, std::size_t N > struct remove_cv<T const[N]> { public: typedef T type[N]; };
template< typename T, std::size_t N > struct remove_cv<T volatile[N]> { public: typedef T type[N]; };
template< typename T, std::size_t N > struct remove_cv<T const volatile[N]> { public: typedef T type[N]; };
}
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
namespace detail {
template <typename B, typename D>
struct is_base_and_derived_impl
{
typedef typename remove_cv<B>::type ncvB;
typedef typename remove_cv<D>::type ncvD;
static const bool value = ((__is_base_of(B,D) && !is_same<B,D>::value) && ! ::boost::is_same<ncvB,ncvD>::value);
};
}
template< typename Base, typename Derived > struct is_base_and_derived : public ::boost::integral_constant<bool,(::boost::detail::is_base_and_derived_impl<Base,Derived>::value)> { public: };
template< typename Base, typename Derived > struct is_base_and_derived< Base&,Derived > : public ::boost::integral_constant<bool,false> { public: };
template< typename Base, typename Derived > struct is_base_and_derived< Base,Derived& > : public ::boost::integral_constant<bool,false> { public: };
template< typename Base, typename Derived > struct is_base_and_derived< Base&,Derived& > : public ::boost::integral_constant<bool,false> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
#define BOOST_TT_IS_CLASS_HPP_INCLUDED
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
namespace detail {
template <typename T>
struct is_class_impl
{
static const bool value = __is_class(T);
};
}
template< typename T > struct is_class : public ::boost::integral_constant<bool,::boost::detail::is_class_impl<T>::value> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
#define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i,name)
#define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C)
#define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) template< typename T > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) template< typename T1, typename T2 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) template< typename T1, typename T2, typename T3 > struct trait BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) }; BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait)
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) template<> struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) };
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) template<> struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) template<> struct trait ##_impl< sp > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) template<> struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) template< param > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) template< param1, param2 > struct trait< sp > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) };
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) template< param1, param2 > struct trait< sp1,sp2 > BOOST_TT_AUX_BOOL_C_BASE(C) { public: BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) };
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) template< param > struct trait ##_impl< sp1,sp2 > { public: BOOST_STATIC_CONSTANT(bool, value = (C)); };
#define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value)
namespace boost {
namespace detail{
template <class B, class D>
struct is_base_of_imp
{
typedef typename remove_cv<B>::type ncvB;
typedef typename remove_cv<D>::type ncvD;
static const bool value = (::boost::type_traits::ice_or< (::boost::detail::is_base_and_derived_impl<ncvB,ncvD>::value), (::boost::type_traits::ice_and< ::boost::is_same<ncvB,ncvD>::value, ::boost::is_class<ncvB>::value>::value)>::value);
};
}
template< typename Base, typename Derived > struct is_base_of : public ::boost::integral_constant<bool,(::boost::detail::is_base_of_imp<Base, Derived>::value)> { public: };
template< typename Base, typename Derived > struct is_base_of< Base&,Derived > : public ::boost::integral_constant<bool,false> { public: };
template< typename Base, typename Derived > struct is_base_of< Base,Derived& > : public ::boost::integral_constant<bool,false> { public: };
template< typename Base, typename Derived > struct is_base_of< Base&,Derived& > : public ::boost::integral_constant<bool,false> { public: };
}
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
namespace boost {
namespace CV {
enum violation_enum {min_violation, max_violation};
template<class value_policies>
class constrained_value {
public:
typedef typename value_policies::value_type value_type;
constrained_value(value_type value)
;
constrained_value& operator=(value_type v)
;
static value_type max () ;
static value_type min () ;
operator value_type() const ;
protected:
value_type value_;
private:
void assign(value_type value)
;
};
template<typename rep_type, rep_type min_value,
rep_type max_value, class exception_type>
class simple_exception_policy
{
struct exception_wrapper : public exception_type
{
operator std::out_of_range () const
;
};
typedef typename mpl::if_<
is_base_of< std::exception, exception_type >,
exception_type,
exception_wrapper
>::type actual_exception_type;
public:
typedef rep_type value_type;
static rep_type min () ;
static rep_type max () ;
static void on_error(rep_type, rep_type, violation_enum)
;
};
} }
#define DATE_TIME_DATE_DEFS_HPP
namespace boost {
namespace date_time {
enum weekdays {Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday};
enum months_of_year {Jan=1,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec,NotAMonth,NumMonths};
} }
namespace boost {
namespace gregorian {
using date_time::Sunday;
using date_time::Monday;
using date_time::Tuesday;
using date_time::Wednesday;
using date_time::Thursday;
using date_time::Friday;
using date_time::Saturday;
struct bad_weekday : public std::out_of_range
{
bad_weekday() ;
};
typedef CV::simple_exception_policy<unsigned short, 0, 6, bad_weekday> greg_weekday_policies;
typedef CV::constrained_value<greg_weekday_policies> greg_weekday_rep;
class greg_weekday : public greg_weekday_rep {
public:
typedef boost::date_time::weekdays weekday_enum;
greg_weekday(unsigned short day_of_week_num)
;
unsigned short as_number() const ;
const char* as_short_string() const;
const char* as_long_string() const;
const wchar_t* as_short_wstring() const;
const wchar_t* as_long_wstring() const;
weekday_enum as_enum() const ;
};
} }
#define GREG_DAY_OF_YEAR_HPP___
namespace boost {
namespace gregorian {
struct bad_day_of_year : public std::out_of_range
{
bad_day_of_year()
;
};
typedef CV::simple_exception_policy<unsigned short,1,366,bad_day_of_year> greg_day_of_year_policies;
typedef CV::constrained_value<greg_day_of_year_policies> greg_day_of_year_rep;
} }
#define DATE_TIME_GREGORIAN_CALENDAR_HPP__
namespace boost {
namespace date_time {
template<typename ymd_type_, typename date_int_type_>
class gregorian_calendar_base {
public:
typedef ymd_type_ ymd_type;
typedef typename ymd_type::month_type month_type;
typedef typename ymd_type::day_type day_type;
typedef typename ymd_type::year_type year_type;
typedef date_int_type_ date_int_type;
static unsigned short day_of_week(const ymd_type& ymd);
static int week_number(const ymd_type&ymd);
static date_int_type day_number(const ymd_type& ymd);
static date_int_type julian_day_number(const ymd_type& ymd);
static date_int_type modjulian_day_number(const ymd_type& ymd);
static ymd_type from_day_number(date_int_type);
static ymd_type from_julian_day_number(date_int_type);
static ymd_type from_modjulian_day_number(date_int_type);
static bool is_leap_year(year_type);
static unsigned short end_of_month_day(year_type y, month_type m);
static ymd_type epoch();
static unsigned short days_in_week();
};
} }
#undef BOOST_DATE_TIME_INLINE
#define BOOST_DATE_TIME_INLINE inline
namespace boost {
namespace date_time {
} }
#define DATE_TIME_GREG_YMD_HPP__
#define GREG_DAY_HPP___
namespace boost {
namespace gregorian {
struct bad_day_of_month : public std::out_of_range
{
bad_day_of_month()
;
bad_day_of_month(const std::string& s)
;
};
typedef CV::simple_exception_policy<unsigned short, 1, 31, bad_day_of_month> greg_day_policies;
typedef CV::constrained_value<greg_day_policies> greg_day_rep;
class greg_day : public greg_day_rep {
public:
greg_day(unsigned short day_of_month) ;
unsigned short as_number() const ;
operator unsigned short() const ;
private:
};
} }
#define GREG_YEAR_HPP___
namespace boost {
namespace gregorian {
struct bad_year : public std::out_of_range
{
bad_year()
;
};
typedef CV::simple_exception_policy<unsigned short, 1400, 10000, bad_year> greg_year_policies;
typedef CV::constrained_value<greg_year_policies> greg_year_rep;
class greg_year : public greg_year_rep {
public:
greg_year(unsigned short year) ;
operator unsigned short() const ;
private:
};
} }
#define GREG_MONTH_HPP___
#define _GLIBCXX_MAP 1
#define _STL_TREE_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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 _Val>
struct _Rb_tree_node : public _Rb_tree_node_base
{
typedef _Rb_tree_node<_Val>* _Link_type;
__gnu_cxx::__aligned_buffer<_Val> _M_storage;
_Val*
_M_valptr()
;
const _Val*
_M_valptr() const
;
};
__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(_Link_type __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(_Link_type __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(static_cast<typename iterator::_Link_type>
(const_cast<typename iterator::_Base_ptr>(_M_node))); }
reference
operator*() const noexcept
{ return *static_cast<_Link_type>(_M_node)->_M_valptr(); }
pointer
operator->() const noexcept
{ return static_cast<_Link_type>(_M_node)->_M_valptr(); }
_Self&
operator++() noexcept
{
_M_node = _Rb_tree_increment(_M_node);
return *this;
}
_Self
operator++(int) noexcept
{
_Self __tmp = *this;
_M_node = _Rb_tree_increment(_M_node);
return __tmp;
}
_Self&
operator--() noexcept
{
_M_node = _Rb_tree_decrement(_M_node);
return *this;
}
_Self
operator--(int) noexcept
{
_Self __tmp = *this;
_M_node = _Rb_tree_decrement(_M_node);
return __tmp;
}
bool
operator==(const _Self& __x) const noexcept
{ return _M_node == __x._M_node; }
bool
operator!=(const _Self& __x) const noexcept
{ return _M_node != __x._M_node; }
_Base_ptr _M_node;
};
template<typename _Val>
inline bool
operator==(const _Rb_tree_iterator<_Val>& __x,
const _Rb_tree_const_iterator<_Val>& __y) noexcept
{ return __x._M_node == __y._M_node; }
template<typename _Val>
inline bool
operator!=(const _Rb_tree_iterator<_Val>& __x,
const _Rb_tree_const_iterator<_Val>& __y) noexcept
{ return __x._M_node != __y._M_node; }
void
_Rb_tree_insert_and_rebalance(const bool __insert_left,
_Rb_tree_node_base* __x,
_Rb_tree_node_base* __p,
_Rb_tree_node_base& __header) throw ();
_Rb_tree_node_base*
_Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z,
_Rb_tree_node_base& __header) throw ();
template<typename _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(const _Rb_tree_node_base& __header,
_Rb_tree& __t)
;
_Reuse_or_alloc_node(const _Reuse_or_alloc_node&) = delete;
~_Reuse_or_alloc_node()
;
template<typename _Arg>
_Link_type
operator()(_Arg&& __arg)
;
private:
_Base_ptr
_M_extract()
;
_Base_ptr _M_root;
_Base_ptr _M_nodes;
_Rb_tree& _M_t;
};
struct _Alloc_node
{
_Alloc_node(_Rb_tree& __t) ;
template<typename _Arg>
_Link_type
operator()(_Arg&& __arg) const
;
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); }
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
{
_Key_compare _M_key_compare;
_Rb_tree_node_base _M_header;
size_type _M_node_count;
_Rb_tree_impl()
: _Node_allocator(), _M_key_compare(), _M_header(),
_M_node_count(0)
{ _M_initialize(); }
_Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a)
: _Node_allocator(__a), _M_key_compare(__comp), _M_header(),
_M_node_count(0)
{ _M_initialize(); }
_Rb_tree_impl(const _Key_compare& __comp, _Node_allocator&& __a)
: _Node_allocator(std::move(__a)), _M_key_compare(__comp),
_M_header(), _M_node_count(0)
{ _M_initialize(); }
void
_M_reset()
{
this->_M_header._M_parent = 0;
this->_M_header._M_left = &this->_M_header;
this->_M_header._M_right = &this->_M_header;
this->_M_node_count = 0;
}
private:
void
_M_initialize()
{
this->_M_header._M_color = _S_red;
this->_M_header._M_parent = 0;
this->_M_header._M_left = &this->_M_header;
this->_M_header._M_right = &this->_M_header;
}
};
_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);
}
_Link_type
_M_end() noexcept
{ return reinterpret_cast<_Link_type>(&this->_M_impl._M_header); }
_Const_Link_type
_M_end() const noexcept
{ return reinterpret_cast<_Const_Link_type>(&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;
private:
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);
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);
template<typename _NodeGen>
_Link_type
_M_copy(_Const_Link_type __x, _Link_type __p, _NodeGen&);
_Link_type
_M_copy(_Const_Link_type __x, _Link_type __p)
;
void
_M_erase(_Link_type __x);
iterator
_M_lower_bound(_Link_type __x, _Link_type __y,
const _Key& __k);
const_iterator
_M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
const _Key& __k) const;
iterator
_M_upper_bound(_Link_type __x, _Link_type __y,
const _Key& __k);
const_iterator
_M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
const _Key& __k) const;
public:
_Rb_tree() ;
_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._M_key_compare,
_Alloc_traits::_S_select_on_copy(__x._M_get_Node_allocator()))
{
if (__x._M_root() != 0)
{
_M_root() = _M_copy(__x._M_begin(), _M_end());
_M_leftmost() = _S_minimum(_M_root());
_M_rightmost() = _S_maximum(_M_root());
_M_impl._M_node_count = __x._M_impl._M_node_count;
}
}
_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._M_begin(), _M_end());
_M_leftmost() = _S_minimum(_M_root());
_M_rightmost() = _S_maximum(_M_root());
_M_impl._M_node_count = __x._M_impl._M_node_count;
}
}
_Rb_tree(_Rb_tree&& __x)
: _M_impl(__x._M_impl._M_key_compare, __x._M_get_Node_allocator())
{
if (__x._M_root() != 0)
_M_move_data(__x, std::true_type());
}
_Rb_tree(_Rb_tree&& __x, const allocator_type& __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
;
iterator
begin() noexcept
{
return iterator(static_cast<_Link_type>
(this->_M_impl._M_header._M_left));
}
const_iterator
begin() const noexcept
{
return const_iterator(static_cast<_Const_Link_type>
(this->_M_impl._M_header._M_left));
}
iterator
end() noexcept
{ return iterator(static_cast<_Link_type>(&this->_M_impl._M_header)); }
const_iterator
end() const noexcept
{
return const_iterator(static_cast<_Const_Link_type>
(&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(_Alloc_traits::_S_nothrow_swap());
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)
;
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)
;
template<typename... _Args>
pair<iterator, bool>
_M_emplace_unique(_Args&&... __args);
template<typename... _Args>
iterator
_M_emplace_equal(_Args&&... __args);
template<typename... _Args>
iterator
_M_emplace_hint_unique(const_iterator __pos, _Args&&... __args);
template<typename... _Args>
iterator
_M_emplace_hint_equal(const_iterator __pos, _Args&&... __args);
template<typename _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)
;
__attribute ((__abi_tag__ ("cxx11")))
iterator
erase(iterator __position)
;
size_type
erase(const key_type& __x);
__attribute ((__abi_tag__ ("cxx11")))
iterator
erase(const_iterator __first, const_iterator __last)
;
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)
;
const_iterator
lower_bound(const key_type& __k) const
;
iterator
upper_bound(const key_type& __k)
;
const_iterator
upper_bound(const key_type& __k) const
;
pair<iterator, iterator>
equal_range(const key_type& __k);
pair<const_iterator, const_iterator>
equal_range(const key_type& __k) const;
bool
__rb_verify() const;
_Rb_tree&
operator=(_Rb_tree&&) noexcept(_Alloc_traits::_S_nothrow_move());
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&, std::true_type);
void
_M_move_data(_Rb_tree&, std::false_type);
};
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
bool
operator==(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
bool
operator<(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
bool
operator!=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
bool
operator>(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
bool
operator<=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
bool
operator>=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
void
swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
;
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=(_Rb_tree&& __x)
noexcept(_Alloc_traits::_S_nothrow_move())
{
_M_impl._M_key_compare = __x._M_impl._M_key_compare;
if (_Alloc_traits::_S_propagate_on_move_assign()
|| _Alloc_traits::_S_always_equal()
|| _M_get_Node_allocator() == __x._M_get_Node_allocator())
{
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());
return *this;
}
_Reuse_or_alloc_node __roan(_M_impl._M_header, *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._M_begin(), _M_end(), __lbd);
_M_leftmost() = _S_minimum(_M_root());
_M_rightmost() = _S_maximum(_M_root());
_M_impl._M_node_count = __x._M_impl._M_node_count;
__x.clear();
}
return *this;
}
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
void
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t)
noexcept(_Alloc_traits::_S_nothrow_swap())
{
if (_M_root() == 0)
{
if (__t._M_root() != 0)
{
_M_root() = __t._M_root();
_M_leftmost() = __t._M_leftmost();
_M_rightmost() = __t._M_rightmost();
_M_root()->_M_parent = _M_end();
_M_impl._M_node_count = __t._M_impl._M_node_count;
__t._M_impl._M_reset();
}
}
else if (__t._M_root() == 0)
{
__t._M_root() = _M_root();
__t._M_leftmost() = _M_leftmost();
__t._M_rightmost() = _M_rightmost();
__t._M_root()->_M_parent = __t._M_end();
__t._M_impl._M_node_count = _M_impl._M_node_count;
_M_impl._M_reset();
}
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());
}
__attribute__ ((__pure__)) unsigned int
_Rb_tree_black_count(const _Rb_tree_node_base* __node,
const _Rb_tree_node_base* __root) throw ();
}
#define _STL_MAP_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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:
typedef typename _Alloc::value_type _Alloc_value_type;
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) ;
public:
bool operator()(const value_type& __x, const value_type& __y) const
;
};
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;
map() ;
explicit
map(const _Compare& __comp,
const allocator_type& __a = allocator_type()) ;
map(const map& __x) ;
map(map&& __x)
noexcept(is_nothrow_copy_constructible<_Compare>::value)
: _M_t(std::move(__x._M_t)) { }
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); }
template<typename _InputIterator>
map(_InputIterator __first, _InputIterator __last)
: _M_t()
{ _M_t._M_insert_unique(__first, __last); }
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&
operator=(const map& __x)
{
_M_t = __x._M_t;
return *this;
}
map&
operator=(map&&) = default;
map&
operator=(initializer_list<value_type> __l)
;
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(); }
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;
}
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;
}
template<typename... _Args>
std::pair<iterator, bool>
emplace(_Args&&... __args)
{ return _M_t._M_emplace_unique(std::forward<_Args>(__args)...); }
template<typename... _Args>
iterator
emplace_hint(const_iterator __pos, _Args&&... __args)
{
return _M_t._M_emplace_hint_unique(__pos,
std::forward<_Args>(__args)...);
}
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)); }
void
insert(std::initializer_list<value_type> __list)
{ insert(__list.begin(), __list.end()); }
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)); }
template<typename _InputIterator>
void
insert(_InputIterator __first, _InputIterator __last)
{ _M_t._M_insert_unique(__first, __last); }
iterator
erase(const_iterator __position)
{ return _M_t.erase(__position); }
__attribute ((__abi_tag__ ("cxx11")))
iterator
erase(iterator __position)
{ return _M_t.erase(__position); }
size_type
erase(const key_type& __x)
{ return _M_t.erase(__x); }
iterator
erase(const_iterator __first, const_iterator __last)
{ return _M_t.erase(__first, __last); }
void
swap(map& __x)
noexcept(_Alloc_traits::_S_nothrow_swap())
{ _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()); }
iterator
find(const key_type& __x)
{ return _M_t.find(__x); }
const_iterator
find(const key_type& __x) const
{ return _M_t.find(__x); }
size_type
count(const key_type& __x) const
{ return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
iterator
lower_bound(const key_type& __x)
{ return _M_t.lower_bound(__x); }
const_iterator
lower_bound(const key_type& __x) const
{ return _M_t.lower_bound(__x); }
iterator
upper_bound(const key_type& __x)
{ return _M_t.upper_bound(__x); }
const_iterator
upper_bound(const key_type& __x) const
{ return _M_t.upper_bound(__x); }
std::pair<iterator, iterator>
equal_range(const key_type& __x)
{ return _M_t.equal_range(__x); }
std::pair<const_iterator, const_iterator>
equal_range(const key_type& __x) const
{ return _M_t.equal_range(__x); }
template<typename _K1, typename _T1, typename _C1, typename _A1>
friend bool
operator==(const map<_K1, _T1, _C1, _A1>&,
const map<_K1, _T1, _C1, _A1>&);
template<typename _K1, typename _T1, typename _C1, typename _A1>
friend bool
operator<(const map<_K1, _T1, _C1, _A1>&,
const map<_K1, _T1, _C1, _A1>&);
};
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator==(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator<(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator!=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator>(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator<=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator>=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
const map<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
void
swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
map<_Key, _Tp, _Compare, _Alloc>& __y)
;
}
#define _STL_MULTIMAP_H 1
namespace std __attribute__ ((__visibility__ ("default")))
{
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:
typedef typename _Alloc::value_type _Alloc_value_type;
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) ;
public:
bool operator()(const value_type& __x, const value_type& __y) const
;
};
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;
multimap() ;
explicit
multimap(const _Compare& __comp,
const allocator_type& __a = allocator_type()) ;
multimap(const multimap& __x) ;
multimap(multimap&& __x)
noexcept(is_nothrow_copy_constructible<_Compare>::value)
: _M_t(std::move(__x._M_t)) { }
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); }
template<typename _InputIterator>
multimap(_InputIterator __first, _InputIterator __last)
: _M_t()
{ _M_t._M_insert_equal(__first, __last); }
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&
operator=(const multimap& __x)
{
_M_t = __x._M_t;
return *this;
}
multimap&
operator=(multimap&&) = default;
multimap&
operator=(initializer_list<value_type> __l)
;
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(); }
template<typename... _Args>
iterator
emplace(_Args&&... __args)
{ return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); }
template<typename... _Args>
iterator
emplace_hint(const_iterator __pos, _Args&&... __args)
{
return _M_t._M_emplace_hint_equal(__pos,
std::forward<_Args>(__args)...);
}
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)); }
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)); }
template<typename _InputIterator>
void
insert(_InputIterator __first, _InputIterator __last)
{ _M_t._M_insert_equal(__first, __last); }
void
insert(initializer_list<value_type> __l)
{ this->insert(__l.begin(), __l.end()); }
iterator
erase(const_iterator __position)
{ return _M_t.erase(__position); }
__attribute ((__abi_tag__ ("cxx11")))
iterator
erase(iterator __position)
{ return _M_t.erase(__position); }
size_type
erase(const key_type& __x)
{ return _M_t.erase(__x); }
iterator
erase(const_iterator __first, const_iterator __last)
{ return _M_t.erase(__first, __last); }
void
swap(multimap& __x)
noexcept(_Alloc_traits::_S_nothrow_swap())
{ _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()); }
iterator
find(const key_type& __x)
{ return _M_t.find(__x); }
const_iterator
find(const key_type& __x) const
{ return _M_t.find(__x); }
size_type
count(const key_type& __x) const
{ return _M_t.count(__x); }
iterator
lower_bound(const key_type& __x)
{ return _M_t.lower_bound(__x); }
const_iterator
lower_bound(const key_type& __x) const
{ return _M_t.lower_bound(__x); }
iterator
upper_bound(const key_type& __x)
{ return _M_t.upper_bound(__x); }
const_iterator
upper_bound(const key_type& __x) const
{ return _M_t.upper_bound(__x); }
std::pair<iterator, iterator>
equal_range(const key_type& __x)
{ return _M_t.equal_range(__x); }
std::pair<const_iterator, const_iterator>
equal_range(const key_type& __x) const
{ return _M_t.equal_range(__x); }
template<typename _K1, typename _T1, typename _C1, typename _A1>
friend bool
operator==(const multimap<_K1, _T1, _C1, _A1>&,
const multimap<_K1, _T1, _C1, _A1>&);
template<typename _K1, typename _T1, typename _C1, typename _A1>
friend bool
operator<(const multimap<_K1, _T1, _C1, _A1>&,
const multimap<_K1, _T1, _C1, _A1>&);
};
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator==(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator<(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator!=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator<=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
bool
operator>=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
;
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
void
swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
multimap<_Key, _Tp, _Compare, _Alloc>& __y)
;
}
namespace boost {
namespace gregorian {
typedef date_time::months_of_year months_of_year;
using date_time::Jan;
using date_time::Feb;
using date_time::Mar;
using date_time::Apr;
using date_time::May;
using date_time::Jun;
using date_time::Jul;
using date_time::Aug;
using date_time::Sep;
using date_time::Oct;
using date_time::Nov;
using date_time::Dec;
using date_time::NotAMonth;
using date_time::NumMonths;
struct bad_month : public std::out_of_range
{
bad_month() ;
};
typedef CV::simple_exception_policy<unsigned short, 1, 12, bad_month> greg_month_policies;
typedef CV::constrained_value<greg_month_policies> greg_month_rep;
class greg_month : public greg_month_rep {
public:
typedef date_time::months_of_year month_enum;
typedef std::map<std::string, unsigned short> month_map_type;
typedef boost::shared_ptr<month_map_type> month_map_ptr_type;
greg_month(month_enum theMonth) ;
greg_month(unsigned short theMonth) ;
operator unsigned short() const ;
unsigned short as_number() const ;
month_enum as_enum() const ;
const char* as_short_string() const;
const char* as_long_string() const;
const wchar_t* as_short_wstring() const;
const wchar_t* as_long_wstring() const;
static month_map_ptr_type get_month_map_ptr();
const char* as_short_string(char) const
;
const char* as_long_string(char) const
;
const wchar_t* as_short_string(wchar_t) const
;
const wchar_t* as_long_string(wchar_t) const
;
};
} }
namespace boost {
namespace gregorian {
typedef date_time::year_month_day_base<greg_year,
greg_month,
greg_day> greg_year_month_day;
} }
namespace boost {
namespace gregorian {
typedef date_time::int_adapter<uint32_t> fancy_date_rep;
class gregorian_calendar :
public date_time::gregorian_calendar_base<greg_year_month_day, fancy_date_rep::int_type> {
public:
typedef greg_weekday day_of_week_type;
typedef greg_day_of_year_rep day_of_year_type;
typedef fancy_date_rep date_rep_type;
typedef fancy_date_rep date_traits_type;
private:
};
} }
#define GREG_DURATION_HPP___
#define DATE_TIME_DATE_DURATION__
namespace boost {
namespace date_time {
template<class duration_rep_traits>
class date_duration : private
boost::less_than_comparable1< date_duration< duration_rep_traits >
, boost::equality_comparable1< date_duration< duration_rep_traits >
, boost::addable1< date_duration< duration_rep_traits >
, boost::subtractable1< date_duration< duration_rep_traits >
, boost::dividable2< date_duration< duration_rep_traits >, int
> > > > >
{
public:
typedef typename duration_rep_traits::int_type duration_rep_type;
typedef typename duration_rep_traits::impl_type duration_rep;
explicit date_duration(duration_rep day_count) ;
date_duration(special_values sv)
;
date_duration(const date_duration<duration_rep_traits>& other)
;
duration_rep get_rep()const
;
bool is_special()const
;
duration_rep_type days() const
;
static date_duration unit()
;
bool operator==(const date_duration& rhs) const
;
bool operator<(const date_duration& rhs) const
;
date_duration& operator-=(const date_duration& rhs)
;
date_duration& operator+=(const date_duration& rhs)
;
date_duration operator-() const
;
date_duration& operator/=(int divisor)
;
bool is_negative() const
;
private:
duration_rep days_;
};
struct duration_traits_long
{
typedef long int_type;
typedef long impl_type;
static int_type as_number(impl_type i) ;
};
struct duration_traits_adapted
{
typedef long int_type;
typedef boost::date_time::int_adapter<long> impl_type;
static int_type as_number(impl_type i) ;
};
} }
namespace boost {
namespace gregorian {
typedef boost::date_time::duration_traits_adapted date_duration_rep;
class date_duration :
public boost::date_time::date_duration< date_duration_rep >
{
typedef boost::date_time::date_duration< date_duration_rep > base_type;
public:
typedef base_type::duration_rep duration_rep;
explicit date_duration(duration_rep day_count = 0) ;
date_duration(date_time::special_values sv) ;
date_duration(const date_duration& other)
;
date_duration(const base_type& other)
;
bool operator== (const date_duration& rhs) const
;
bool operator!= (const date_duration& rhs) const
;
bool operator< (const date_duration& rhs) const
;
bool operator> (const date_duration& rhs) const
;
bool operator<= (const date_duration& rhs) const
;
bool operator>= (const date_duration& rhs) const
;
date_duration& operator-= (const date_duration& rhs)
;
friend date_duration operator- (date_duration rhs, date_duration const& lhs)
;
date_duration& operator+= (const date_duration& rhs)
;
friend date_duration operator+ (date_duration rhs, date_duration const& lhs)
;
date_duration operator- ()const
;
date_duration& operator/= (int divisor)
;
friend date_duration operator/ (date_duration rhs, int lhs)
;
static date_duration unit()
;
};
typedef date_duration days;
} }
#define DATE_DURATION_TYPES_HPP___
namespace boost {
namespace date_time {
template <class duration_config>
class weeks_duration : public date_duration<duration_config> {
public:
weeks_duration(typename duration_config::impl_type w) ;
weeks_duration(special_values sv) ;
};
template<class t>
class years_duration;
template<class base_config>
class months_duration
{
private:
typedef typename base_config::int_rep int_rep;
typedef typename int_rep::int_type int_type;
typedef typename base_config::date_type date_type;
typedef typename date_type::duration_type duration_type;
typedef typename base_config::month_adjustor_type month_adjustor_type;
typedef months_duration<base_config> months_type;
typedef years_duration<base_config> years_type;
public:
months_duration(int_rep num) ;
months_duration(special_values sv)
;
int_rep number_of_months() const ;
duration_type get_neg_offset(const date_type& d) const
;
duration_type get_offset(const date_type& d) const
;
bool operator==(const months_type& rhs) const
;
bool operator!=(const months_type& rhs) const
;
months_type operator+(const months_type& rhs)const
;
months_type& operator+=(const months_type& rhs)
;
months_type operator-(const months_type& rhs)const
;
months_type& operator-=(const months_type& rhs)
;
months_type operator*(const int_type rhs)const
;
months_type& operator*=(const int_type rhs)
;
months_type operator/(const int_type rhs)const
;
months_type& operator/=(const int_type rhs)
;
months_type operator+(const years_type& y)const
;
months_type& operator+=(const years_type& y)
;
months_type operator-(const years_type& y) const
;
months_type& operator-=(const years_type& y)
;
friend date_type operator+(const date_type& d, const months_type& m)
;
friend date_type operator+=(date_type& d, const months_type& m)
;
friend date_type operator-(const date_type& d, const months_type& m)
;
friend date_type operator-=(date_type& d, const months_type& m)
;
private:
int_rep _m;
};
template<class base_config>
class years_duration
{
private:
typedef typename base_config::int_rep int_rep;
typedef typename int_rep::int_type int_type;
typedef typename base_config::date_type date_type;
typedef typename date_type::duration_type duration_type;
typedef typename base_config::month_adjustor_type month_adjustor_type;
typedef years_duration<base_config> years_type;
typedef months_duration<base_config> months_type;
public:
years_duration(int_rep num) ;
years_duration(special_values sv)
;
int_rep number_of_years() const ;
duration_type get_neg_offset(const date_type& d) const
;
duration_type get_offset(const date_type& d) const
;
bool operator==(const years_type& rhs) const
;
bool operator!=(const years_type& rhs) const
;
years_type operator+(const years_type& rhs)const
;
years_type& operator+=(const years_type& rhs)
;
years_type operator-(const years_type& rhs)const
;
years_type& operator-=(const years_type& rhs)
;
years_type operator*(const int_type rhs)const
;
years_type& operator*=(const int_type rhs)
;
years_type operator/(const int_type rhs)const
;
years_type& operator/=(const int_type rhs)
;
months_type operator+(const months_type& m) const
;
months_type operator-(const months_type& m) const
;
friend date_type operator+(const date_type& d, const years_type& y)
;
friend date_type operator+=(date_type& d, const years_type& y)
;
friend date_type operator-(const date_type& d, const years_type& y)
;
friend date_type operator-=(date_type& d, const years_type& y)
;
private:
int_rep _y;
};
}}
#define GREG_DURATION_TYPES_HPP___
#define GREG_DATE_HPP___
namespace boost {
namespace gregorian {
using date_time::special_values;
using date_time::not_special;
using date_time::neg_infin;
using date_time::pos_infin;
using date_time::not_a_date_time;
using date_time::max_date_time;
using date_time::min_date_time;
class date : public date_time::date<date, gregorian_calendar, date_duration>
{
public:
typedef gregorian_calendar::year_type year_type;
typedef gregorian_calendar::month_type month_type;
typedef gregorian_calendar::day_type day_type;
typedef gregorian_calendar::day_of_year_type day_of_year_type;
typedef gregorian_calendar::ymd_type ymd_type;
typedef gregorian_calendar::date_rep_type date_rep_type;
typedef gregorian_calendar::date_int_type date_int_type;
typedef date_duration duration_type;
date()
;
date(year_type y, month_type m, day_type d)
;
explicit date(const ymd_type& ymd)
;
explicit date(const date_int_type& rhs)
;
explicit date(date_rep_type rhs)
;
explicit date(special_values sv)
;
date_int_type julian_day() const
;
day_of_year_type day_of_year() const
;
date_int_type modjulian_day() const
;
int week_number() const
;
date_int_type day_number() const
;
date end_of_month() const
;
private:
};
} }
#define _DATE_TIME_ADJUST_FUNCTORS_HPP___
#define _DATE_TIME_WRAPPING_INT_HPP__
namespace boost {
namespace date_time {
template<typename int_type_, int_type_ wrap_val>
class wrapping_int {
public:
typedef int_type_ int_type;
static int_type wrap_value() ;
wrapping_int(int_type v) ;
int_type as_int() const ;
operator int_type() const ;
template< typename IntT >
IntT add(IntT v)
;
template< typename IntT >
IntT subtract(IntT v)
;
private:
int_type value_;
template< typename IntT >
IntT calculate_wrap(IntT wrap)
;
};
template<typename int_type_, int_type_ wrap_min, int_type_ wrap_max>
class wrapping_int2 {
public:
typedef int_type_ int_type;
static int_type wrap_value() ;
static int_type min_value() ;
wrapping_int2(int_type v) ;
int_type as_int() const ;
operator int_type() const ;
template< typename IntT >
IntT add(IntT v)
;
template< typename IntT >
IntT subtract(IntT v)
;
private:
int_type value_;
template< typename IntT >
IntT calculate_wrap(IntT wrap)
;
};
} }
namespace boost {
namespace date_time {
template<class date_type>
class day_functor
{
public:
typedef typename date_type::duration_type duration_type;
day_functor(int f) ;
duration_type get_offset(const date_type& d) const
;
duration_type get_neg_offset(const date_type& d) const
;
private:
int f_;
};
template<class date_type>
class month_functor
{
public:
typedef typename date_type::duration_type duration_type;
typedef typename date_type::calendar_type cal_type;
typedef typename cal_type::ymd_type ymd_type;
typedef typename cal_type::day_type day_type;
month_functor(int f) ;
duration_type get_offset(const date_type& d) const
;
duration_type get_neg_offset(const date_type& d) const
;
private:
int f_;
mutable short origDayOfMonth_;
};
template<class date_type>
class week_functor
{
public:
typedef typename date_type::duration_type duration_type;
typedef typename date_type::calendar_type calendar_type;
week_functor(int f) ;
duration_type get_offset(const date_type& d) const
;
duration_type get_neg_offset(const date_type& d) const
;
private:
int f_;
};
template<class date_type>
class year_functor
{
public:
typedef typename date_type::duration_type duration_type;
year_functor(int f) ;
duration_type get_offset(const date_type& d) const
;
duration_type get_neg_offset(const date_type& d) const
;
private:
month_functor<date_type> _mf;
};
} }
namespace boost {
namespace gregorian {
struct greg_durations_config {
typedef date date_type;
typedef date_time::int_adapter<int> int_rep;
typedef date_time::month_functor<date_type> month_adjustor_type;
};
typedef date_time::months_duration<greg_durations_config> months;
typedef date_time::years_duration<greg_durations_config> years;
class weeks_duration : public date_duration {
public:
weeks_duration(duration_rep w) ;
weeks_duration(date_time::special_values sv) ;
};
typedef weeks_duration weeks;
}}
#define DATE_TIME_DATE_GENERATORS_HPP__
#define _GLIBCXX_SSTREAM 1
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _CharT, typename _Traits, typename _Alloc>
class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef _Alloc allocator_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef basic_streambuf<char_type, traits_type> __streambuf_type;
typedef basic_string<char_type, _Traits, _Alloc> __string_type;
typedef typename __string_type::size_type __size_type;
protected:
ios_base::openmode _M_mode;
__string_type _M_string;
public:
explicit
basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
;
explicit
basic_stringbuf(const __string_type& __str,
ios_base::openmode __mode = ios_base::in | ios_base::out)
;
basic_stringbuf(const basic_stringbuf&) = delete;
basic_stringbuf(basic_stringbuf&& __rhs)
;
basic_stringbuf&
operator=(const basic_stringbuf&) = delete;
basic_stringbuf&
operator=(basic_stringbuf&& __rhs)
;
void
swap(basic_stringbuf& __rhs)
;
__string_type
str() const
;
void
str(const __string_type& __s)
;
protected:
void
_M_stringbuf_init(ios_base::openmode __mode)
;
virtual streamsize
showmanyc()
;
virtual int_type
underflow();
virtual int_type
pbackfail(int_type __c = traits_type::eof());
virtual int_type
overflow(int_type __c = traits_type::eof());
virtual __streambuf_type*
setbuf(char_type* __s, streamsize __n)
;
virtual pos_type
seekoff(off_type __off, ios_base::seekdir __way,
ios_base::openmode __mode = ios_base::in | ios_base::out);
virtual pos_type
seekpos(pos_type __sp,
ios_base::openmode __mode = ios_base::in | ios_base::out);
void
_M_sync(char_type* __base, __size_type __i, __size_type __o);
void
_M_update_egptr()
;
void
_M_pbump(char_type* __pbeg, char_type* __pend, off_type __off);
};
template<typename _CharT, typename _Traits, typename _Alloc>
class basic_istringstream : public basic_istream<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef _Alloc allocator_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
typedef basic_istream<char_type, traits_type> __istream_type;
private:
__stringbuf_type _M_stringbuf;
public:
explicit
basic_istringstream(ios_base::openmode __mode = ios_base::in)
;
explicit
basic_istringstream(const __string_type& __str,
ios_base::openmode __mode = ios_base::in)
;
~basic_istringstream()
;
basic_istringstream(const basic_istringstream&) = delete;
basic_istringstream(basic_istringstream&& __rhs)
;
basic_istringstream&
operator=(const basic_istringstream&) = delete;
basic_istringstream&
operator=(basic_istringstream&& __rhs)
;
void
swap(basic_istringstream& __rhs)
;
__stringbuf_type*
rdbuf() const
;
__string_type
str() const
;
void
str(const __string_type& __s)
;
};
template <typename _CharT, typename _Traits, typename _Alloc>
class basic_ostringstream : public basic_ostream<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef _Alloc allocator_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
typedef basic_ostream<char_type, traits_type> __ostream_type;
private:
__stringbuf_type _M_stringbuf;
public:
explicit
basic_ostringstream(ios_base::openmode __mode = ios_base::out)
;
explicit
basic_ostringstream(const __string_type& __str,
ios_base::openmode __mode = ios_base::out)
;
~basic_ostringstream()
;
basic_ostringstream(const basic_ostringstream&) = delete;
basic_ostringstream(basic_ostringstream&& __rhs)
;
basic_ostringstream&
operator=(const basic_ostringstream&) = delete;
basic_ostringstream&
operator=(basic_ostringstream&& __rhs)
;
void
swap(basic_ostringstream& __rhs)
;
__stringbuf_type*
rdbuf() const
;
__string_type
str() const
;
void
str(const __string_type& __s)
;
};
template <typename _CharT, typename _Traits, typename _Alloc>
class basic_stringstream : public basic_iostream<_CharT, _Traits>
{
public:
typedef _CharT char_type;
typedef _Traits traits_type;
typedef _Alloc allocator_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
typedef basic_iostream<char_type, traits_type> __iostream_type;
private:
__stringbuf_type _M_stringbuf;
public:
explicit
basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
;
explicit
basic_stringstream(const __string_type& __str,
ios_base::openmode __m = ios_base::out | ios_base::in)
;
~basic_stringstream()
;
basic_stringstream(const basic_stringstream&) = delete;
basic_stringstream(basic_stringstream&& __rhs)
;
basic_stringstream&
operator=(const basic_stringstream&) = delete;
basic_stringstream&
operator=(basic_stringstream&& __rhs)
;
void
swap(basic_stringstream& __rhs)
;
__stringbuf_type*
rdbuf() const
;
__string_type
str() const
;
void
str(const __string_type& __s)
;
};
template <class _CharT, class _Traits, class _Allocator>
void
swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x,
basic_stringbuf<_CharT, _Traits, _Allocator>& __y)
;
template <class _CharT, class _Traits, class _Allocator>
void
swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x,
basic_istringstream<_CharT, _Traits, _Allocator>& __y)
;
template <class _CharT, class _Traits, class _Allocator>
void
swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x,
basic_ostringstream<_CharT, _Traits, _Allocator>& __y)
;
template <class _CharT, class _Traits, class _Allocator>
void
swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x,
basic_stringstream<_CharT, _Traits, _Allocator>& __y)
;
}
#define _SSTREAM_TCC 1
namespace std __attribute__ ((__visibility__ ("default")))
{
extern template class basic_stringbuf<char>;
extern template class basic_istringstream<char>;
extern template class basic_ostringstream<char>;
extern template class basic_stringstream<char>;
extern template class basic_stringbuf<wchar_t>;
extern template class basic_istringstream<wchar_t>;
extern template class basic_ostringstream<wchar_t>;
extern template class basic_stringstream<wchar_t>;
}
namespace boost {
namespace date_time {
template<class date_type>
class year_based_generator
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::year_type year_type;
year_based_generator() ;
virtual ~year_based_generator() ;
virtual date_type get_date(year_type y) const = 0;
virtual std::string to_string() const =0;
};
template<class date_type>
class partial_date : public year_based_generator<date_type>
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_type day_type;
typedef typename calendar_type::month_type month_type;
typedef typename calendar_type::year_type year_type;
typedef typename date_type::duration_type duration_type;
typedef typename duration_type::duration_rep duration_rep;
partial_date(day_type d, month_type m)
;
partial_date(duration_rep days)
;
date_type get_date(year_type y) const
;
date_type operator()(year_type y) const
;
bool operator==(const partial_date& rhs) const
;
bool operator<(const partial_date& rhs) const
;
month_type month() const
;
day_type day() const
;
virtual std::string to_string() const
;
private:
day_type day_;
month_type month_;
};
const char* nth_as_str(int n);
template<class date_type>
class nth_kday_of_month : public year_based_generator<date_type>
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_of_week_type day_of_week_type;
typedef typename calendar_type::month_type month_type;
typedef typename calendar_type::year_type year_type;
typedef typename date_type::duration_type duration_type;
enum week_num {first=1, second, third, fourth, fifth};
nth_kday_of_month(week_num week_no,
day_of_week_type dow,
month_type m)
;
date_type get_date(year_type y) const
;
month_type month() const
;
week_num nth_week() const
;
day_of_week_type day_of_week() const
;
const char* nth_week_as_str() const
;
virtual std::string to_string() const
;
private:
month_type month_;
week_num wn_;
day_of_week_type dow_;
};
template<class date_type>
class first_kday_of_month : public year_based_generator<date_type>
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_of_week_type day_of_week_type;
typedef typename calendar_type::month_type month_type;
typedef typename calendar_type::year_type year_type;
typedef typename date_type::duration_type duration_type;
first_kday_of_month(day_of_week_type dow, month_type m)
;
date_type get_date(year_type year) const
;
month_type month() const
;
day_of_week_type day_of_week() const
;
virtual std::string to_string() const
;
private:
month_type month_;
day_of_week_type dow_;
};
template<class date_type>
class last_kday_of_month : public year_based_generator<date_type>
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_of_week_type day_of_week_type;
typedef typename calendar_type::month_type month_type;
typedef typename calendar_type::year_type year_type;
typedef typename date_type::duration_type duration_type;
last_kday_of_month(day_of_week_type dow, month_type m)
;
date_type get_date(year_type year) const
;
month_type month() const
;
day_of_week_type day_of_week() const
;
virtual std::string to_string() const
;
private:
month_type month_;
day_of_week_type dow_;
};
template<class date_type>
class first_kday_after
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_of_week_type day_of_week_type;
typedef typename date_type::duration_type duration_type;
first_kday_after(day_of_week_type dow)
;
date_type get_date(date_type start_day) const
;
day_of_week_type day_of_week() const
;
private:
day_of_week_type dow_;
};
template<class date_type>
class first_kday_before
{
public:
typedef typename date_type::calendar_type calendar_type;
typedef typename calendar_type::day_of_week_type day_of_week_type;
typedef typename date_type::duration_type duration_type;
first_kday_before(day_of_week_type dow)
;
date_type get_date(date_type start_day) const
;
day_of_week_type day_of_week() const
;
private:
day_of_week_type dow_;
};
template<typename date_type, class weekday_type>
typename date_type::duration_type days_until_weekday(const date_type& d, const weekday_type& wd)
;
template<typename date_type, class weekday_type>
typename date_type::duration_type days_before_weekday(const date_type& d, const weekday_type& wd)
;
template<class date_type, class weekday_type>
date_type next_weekday(const date_type& d, const weekday_type& wd)
;
template<class date_type, class weekday_type>
date_type previous_weekday(const date_type& d, const weekday_type& wd)
;
} }
#define DATE_CLOCK_DEVICE_HPP___
namespace boost {
namespace date_time {
template<class date_type>
class day_clock
{
public:
typedef typename date_type::ymd_type ymd_type;
static date_type local_day()
;
static typename date_type::ymd_type local_day_ymd()
;
static typename date_type::ymd_type universal_day_ymd()
;
static date_type universal_day()
;
private:
static ::std::tm* get_local_time(std::tm& result)
;
static ::std::tm* get_universal_time(std::tm& result)
;
};
} }
#define DATE_ITERATOR_HPP___
namespace boost {
namespace date_time {
enum date_resolutions {day, week, months, year, decade, century, NumDateResolutions};
template<class date_type>
class date_itr_base {
public:
typedef typename date_type::duration_type duration_type;
typedef date_type value_type;
typedef std::input_iterator_tag iterator_category;
date_itr_base(date_type d) ;
virtual ~date_itr_base() ;
date_itr_base& operator++()
;
date_itr_base& operator--()
;
virtual duration_type get_offset(const date_type& current) const=0;
virtual duration_type get_neg_offset(const date_type& current) const=0;
date_type operator*() ;
date_type* operator->() ;
bool operator< (const date_type& d) ;
bool operator<= (const date_type& d) ;
bool operator> (const date_type& d) ;
bool operator>= (const date_type& d) ;
bool operator== (const date_type& d) ;
bool operator!= (const date_type& d) ;
private:
date_type current_;
};
template<class offset_functor, class date_type>
class date_itr : public date_itr_base<date_type> {
public:
typedef typename date_type::duration_type duration_type;
date_itr(date_type d, int factor=1)
;
private:
virtual duration_type get_offset(const date_type& current) const
;
virtual duration_type get_neg_offset(const date_type& current) const
;
offset_functor of_;
};
} }
namespace boost {
namespace gregorian {
typedef date_time::period<date, date_duration> date_period;
typedef date_time::year_based_generator<date> year_based_generator;
typedef date_time::partial_date<date> partial_date;
typedef date_time::nth_kday_of_month<date> nth_kday_of_month;
typedef nth_kday_of_month nth_day_of_the_week_in_month;
typedef date_time::first_kday_of_month<date> first_kday_of_month;
typedef first_kday_of_month first_day_of_the_week_in_month;
typedef date_time::last_kday_of_month<date> last_kday_of_month;
typedef last_kday_of_month last_day_of_the_week_in_month;
typedef date_time::first_kday_after<date> first_kday_after;
typedef first_kday_after first_day_of_the_week_after;
typedef date_time::first_kday_before<date> first_kday_before;
typedef first_kday_before first_day_of_the_week_before;
typedef date_time::day_clock<date> day_clock;
typedef date_time::date_itr_base<date> date_iterator;
typedef date_time::date_itr<date_time::day_functor<date>,
date> day_iterator;
typedef date_time::date_itr<date_time::week_functor<date>,
date> week_iterator;
typedef date_time::date_itr<date_time::month_functor<date>,
date> month_iterator;
typedef date_time::date_itr<date_time::year_functor<date>,
date> year_iterator;
using date_time::days_until_weekday;
using date_time::days_before_weekday;
using date_time::next_weekday;
using date_time::previous_weekday;
} }
namespace boost {
namespace posix_time {
#define BOOST_DATE_TIME_HAS_MILLISECONDS
#define BOOST_DATE_TIME_HAS_MICROSECONDS
#undef BOOST_DATE_TIME_HAS_NANOSECONDS
typedef date_time::time_resolution_traits<
boost::date_time::time_resolution_traits_adapted64_impl, boost::date_time::micro,
1000000, 6 > time_res_traits;
class time_duration :
public date_time::time_duration<time_duration, time_res_traits>
{
public:
typedef time_res_traits rep_type;
typedef time_res_traits::day_type day_type;
typedef time_res_traits::hour_type hour_type;
typedef time_res_traits::min_type min_type;
typedef time_res_traits::sec_type sec_type;
typedef time_res_traits::fractional_seconds_type fractional_seconds_type;
typedef time_res_traits::tick_type tick_type;
typedef time_res_traits::impl_type impl_type;
time_duration(hour_type hour,
min_type min,
sec_type sec,
fractional_seconds_type fs=0)
;
time_duration()
;
time_duration(boost::date_time::special_values sv)
;
friend class date_time::time_duration<time_duration, time_res_traits>;
protected:
explicit time_duration(impl_type tick_count)
;
};
class millisec_posix_time_system_config
{
public:
typedef boost::int64_t time_rep_type;
typedef gregorian::date date_type;
typedef gregorian::date_duration date_duration_type;
typedef time_duration time_duration_type;
typedef time_res_traits::tick_type int_type;
typedef time_res_traits::impl_type impl_type;
typedef time_res_traits resolution_traits;
static const boost::int64_t tick_per_second = 1000000;
};
} }
#define DATE_TIME_TIME_SYSTEM_SPLIT_HPP
namespace boost {
namespace date_time {
template<typename config>
class split_timedate_system
{
public:
typedef typename config::time_rep_type time_rep_type;
typedef typename config::date_type date_type;
typedef typename config::time_duration_type time_duration_type;
typedef typename config::date_duration_type date_duration_type;
typedef typename config::int_type int_type;
typedef typename config::resolution_traits resolution_traits;
private:
static const int_type ticks_per_day = 86400L * config::tick_per_second;
public:
typedef date_time::wrapping_int<int_type, ticks_per_day> wrap_int_type;
static time_rep_type get_time_rep(special_values sv)
;
static time_rep_type get_time_rep(const date_type& day,
const time_duration_type& tod,
date_time::dst_flags = not_dst)
;
static date_type get_date(const time_rep_type& val)
;
static time_duration_type get_time_of_day(const time_rep_type& val)
;
static std::string zone_name(const time_rep_type&)
;
static bool is_equal(const time_rep_type& lhs, const time_rep_type& rhs)
;
static bool is_less(const time_rep_type& lhs, const time_rep_type& rhs)
;
static time_rep_type add_days(const time_rep_type& base,
const date_duration_type& dd)
;
static time_rep_type subtract_days(const time_rep_type& base,
const date_duration_type& dd)
;
static time_rep_type subtract_time_duration(const time_rep_type& base,
const time_duration_type& td)
;
static time_rep_type add_time_duration(const time_rep_type& base,
time_duration_type td)
;
static time_duration_type subtract_times(const time_rep_type& lhs,
const time_rep_type& rhs)
;
};
} }
#define DATE_TIME_TIME_SYSTEM_COUNTED_HPP
namespace boost {
namespace date_time {
template<class config>
struct counted_time_rep
{
typedef typename config::int_type int_type;
typedef typename config::date_type date_type;
typedef typename config::impl_type impl_type;
typedef typename date_type::duration_type date_duration_type;
typedef typename date_type::calendar_type calendar_type;
typedef typename date_type::ymd_type ymd_type;
typedef typename config::time_duration_type time_duration_type;
typedef typename config::resolution_traits resolution_traits;
counted_time_rep(const date_type& d, const time_duration_type& time_of_day)
;
explicit counted_time_rep(int_type count)
;
explicit counted_time_rep(impl_type count)
;
date_type date() const
;
unsigned long day_count() const
;
int_type time_count() const
;
int_type tod() const
;
static int_type frac_sec_per_day()
;
bool is_pos_infinity()const
;
bool is_neg_infinity()const
;
bool is_not_a_date_time()const
;
bool is_special()const
;
impl_type get_rep()const
;
private:
impl_type time_count_;
};
template<class time_rep>
class counted_time_system
{
public:
typedef time_rep time_rep_type;
typedef typename time_rep_type::impl_type impl_type;
typedef typename time_rep_type::time_duration_type time_duration_type;
typedef typename time_duration_type::fractional_seconds_type fractional_seconds_type;
typedef typename time_rep_type::date_type date_type;
typedef typename time_rep_type::date_duration_type date_duration_type;
template<class T> static void unused_var(const T&) ;
static time_rep_type get_time_rep(const date_type& day,
const time_duration_type& tod,
date_time::dst_flags dst=not_dst)
;
static time_rep_type get_time_rep(special_values sv)
;
static date_type get_date(const time_rep_type& val)
;
static time_duration_type get_time_of_day(const time_rep_type& val)
;
static std::string zone_name(const time_rep_type&)
;
static bool is_equal(const time_rep_type& lhs, const time_rep_type& rhs)
;
static bool is_less(const time_rep_type& lhs, const time_rep_type& rhs)
;
static time_rep_type add_days(const time_rep_type& base,
const date_duration_type& dd)
;
static time_rep_type subtract_days(const time_rep_type& base,
const date_duration_type& dd)
;
static time_rep_type subtract_time_duration(const time_rep_type& base,
const time_duration_type& td)
;
static time_rep_type add_time_duration(const time_rep_type& base,
time_duration_type td)
;
static time_duration_type subtract_times(const time_rep_type& lhs,
const time_rep_type& rhs)
;
};
} }
namespace boost {
namespace posix_time {
typedef date_time::counted_time_rep<millisec_posix_time_system_config> int64_time_rep;
typedef date_time::counted_time_system<int64_time_rep> posix_time_system;
} }
#define DATE_TIME_TIME_HPP___
namespace boost {
namespace date_time {
template <class T, class time_system>
class base_time : private
boost::less_than_comparable<T
, boost::equality_comparable<T
> >
{
public:
typedef T time_type;
typedef typename time_system::time_rep_type time_rep_type;
typedef typename time_system::date_type date_type;
typedef typename time_system::date_duration_type date_duration_type;
typedef typename time_system::time_duration_type time_duration_type;
base_time(const date_type& day,
const time_duration_type& td,
dst_flags dst=not_dst)
;
base_time(special_values sv)
;
base_time(const time_rep_type& rhs)
;
date_type date() const
;
time_duration_type time_of_day() const
;
std::string zone_name(bool =false) const
;
std::string zone_abbrev(bool =false) const
;
std::string zone_as_posix_string() const
;
bool is_not_a_date_time() const
;
bool is_infinity() const
;
bool is_pos_infinity() const
;
bool is_neg_infinity() const
;
bool is_special() const
;
bool operator==(const time_type& rhs) const
;
bool operator<(const time_type& rhs) const
;
time_duration_type operator-(const time_type& rhs) const
;
time_type operator+(const date_duration_type& dd) const
;
time_type operator+=(const date_duration_type& dd)
;
time_type operator-(const date_duration_type& dd) const
;
time_type operator-=(const date_duration_type& dd)
;
time_type operator+(const time_duration_type& td) const
;
time_type operator+=(const time_duration_type& td)
;
time_type operator-(const time_duration_type& rhs) const
;
time_type operator-=(const time_duration_type& td)
;
protected:
time_rep_type time_;
};
} }
namespace boost {
namespace posix_time {
using date_time::special_values;
using date_time::not_special;
using date_time::neg_infin;
using date_time::pos_infin;
using date_time::not_a_date_time;
using date_time::max_date_time;
using date_time::min_date_time;
class ptime : public date_time::base_time<ptime, posix_time_system>
{
public:
typedef posix_time_system time_system_type;
typedef time_system_type::time_rep_type time_rep_type;
typedef time_system_type::time_duration_type time_duration_type;
typedef ptime time_type;
ptime(gregorian::date d,time_duration_type td)
;
explicit ptime(gregorian::date d)
;
ptime(const time_rep_type& rhs)
;
ptime(const special_values sv)
;
ptime()
;
};
} }
#define DATE_DURATION_OPERATORS_HPP___
namespace boost {
namespace posix_time {
ptime
operator+(const ptime& t, const boost::gregorian::months& m)
;
ptime
operator+=(ptime& t, const boost::gregorian::months& m)
;
ptime
operator-(const ptime& t, const boost::gregorian::months& m)
;
ptime
operator-=(ptime& t, const boost::gregorian::months& m)
;
ptime
operator+(const ptime& t, const boost::gregorian::years& y)
;
ptime
operator+=(ptime& t, const boost::gregorian::years& y)
;
ptime
operator-(const ptime& t, const boost::gregorian::years& y)
;
ptime
operator-=(ptime& t, const boost::gregorian::years& y)
;
}}
#define POSIX_TIME_DURATION_HPP___
namespace boost {
namespace posix_time {
class hours : public time_duration
{
public:
explicit hours(long h)
;
};
class minutes : public time_duration
{
public:
explicit minutes(long m)
;
};
class seconds : public time_duration
{
public:
explicit seconds(long s)
;
};
typedef date_time::subsecond_duration<time_duration,1000> millisec;
typedef date_time::subsecond_duration<time_duration,1000> milliseconds;
typedef date_time::subsecond_duration<time_duration,1000000> microsec;
typedef date_time::subsecond_duration<time_duration,1000000> microseconds;
} }
#define POSIX_TIME_PERIOD_HPP___
namespace boost {
namespace posix_time {
typedef date_time::period<ptime, time_duration> time_period;
} }
#define DATE_TIME_TIME_ITERATOR_HPP___
namespace boost {
namespace date_time {
template<class time_type>
class time_itr {
public:
typedef typename time_type::time_duration_type time_duration_type;
time_itr(time_type t, time_duration_type d) ;
time_itr& operator++()
;
time_itr& operator--()
;
time_type operator*() ;
time_type* operator->() ;
bool operator< (const time_type& t) ;
bool operator<= (const time_type& t) ;
bool operator!= (const time_type& t) ;
bool operator== (const time_type& t) ;
bool operator> (const time_type& t) ;
bool operator>= (const time_type& t) ;
private:
time_type current_;
time_duration_type offset_;
};
} }
#define DATE_TIME_DST_RULES_HPP__
namespace boost {
namespace date_time {
enum time_is_dst_result {is_not_in_dst, is_in_dst,
ambiguous, invalid_time_label};
template<class date_type_,
class time_duration_type_>
class dst_calculator
{
public:
typedef time_duration_type_ time_duration_type;
typedef date_type_ date_type;
static time_is_dst_result
process_local_dst_start_day(const time_duration_type& time_of_day,
unsigned int dst_start_offset_minutes,
long dst_length_minutes)
;
static time_is_dst_result
process_local_dst_end_day(const time_duration_type& time_of_day,
unsigned int dst_end_offset_minutes,
long dst_length_minutes)
;
static time_is_dst_result
local_is_dst(const date_type& current_day,
const time_duration_type& time_of_day,
const date_type& dst_start_day,
const time_duration_type& dst_start_offset,
const date_type& dst_end_day,
const time_duration_type& dst_end_offset,
const time_duration_type& dst_length_minutes)
;
static time_is_dst_result
local_is_dst(const date_type& current_day,
const time_duration_type& time_of_day,
const date_type& dst_start_day,
unsigned int dst_start_offset_minutes,
const date_type& dst_end_day,
unsigned int dst_end_offset_minutes,
long dst_length_minutes)
;
};
template<class date_type,
class time_duration_type,
class dst_traits>
class dst_calc_engine
{
public:
typedef typename date_type::year_type year_type;
typedef typename date_type::calendar_type calendar_type;
typedef dst_calculator<date_type, time_duration_type> dstcalc;
static time_is_dst_result local_is_dst(const date_type& d,
const time_duration_type& td)
;
static bool is_dst_boundary_day(date_type d)
;
static time_duration_type dst_offset()
;
static date_type local_dst_start_day(year_type year)
;
static date_type local_dst_end_day(year_type year)
;
};
template<class date_type_,
class time_duration_type_,
unsigned int dst_start_offset_minutes=120,
short dst_length_minutes=60>
class us_dst_rules
{
public:
typedef time_duration_type_ time_duration_type;
typedef date_type_ date_type;
typedef typename date_type::year_type year_type;
typedef typename date_type::calendar_type calendar_type;
typedef date_time::last_kday_of_month<date_type> lkday;
typedef date_time::first_kday_of_month<date_type> fkday;
typedef date_time::nth_kday_of_month<date_type> nkday;
typedef dst_calculator<date_type, time_duration_type> dstcalc;
static time_is_dst_result local_is_dst(const date_type& d,
const time_duration_type& td)
;
static bool is_dst_boundary_day(date_type d)
;
static date_type local_dst_start_day(year_type year)
;
static date_type local_dst_end_day(year_type year)
;
static time_duration_type dst_offset()
;
private:
};
template<class date_type_, class time_duration_type_>
class null_dst_rules
{
public:
typedef time_duration_type_ time_duration_type;
typedef date_type_ date_type;
static time_is_dst_result local_is_dst(const date_type&,
const time_duration_type&)
;
static time_is_dst_result utc_is_dst(const date_type&,
const time_duration_type&)
;
static bool is_dst_boundary_day(date_type )
;
static time_duration_type dst_offset()
;
};
} }
namespace boost {
namespace posix_time {
typedef date_time::time_itr<ptime> time_iterator;
typedef date_time::second_clock<ptime> second_clock;
typedef date_time::microsec_clock<ptime> microsec_clock;
typedef date_time::null_dst_rules<ptime::date_type, time_duration> no_dst;
typedef date_time::us_dst_rules<ptime::date_type, time_duration> us_dst;
} }
namespace boost {
namespace asio {
template <typename Time>
struct time_traits;
template <>
struct time_traits<boost::posix_time::ptime>
{
typedef boost::posix_time::ptime time_type;
typedef boost::posix_time::time_duration duration_type;
static time_type now()
;
static time_type add(const time_type& t, const duration_type& d)
;
static duration_type subtract(const time_type& t1, const time_type& t2)
;
static bool less_than(const time_type& t1, const time_type& t2)
;
static boost::posix_time::time_duration to_posix_duration(
const duration_type& d)
;
};
}
}
#define BOOST_ASIO_DETAIL_TIMER_QUEUE_PTIME_HPP
namespace boost {
namespace asio {
namespace detail {
struct forwarding_posix_time_traits : time_traits<boost::posix_time::ptime> {};
template <>
class timer_queue<time_traits<boost::posix_time::ptime> >
: public timer_queue_base
{
public:
typedef boost::posix_time::ptime time_type;
typedef boost::posix_time::time_duration duration_type;
typedef timer_queue<forwarding_posix_time_traits>::per_timer_data
per_timer_data;
inline timer_queue();
inline virtual ~timer_queue();
inline bool enqueue_timer(const time_type& time,
per_timer_data& timer, wait_op* op);
inline virtual bool empty() const;
inline virtual long wait_duration_msec(long max_duration) const;
inline virtual long wait_duration_usec(long max_duration) const;
inline virtual void get_ready_timers(op_queue<operation>& ops);
inline virtual void get_all_timers(op_queue<operation>& ops);
inline std::size_t cancel_timer(
per_timer_data& timer, op_queue<operation>& ops,
std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
private:
timer_queue<forwarding_posix_time_traits> impl_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_TIMER_QUEUE_PTIME_IPP
namespace boost {
namespace asio {
namespace detail {
bool timer_queue<time_traits<boost::posix_time::ptime> >::enqueue_timer(
const time_type& time, per_timer_data& timer, wait_op* op)
{
return impl_.enqueue_timer(time, timer, op);
}
bool timer_queue<time_traits<boost::posix_time::ptime> >::empty() const
{
return impl_.empty();
}
}
}
}
namespace boost {
namespace asio {
template <typename TimeType,
typename TimeTraits = boost::asio::time_traits<TimeType> >
class deadline_timer_service
: public boost::asio::detail::service_base<
deadline_timer_service<TimeType, TimeTraits> >
{
public:
typedef TimeTraits traits_type;
typedef typename traits_type::time_type time_type;
typedef typename traits_type::duration_type duration_type;
private:
typedef detail::deadline_timer_service<traits_type> service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
explicit deadline_timer_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void destroy(implementation_type& impl)
;
std::size_t cancel(implementation_type& impl, boost::system::error_code& ec)
;
std::size_t cancel_one(implementation_type& impl,
boost::system::error_code& ec)
;
time_type expires_at(const implementation_type& impl) const
;
std::size_t expires_at(implementation_type& impl,
const time_type& expiry_time, boost::system::error_code& ec)
;
duration_type expires_from_now(const implementation_type& impl) const
;
std::size_t expires_from_now(implementation_type& impl,
const duration_type& expiry_time, boost::system::error_code& ec)
;
void wait(implementation_type& impl, boost::system::error_code& ec)
;
template <typename WaitHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WaitHandler, void (boost::system::error_code)>::type>::type
async_wait(implementation_type& impl,
WaitHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename Time,
typename TimeTraits = boost::asio::time_traits<Time>,
typename TimerService = deadline_timer_service<Time, TimeTraits> >
class basic_deadline_timer
: public basic_io_object<TimerService>
{
public:
typedef TimeTraits traits_type;
typedef typename traits_type::time_type time_type;
typedef typename traits_type::duration_type duration_type;
explicit basic_deadline_timer(boost::asio::io_service& io_service)
;
basic_deadline_timer(boost::asio::io_service& io_service,
const time_type& expiry_time)
;
basic_deadline_timer(boost::asio::io_service& io_service,
const duration_type& expiry_time)
;
std::size_t cancel()
;
std::size_t cancel(boost::system::error_code& ec)
;
std::size_t cancel_one()
;
std::size_t cancel_one(boost::system::error_code& ec)
;
time_type expires_at() const
;
std::size_t expires_at(const time_type& expiry_time)
;
std::size_t expires_at(const time_type& expiry_time,
boost::system::error_code& ec)
;
duration_type expires_from_now() const
;
std::size_t expires_from_now(const duration_type& expiry_time)
;
std::size_t expires_from_now(const duration_type& expiry_time,
boost::system::error_code& ec)
;
void wait()
;
void wait(boost::system::error_code& ec)
;
template <typename WaitHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WaitHandler, void (boost::system::error_code)>::type>::type
async_wait(WaitHandler&& handler)
;
};
}
}
#define BOOST_ASIO_BASIC_RAW_SOCKET_HPP
#define BOOST_ASIO_RAW_SOCKET_SERVICE_HPP
namespace boost {
namespace asio {
template <typename Protocol>
class raw_socket_service
: public boost::asio::detail::service_base<raw_socket_service<Protocol> >
{
public:
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
private:
typedef detail::reactive_socket_service<Protocol> service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
typedef typename service_impl_type::native_handle_type native_type;
typedef typename service_impl_type::native_handle_type native_handle_type;
explicit raw_socket_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
raw_socket_service& other_service,
implementation_type& other_impl)
;
template <typename Protocol1>
void converting_move_construct(implementation_type& impl,
typename raw_socket_service<
Protocol1>::implementation_type& other_impl,
typename enable_if<is_convertible<
Protocol1, Protocol>::value>::type* = 0)
;
void destroy(implementation_type& impl)
;
boost::system::error_code open(implementation_type& impl,
const protocol_type& protocol, boost::system::error_code& ec)
;
boost::system::error_code assign(implementation_type& impl,
const protocol_type& protocol, const native_handle_type& native_socket,
boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_type native(implementation_type& impl)
;
native_handle_type native_handle(implementation_type& impl)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
bool at_mark(const implementation_type& impl,
boost::system::error_code& ec) const
;
std::size_t available(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code bind(implementation_type& impl,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
boost::system::error_code connect(implementation_type& impl,
const endpoint_type& peer_endpoint, boost::system::error_code& ec)
;
template <typename ConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ConnectHandler, void (boost::system::error_code)>::type>::type
async_connect(implementation_type& impl,
const endpoint_type& peer_endpoint,
ConnectHandler&& handler)
;
template <typename SettableSocketOption>
boost::system::error_code set_option(implementation_type& impl,
const SettableSocketOption& option, boost::system::error_code& ec)
;
template <typename GettableSocketOption>
boost::system::error_code get_option(const implementation_type& impl,
GettableSocketOption& option, boost::system::error_code& ec) const
;
template <typename IoControlCommand>
boost::system::error_code io_control(implementation_type& impl,
IoControlCommand& command, boost::system::error_code& ec)
;
bool non_blocking(const implementation_type& impl) const
;
boost::system::error_code non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const implementation_type& impl) const
;
boost::system::error_code native_non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
endpoint_type local_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
endpoint_type remote_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code shutdown(implementation_type& impl,
socket_base::shutdown_type what, boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t send(implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(implementation_type& impl, const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename ConstBufferSequence>
std::size_t send_to(implementation_type& impl,
const ConstBufferSequence& buffers, const endpoint_type& destination,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send_to(implementation_type& impl,
const ConstBufferSequence& buffers, const endpoint_type& destination,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags,
ReadHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive_from(implementation_type& impl,
const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive_from(implementation_type& impl,
const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
socket_base::message_flags flags,
ReadHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename Protocol,
typename RawSocketService = raw_socket_service<Protocol> >
class basic_raw_socket
: public basic_socket<Protocol, RawSocketService>
{
public:
typedef typename RawSocketService::native_handle_type native_type;
typedef typename RawSocketService::native_handle_type native_handle_type;
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
explicit basic_raw_socket(boost::asio::io_service& io_service)
;
basic_raw_socket(boost::asio::io_service& io_service,
const protocol_type& protocol)
;
basic_raw_socket(boost::asio::io_service& io_service,
const endpoint_type& endpoint)
;
basic_raw_socket(boost::asio::io_service& io_service,
const protocol_type& protocol, const native_handle_type& native_socket)
;
basic_raw_socket(basic_raw_socket&& other)
;
basic_raw_socket& operator=(basic_raw_socket&& other)
;
template <typename Protocol1, typename RawSocketService1>
basic_raw_socket(basic_raw_socket<Protocol1, RawSocketService1>&& other,
typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
;
template <typename Protocol1, typename RawSocketService1>
typename enable_if<is_convertible<Protocol1, Protocol>::value,
basic_raw_socket>::type& operator=(
basic_raw_socket<Protocol1, RawSocketService1>&& other)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename ConstBufferSequence>
std::size_t send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination)
;
template <typename ConstBufferSequence>
std::size_t send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags)
;
template <typename ConstBufferSequence>
std::size_t send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination,
WriteHandler&& handler)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send_to(const ConstBufferSequence& buffers,
const endpoint_type& destination, socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags,
ReadHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint)
;
template <typename MutableBufferSequence>
std::size_t receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint, socket_base::message_flags flags)
;
template <typename MutableBufferSequence>
std::size_t receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint, socket_base::message_flags flags,
boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint,
ReadHandler&& handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive_from(const MutableBufferSequence& buffers,
endpoint_type& sender_endpoint, socket_base::message_flags flags,
ReadHandler&& handler)
;
};
}
}
#define BOOST_ASIO_BASIC_SEQ_PACKET_SOCKET_HPP
#define BOOST_ASIO_SEQ_PACKET_SOCKET_SERVICE_HPP
namespace boost {
namespace asio {
template <typename Protocol>
class seq_packet_socket_service
: public boost::asio::detail::service_base<
seq_packet_socket_service<Protocol> >
{
public:
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
private:
typedef detail::reactive_socket_service<Protocol> service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
typedef typename service_impl_type::native_handle_type native_type;
typedef typename service_impl_type::native_handle_type native_handle_type;
explicit seq_packet_socket_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
seq_packet_socket_service& other_service,
implementation_type& other_impl)
;
template <typename Protocol1>
void converting_move_construct(implementation_type& impl,
typename seq_packet_socket_service<
Protocol1>::implementation_type& other_impl,
typename enable_if<is_convertible<
Protocol1, Protocol>::value>::type* = 0)
;
void destroy(implementation_type& impl)
;
boost::system::error_code open(implementation_type& impl,
const protocol_type& protocol, boost::system::error_code& ec)
;
boost::system::error_code assign(implementation_type& impl,
const protocol_type& protocol, const native_handle_type& native_socket,
boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_type native(implementation_type& impl)
;
native_handle_type native_handle(implementation_type& impl)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
bool at_mark(const implementation_type& impl,
boost::system::error_code& ec) const
;
std::size_t available(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code bind(implementation_type& impl,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
boost::system::error_code connect(implementation_type& impl,
const endpoint_type& peer_endpoint, boost::system::error_code& ec)
;
template <typename ConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ConnectHandler, void (boost::system::error_code)>::type>::type
async_connect(implementation_type& impl,
const endpoint_type& peer_endpoint,
ConnectHandler&& handler)
;
template <typename SettableSocketOption>
boost::system::error_code set_option(implementation_type& impl,
const SettableSocketOption& option, boost::system::error_code& ec)
;
template <typename GettableSocketOption>
boost::system::error_code get_option(const implementation_type& impl,
GettableSocketOption& option, boost::system::error_code& ec) const
;
template <typename IoControlCommand>
boost::system::error_code io_control(implementation_type& impl,
IoControlCommand& command, boost::system::error_code& ec)
;
bool non_blocking(const implementation_type& impl) const
;
boost::system::error_code non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const implementation_type& impl) const
;
boost::system::error_code native_non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
endpoint_type local_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
endpoint_type remote_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code shutdown(implementation_type& impl,
socket_base::shutdown_type what, boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t send(implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(implementation_type& impl,
const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
socket_base::message_flags& out_flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(implementation_type& impl,
const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
socket_base::message_flags& out_flags,
ReadHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename Protocol,
typename SeqPacketSocketService = seq_packet_socket_service<Protocol> >
class basic_seq_packet_socket
: public basic_socket<Protocol, SeqPacketSocketService>
{
public:
typedef typename SeqPacketSocketService::native_handle_type native_type;
typedef typename SeqPacketSocketService::native_handle_type
native_handle_type;
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
explicit basic_seq_packet_socket(boost::asio::io_service& io_service)
;
basic_seq_packet_socket(boost::asio::io_service& io_service,
const protocol_type& protocol)
;
basic_seq_packet_socket(boost::asio::io_service& io_service,
const endpoint_type& endpoint)
;
basic_seq_packet_socket(boost::asio::io_service& io_service,
const protocol_type& protocol, const native_handle_type& native_socket)
;
basic_seq_packet_socket(basic_seq_packet_socket&& other)
;
basic_seq_packet_socket& operator=(basic_seq_packet_socket&& other)
;
template <typename Protocol1, typename SeqPacketSocketService1>
basic_seq_packet_socket(
basic_seq_packet_socket<Protocol1, SeqPacketSocketService1>&& other,
typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
;
template <typename Protocol1, typename SeqPacketSocketService1>
typename enable_if<is_convertible<Protocol1, Protocol>::value,
basic_seq_packet_socket>::type& operator=(
basic_seq_packet_socket<Protocol1, SeqPacketSocketService1>&& other)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags& out_flags)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags in_flags,
socket_base::message_flags& out_flags)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags in_flags,
socket_base::message_flags& out_flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
socket_base::message_flags& out_flags,
ReadHandler&& handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
socket_base::message_flags in_flags,
socket_base::message_flags& out_flags,
ReadHandler&& handler)
;
};
}
}
#define BOOST_ASIO_BASIC_SERIAL_PORT_HPP
#define BOOST_ASIO_SERIAL_PORT_BASE_HPP
#define _TERMIOS_H 1
extern "C" {
typedef unsigned char cc_t;
typedef unsigned int speed_t;
typedef unsigned int tcflag_t;
#define NCCS 32
struct termios
{
tcflag_t c_iflag;
tcflag_t c_oflag;
tcflag_t c_cflag;
tcflag_t c_lflag;
cc_t c_line;
cc_t c_cc[32];
speed_t c_ispeed;
speed_t c_ospeed;
#define _HAVE_STRUCT_TERMIOS_C_ISPEED 1
#define _HAVE_STRUCT_TERMIOS_C_OSPEED 1
};
#define VINTR 0
#define VQUIT 1
#define VERASE 2
#define VKILL 3
#define VEOF 4
#define VTIME 5
#define VMIN 6
#define VSWTC 7
#define VSTART 8
#define VSTOP 9
#define VSUSP 10
#define VEOL 11
#define VREPRINT 12
#define VDISCARD 13
#define VWERASE 14
#define VLNEXT 15
#define VEOL2 16
#define IGNBRK 0000001
#define BRKINT 0000002
#define IGNPAR 0000004
#define PARMRK 0000010
#define INPCK 0000020
#define ISTRIP 0000040
#define INLCR 0000100
#define IGNCR 0000200
#define ICRNL 0000400
#define IUCLC 0001000
#define IXON 0002000
#define IXANY 0004000
#define IXOFF 0010000
#define IMAXBEL 0020000
#define IUTF8 0040000
#define OPOST 0000001
#define OLCUC 0000002
#define ONLCR 0000004
#define OCRNL 0000010
#define ONOCR 0000020
#define ONLRET 0000040
#define OFILL 0000100
#define OFDEL 0000200
#define NLDLY 0000400
#define NL0 0000000
#define NL1 0000400
#define CRDLY 0003000
#define CR0 0000000
#define CR1 0001000
#define CR2 0002000
#define CR3 0003000
#define TABDLY 0014000
#define TAB0 0000000
#define TAB1 0004000
#define TAB2 0010000
#define TAB3 0014000
#define BSDLY 0020000
#define BS0 0000000
#define BS1 0020000
#define FFDLY 0100000
#define FF0 0000000
#define FF1 0100000
#define VTDLY 0040000
#define VT0 0000000
#define VT1 0040000
#define XTABS 0014000
#define CBAUD 0010017
#define B0 0000000
#define B50 0000001
#define B75 0000002
#define B110 0000003
#define B134 0000004
#define B150 0000005
#define B200 0000006
#define B300 0000007
#define B600 0000010
#define B1200 0000011
#define B1800 0000012
#define B2400 0000013
#define B4800 0000014
#define B9600 0000015
#define B19200 0000016
#define B38400 0000017
#define EXTA B19200
#define EXTB B38400
#define CSIZE 0000060
#define CS5 0000000
#define CS6 0000020
#define CS7 0000040
#define CS8 0000060
#define CSTOPB 0000100
#define CREAD 0000200
#define PARENB 0000400
#define PARODD 0001000
#define HUPCL 0002000
#define CLOCAL 0004000
#define CBAUDEX 0010000
#define B57600 0010001
#define B115200 0010002
#define B230400 0010003
#define B460800 0010004
#define B500000 0010005
#define B576000 0010006
#define B921600 0010007
#define B1000000 0010010
#define B1152000 0010011
#define B1500000 0010012
#define B2000000 0010013
#define B2500000 0010014
#define B3000000 0010015
#define B3500000 0010016
#define B4000000 0010017
#define __MAX_BAUD B4000000
#define CIBAUD 002003600000
#define CMSPAR 010000000000
#define CRTSCTS 020000000000
#define ISIG 0000001
#define ICANON 0000002
#define XCASE 0000004
#define ECHO 0000010
#define ECHOE 0000020
#define ECHOK 0000040
#define ECHONL 0000100
#define NOFLSH 0000200
#define TOSTOP 0000400
#define ECHOCTL 0001000
#define ECHOPRT 0002000
#define ECHOKE 0004000
#define FLUSHO 0010000
#define PENDIN 0040000
#define IEXTEN 0100000
#define EXTPROC 0200000
#define TCOOFF 0
#define TCOON 1
#define TCIOFF 2
#define TCION 3
#define TCIFLUSH 0
#define TCOFLUSH 1
#define TCIOFLUSH 2
#define TCSANOW 0
#define TCSADRAIN 1
#define TCSAFLUSH 2
#define _IOT_termios _IOT (_IOTS (cflag_t), 4, _IOTS (cc_t), NCCS, _IOTS (speed_t), 2)
#define CCEQ(val,c) ((c) == (val) && (val) != _POSIX_VDISABLE)
extern speed_t cfgetospeed (const struct termios *__termios_p) throw ();
extern speed_t cfgetispeed (const struct termios *__termios_p) throw ();
extern int cfsetospeed (struct termios *__termios_p, speed_t __speed) throw ();
extern int cfsetispeed (struct termios *__termios_p, speed_t __speed) throw ();
extern int cfsetspeed (struct termios *__termios_p, speed_t __speed) throw ();
extern int tcgetattr (int __fd, struct termios *__termios_p) throw ();
extern int tcsetattr (int __fd, int __optional_actions,
const struct termios *__termios_p) throw ();
extern void cfmakeraw (struct termios *__termios_p) throw ();
extern int tcsendbreak (int __fd, int __duration) throw ();
extern int tcdrain (int __fd);
extern int tcflush (int __fd, int __queue_selector) throw ();
extern int tcflow (int __fd, int __action) throw ();
extern __pid_t tcgetsid (int __fd) throw ();
}
#define BOOST_ASIO_OPTION_STORAGE termios
namespace boost {
namespace asio {
class serial_port_base
{
public:
class baud_rate
{
public:
explicit baud_rate(unsigned int rate = 0);
unsigned int value() const;
inline boost::system::error_code store(
termios& storage,
boost::system::error_code& ec) const;
inline boost::system::error_code load(
const termios& storage,
boost::system::error_code& ec);
private:
unsigned int value_;
};
class flow_control
{
public:
enum type { none, software, hardware };
inline explicit flow_control(type t = none);
type value() const;
inline boost::system::error_code store(
termios& storage,
boost::system::error_code& ec) const;
inline boost::system::error_code load(
const termios& storage,
boost::system::error_code& ec);
private:
type value_;
};
class parity
{
public:
enum type { none, odd, even };
inline explicit parity(type t = none);
type value() const;
inline boost::system::error_code store(
termios& storage,
boost::system::error_code& ec) const;
inline boost::system::error_code load(
const termios& storage,
boost::system::error_code& ec);
private:
type value_;
};
class stop_bits
{
public:
enum type { one, onepointfive, two };
inline explicit stop_bits(type t = one);
type value() const;
inline boost::system::error_code store(
termios& storage,
boost::system::error_code& ec) const;
inline boost::system::error_code load(
const termios& storage,
boost::system::error_code& ec);
private:
type value_;
};
class character_size
{
public:
inline explicit character_size(unsigned int t = 8);
unsigned int value() const;
inline boost::system::error_code store(
termios& storage,
boost::system::error_code& ec) const;
inline boost::system::error_code load(
const termios& storage,
boost::system::error_code& ec);
private:
unsigned int value_;
};
protected:
~serial_port_base()
;
};
}
}
#undef BOOST_ASIO_OPTION_STORAGE
#define BOOST_ASIO_IMPL_SERIAL_PORT_BASE_HPP
namespace boost {
namespace asio {
}
}
#define BOOST_ASIO_IMPL_SERIAL_PORT_BASE_IPP
#define BOOST_ASIO_OPTION_STORAGE termios
namespace boost {
namespace asio {
}
}
#undef BOOST_ASIO_OPTION_STORAGE
#define BOOST_ASIO_SERIAL_PORT_SERVICE_HPP
#define BOOST_ASIO_DETAIL_REACTIVE_SERIAL_PORT_SERVICE_HPP
#define BOOST_ASIO_DETAIL_DESCRIPTOR_OPS_HPP
namespace boost {
namespace asio {
namespace detail {
namespace descriptor_ops {
enum
{
user_set_non_blocking = 1,
internal_non_blocking = 2,
non_blocking = user_set_non_blocking | internal_non_blocking,
possible_dup = 4
};
typedef unsigned char state_type;
template <typename ReturnType>
ReturnType error_wrapper(ReturnType return_value,
boost::system::error_code& ec)
;
inline int open(const char* path, int flags,
boost::system::error_code& ec);
inline int close(int d, state_type& state,
boost::system::error_code& ec);
inline bool set_user_non_blocking(int d,
state_type& state, bool value, boost::system::error_code& ec);
inline bool set_internal_non_blocking(int d,
state_type& state, bool value, boost::system::error_code& ec);
typedef iovec buf;
inline std::size_t sync_read(int d, state_type state, buf* bufs,
std::size_t count, bool all_empty, boost::system::error_code& ec);
inline bool non_blocking_read(int d, buf* bufs, std::size_t count,
boost::system::error_code& ec, std::size_t& bytes_transferred);
inline std::size_t sync_write(int d, state_type state,
const buf* bufs, std::size_t count, bool all_empty,
boost::system::error_code& ec);
inline bool non_blocking_write(int d,
const buf* bufs, std::size_t count,
boost::system::error_code& ec, std::size_t& bytes_transferred);
inline int ioctl(int d, state_type& state, long cmd,
ioctl_arg_type* arg, boost::system::error_code& ec);
inline int fcntl(int d, int cmd, boost::system::error_code& ec);
inline int fcntl(int d, int cmd,
long arg, boost::system::error_code& ec);
inline int poll_read(int d,
state_type state, boost::system::error_code& ec);
inline int poll_write(int d,
state_type state, boost::system::error_code& ec);
}
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_DESCRIPTOR_OPS_IPP
#undef __need_error_t
namespace boost {
namespace asio {
namespace detail {
namespace descriptor_ops {
int open(const char* path, int flags, boost::system::error_code& ec)
;
int close(int d, state_type& state, boost::system::error_code& ec)
;
bool set_user_non_blocking(int d, state_type& state,
bool value, boost::system::error_code& ec)
;
bool set_internal_non_blocking(int d, state_type& state,
bool value, boost::system::error_code& ec)
;
std::size_t sync_read(int d, state_type state, buf* bufs,
std::size_t count, bool all_empty, boost::system::error_code& ec)
;
bool non_blocking_read(int d, buf* bufs, std::size_t count,
boost::system::error_code& ec, std::size_t& bytes_transferred)
;
std::size_t sync_write(int d, state_type state, const buf* bufs,
std::size_t count, bool all_empty, boost::system::error_code& ec)
;
bool non_blocking_write(int d, const buf* bufs, std::size_t count,
boost::system::error_code& ec, std::size_t& bytes_transferred)
;
int ioctl(int d, state_type& state, long cmd,
ioctl_arg_type* arg, boost::system::error_code& ec)
;
int fcntl(int d, int cmd, boost::system::error_code& ec)
;
int fcntl(int d, int cmd, long arg, boost::system::error_code& ec)
;
int poll_read(int d, state_type state, boost::system::error_code& ec)
;
int poll_write(int d, state_type state, boost::system::error_code& ec)
;
}
}
}
}
#define BOOST_ASIO_DETAIL_REACTIVE_DESCRIPTOR_SERVICE_HPP
#define BOOST_ASIO_DETAIL_DESCRIPTOR_READ_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename MutableBufferSequence>
class descriptor_read_op_base : public reactor_op
{
public:
descriptor_read_op_base(int descriptor,
const MutableBufferSequence& buffers, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
int descriptor_;
MutableBufferSequence buffers_;
};
template <typename MutableBufferSequence, typename Handler>
class descriptor_read_op
: public descriptor_read_op_base<MutableBufferSequence>
{
public:
struct ptr { Handler* h; void* v; descriptor_read_op* p; ~ptr() ; void reset() ; };
descriptor_read_op(int descriptor,
const MutableBufferSequence& buffers, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
#define BOOST_ASIO_DETAIL_DESCRIPTOR_WRITE_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename ConstBufferSequence>
class descriptor_write_op_base : public reactor_op
{
public:
descriptor_write_op_base(int descriptor,
const ConstBufferSequence& buffers, func_type complete_func)
;
static bool do_perform(reactor_op* base)
;
private:
int descriptor_;
ConstBufferSequence buffers_;
};
template <typename ConstBufferSequence, typename Handler>
class descriptor_write_op
: public descriptor_write_op_base<ConstBufferSequence>
{
public:
struct ptr { Handler* h; void* v; descriptor_write_op* p; ~ptr() ; void reset() ; };
descriptor_write_op(int descriptor,
const ConstBufferSequence& buffers, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
class reactive_descriptor_service
{
public:
typedef int native_handle_type;
class implementation_type
: private boost::asio::detail::noncopyable
{
public:
implementation_type()
;
private:
friend class reactive_descriptor_service;
int descriptor_;
descriptor_ops::state_type state_;
reactor::per_descriptor_data reactor_data_;
};
inline reactive_descriptor_service(
boost::asio::io_service& io_service);
inline void shutdown_service();
inline void construct(implementation_type& impl);
inline void move_construct(implementation_type& impl,
implementation_type& other_impl);
inline void move_assign(implementation_type& impl,
reactive_descriptor_service& other_service,
implementation_type& other_impl);
inline void destroy(implementation_type& impl);
inline boost::system::error_code assign(implementation_type& impl,
const native_handle_type& native_descriptor,
boost::system::error_code& ec);
bool is_open(const implementation_type& impl) const
;
inline boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec);
native_handle_type native_handle(const implementation_type& impl) const
;
inline native_handle_type release(implementation_type& impl);
inline boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec);
template <typename IO_Control_Command>
boost::system::error_code io_control(implementation_type& impl,
IO_Control_Command& command, boost::system::error_code& ec)
;
bool non_blocking(const implementation_type& impl) const
;
boost::system::error_code non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const implementation_type& impl) const
;
boost::system::error_code native_non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
size_t write_some(implementation_type& impl,
const ConstBufferSequence& buffers, boost::system::error_code& ec)
;
size_t write_some(implementation_type& impl,
const null_buffers&, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename Handler>
void async_write_some(implementation_type& impl,
const ConstBufferSequence& buffers, Handler& handler)
;
template <typename Handler>
void async_write_some(implementation_type& impl,
const null_buffers&, Handler& handler)
;
template <typename MutableBufferSequence>
size_t read_some(implementation_type& impl,
const MutableBufferSequence& buffers, boost::system::error_code& ec)
;
size_t read_some(implementation_type& impl,
const null_buffers&, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename Handler>
void async_read_some(implementation_type& impl,
const MutableBufferSequence& buffers, Handler& handler)
;
template <typename Handler>
void async_read_some(implementation_type& impl,
const null_buffers&, Handler& handler)
;
private:
inline void start_op(implementation_type& impl, int op_type,
reactor_op* op, bool is_continuation, bool is_non_blocking, bool noop);
reactor& reactor_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_REACTIVE_DESCRIPTOR_SERVICE_IPP
namespace boost {
namespace asio {
namespace detail {
}
}
}
namespace boost {
namespace asio {
namespace detail {
class reactive_serial_port_service
{
public:
typedef reactive_descriptor_service::native_handle_type native_handle_type;
typedef reactive_descriptor_service::implementation_type implementation_type;
inline reactive_serial_port_service(
boost::asio::io_service& io_service);
inline void shutdown_service();
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
reactive_serial_port_service& other_service,
implementation_type& other_impl)
;
void destroy(implementation_type& impl)
;
inline boost::system::error_code open(implementation_type& impl,
const std::string& device, boost::system::error_code& ec);
boost::system::error_code assign(implementation_type& impl,
const native_handle_type& native_descriptor,
boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_handle_type native_handle(implementation_type& impl)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
template <typename SettableSerialPortOption>
boost::system::error_code set_option(implementation_type& impl,
const SettableSerialPortOption& option, boost::system::error_code& ec)
;
template <typename GettableSerialPortOption>
boost::system::error_code get_option(const implementation_type& impl,
GettableSerialPortOption& option, boost::system::error_code& ec) const
;
boost::system::error_code send_break(implementation_type& impl,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
size_t write_some(implementation_type& impl,
const ConstBufferSequence& buffers, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename Handler>
void async_write_some(implementation_type& impl,
const ConstBufferSequence& buffers, Handler& handler)
;
template <typename MutableBufferSequence>
size_t read_some(implementation_type& impl,
const MutableBufferSequence& buffers, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename Handler>
void async_read_some(implementation_type& impl,
const MutableBufferSequence& buffers, Handler& handler)
;
private:
typedef boost::system::error_code (*store_function_type)(
const void*, termios&, boost::system::error_code&);
template <typename SettableSerialPortOption>
static boost::system::error_code store_option(const void* option,
termios& storage, boost::system::error_code& ec)
;
inline boost::system::error_code do_set_option(
implementation_type& impl, store_function_type store,
const void* option, boost::system::error_code& ec);
typedef boost::system::error_code (*load_function_type)(
void*, const termios&, boost::system::error_code&);
template <typename GettableSerialPortOption>
static boost::system::error_code load_option(void* option,
const termios& storage, boost::system::error_code& ec)
;
inline boost::system::error_code do_get_option(
const implementation_type& impl, load_function_type load,
void* option, boost::system::error_code& ec) const;
reactive_descriptor_service descriptor_service_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_REACTIVE_SERIAL_PORT_SERVICE_IPP
namespace boost {
namespace asio {
namespace detail {
}
}
}
#define BOOST_ASIO_DETAIL_WIN_IOCP_SERIAL_PORT_SERVICE_HPP
namespace boost {
namespace asio {
class serial_port_service
: public boost::asio::detail::service_base<serial_port_service>
{
public:
private:
typedef detail::reactive_serial_port_service service_impl_type;
public:
typedef service_impl_type::implementation_type implementation_type;
typedef service_impl_type::native_handle_type native_type;
typedef service_impl_type::native_handle_type native_handle_type;
explicit serial_port_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
serial_port_service& other_service,
implementation_type& other_impl)
;
void destroy(implementation_type& impl)
;
boost::system::error_code open(implementation_type& impl,
const std::string& device, boost::system::error_code& ec)
;
boost::system::error_code assign(implementation_type& impl,
const native_handle_type& handle, boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_type native(implementation_type& impl)
;
native_handle_type native_handle(implementation_type& impl)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
template <typename SettableSerialPortOption>
boost::system::error_code set_option(implementation_type& impl,
const SettableSerialPortOption& option, boost::system::error_code& ec)
;
template <typename GettableSerialPortOption>
boost::system::error_code get_option(const implementation_type& impl,
GettableSerialPortOption& option, boost::system::error_code& ec) const
;
boost::system::error_code send_break(implementation_type& impl,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t write_some(implementation_type& impl,
const ConstBufferSequence& buffers, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(implementation_type& impl,
const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t read_some(implementation_type& impl,
const MutableBufferSequence& buffers, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(implementation_type& impl,
const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename SerialPortService = serial_port_service>
class basic_serial_port
: public basic_io_object<SerialPortService>,
public serial_port_base
{
public:
typedef typename SerialPortService::native_handle_type native_type;
typedef typename SerialPortService::native_handle_type native_handle_type;
typedef basic_serial_port<SerialPortService> lowest_layer_type;
explicit basic_serial_port(boost::asio::io_service& io_service)
;
explicit basic_serial_port(boost::asio::io_service& io_service,
const char* device)
;
explicit basic_serial_port(boost::asio::io_service& io_service,
const std::string& device)
;
basic_serial_port(boost::asio::io_service& io_service,
const native_handle_type& native_serial_port)
;
basic_serial_port(basic_serial_port&& other)
;
basic_serial_port& operator=(basic_serial_port&& other)
;
lowest_layer_type& lowest_layer()
;
const lowest_layer_type& lowest_layer() const
;
void open(const std::string& device)
;
boost::system::error_code open(const std::string& device,
boost::system::error_code& ec)
;
void assign(const native_handle_type& native_serial_port)
;
boost::system::error_code assign(const native_handle_type& native_serial_port,
boost::system::error_code& ec)
;
bool is_open() const
;
void close()
;
boost::system::error_code close(boost::system::error_code& ec)
;
native_type native()
;
native_handle_type native_handle()
;
void cancel()
;
boost::system::error_code cancel(boost::system::error_code& ec)
;
void send_break()
;
boost::system::error_code send_break(boost::system::error_code& ec)
;
template <typename SettableSerialPortOption>
void set_option(const SettableSerialPortOption& option)
;
template <typename SettableSerialPortOption>
boost::system::error_code set_option(const SettableSerialPortOption& option,
boost::system::error_code& ec)
;
template <typename GettableSerialPortOption>
void get_option(GettableSerialPortOption& option)
;
template <typename GettableSerialPortOption>
boost::system::error_code get_option(GettableSerialPortOption& option,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
};
}
}
#define BOOST_ASIO_BASIC_SIGNAL_SET_HPP
#define BOOST_ASIO_SIGNAL_SET_SERVICE_HPP
#define BOOST_ASIO_DETAIL_SIGNAL_SET_SERVICE_HPP
#define _SIGNAL_H
extern "C" {
#define _SIGSET_H_fns 1
#define _EXTERN_INLINE __extern_inline
#define __sigmask(sig) (((unsigned long int) 1) << (((sig) - 1) % (8 * sizeof (unsigned long int))))
#define __sigword(sig) (((sig) - 1) / (8 * sizeof (unsigned long int)))
#define __sigemptyset(set) (__extension__ ({ int __cnt = _SIGSET_NWORDS; sigset_t *__set = (set); while (--__cnt >= 0) __set->__val[__cnt] = 0; 0; }))
#define __sigfillset(set) (__extension__ ({ int __cnt = _SIGSET_NWORDS; sigset_t *__set = (set); while (--__cnt >= 0) __set->__val[__cnt] = ~0UL; 0; }))
#define __sigisemptyset(set) (__extension__ ({ int __cnt = _SIGSET_NWORDS; const sigset_t *__set = (set); int __ret = __set->__val[--__cnt]; while (!__ret && --__cnt >= 0) __ret = __set->__val[__cnt]; __ret == 0; }))
#define __sigandset(dest,left,right) (__extension__ ({ int __cnt = _SIGSET_NWORDS; sigset_t *__dest = (dest); const sigset_t *__left = (left); const sigset_t *__right = (right); while (--__cnt >= 0) __dest->__val[__cnt] = (__left->__val[__cnt] & __right->__val[__cnt]); 0; }))
#define __sigorset(dest,left,right) (__extension__ ({ int __cnt = _SIGSET_NWORDS; sigset_t *__dest = (dest); const sigset_t *__left = (left); const sigset_t *__right = (right); while (--__cnt >= 0) __dest->__val[__cnt] = (__left->__val[__cnt] | __right->__val[__cnt]); 0; }))
extern int __sigismember (const __sigset_t *, int);
extern int __sigaddset (__sigset_t *, int);
extern int __sigdelset (__sigset_t *, int);
#define __sig_atomic_t_defined
typedef __sig_atomic_t sig_atomic_t;
#undef __need_sig_atomic_t
#undef __need_sigset_t
#define SIG_ERR ((__sighandler_t) -1)
#define SIG_DFL ((__sighandler_t) 0)
#define SIG_IGN ((__sighandler_t) 1)
#define SIG_HOLD ((__sighandler_t) 2)
#define SIGHUP 1
#define SIGINT 2
#define SIGQUIT 3
#define SIGILL 4
#define SIGTRAP 5
#define SIGABRT 6
#define SIGIOT 6
#define SIGBUS 7
#define SIGFPE 8
#define SIGKILL 9
#define SIGUSR1 10
#define SIGSEGV 11
#define SIGUSR2 12
#define SIGPIPE 13
#define SIGALRM 14
#define SIGTERM 15
#define SIGSTKFLT 16
#define SIGCLD SIGCHLD
#define SIGCHLD 17
#define SIGCONT 18
#define SIGSTOP 19
#define SIGTSTP 20
#define SIGTTIN 21
#define SIGTTOU 22
#define SIGURG 23
#define SIGXCPU 24
#define SIGXFSZ 25
#define SIGVTALRM 26
#define SIGPROF 27
#define SIGWINCH 28
#define SIGPOLL SIGIO
#define SIGIO 29
#define SIGPWR 30
#define SIGSYS 31
#define SIGUNUSED 31
#define _NSIG 65
#define SIGRTMIN (__libc_current_sigrtmin ())
#define SIGRTMAX (__libc_current_sigrtmax ())
#define __SIGRTMIN 32
#define __SIGRTMAX (_NSIG - 1)
#define __need_timespec
#define __WORDSIZE 64
#define __WORDSIZE_TIME64_COMPAT32 1
#define __SYSCALL_WORDSIZE 64
#define __have_siginfo_t 1
#define __SI_MAX_SIZE 128
#define __SI_PAD_SIZE ((__SI_MAX_SIZE / sizeof (int)) - 4)
typedef __clock_t __sigchld_clock_t;
#define __SI_ALIGNMENT
typedef struct
{
int si_signo;
int si_errno;
int si_code;
union
{
int _pad[((128 / sizeof (int)) - 4)];
struct
{
__pid_t si_pid;
__uid_t si_uid;
} _kill;
struct
{
int si_tid;
int si_overrun;
sigval_t si_sigval;
} _timer;
struct
{
__pid_t si_pid;
__uid_t si_uid;
sigval_t si_sigval;
} _rt;
struct
{
__pid_t si_pid;
__uid_t si_uid;
int si_status;
__sigchld_clock_t si_utime;
__sigchld_clock_t si_stime;
} _sigchld;
struct
{
void *si_addr;
short int si_addr_lsb;
} _sigfault;
struct
{
long int si_band;
int si_fd;
} _sigpoll;
struct
{
void *_call_addr;
int _syscall;
unsigned int _arch;
} _sigsys;
} _sifields;
} siginfo_t ;
#define si_pid _sifields._kill.si_pid
#define si_uid _sifields._kill.si_uid
#define si_timerid _sifields._timer.si_tid
#define si_overrun _sifields._timer.si_overrun
#define si_status _sifields._sigchld.si_status
#define si_utime _sifields._sigchld.si_utime
#define si_stime _sifields._sigchld.si_stime
#define si_value _sifields._rt.si_sigval
#define si_int _sifields._rt.si_sigval.sival_int
#define si_ptr _sifields._rt.si_sigval.sival_ptr
#define si_addr _sifields._sigfault.si_addr
#define si_addr_lsb _sifields._sigfault.si_addr_lsb
#define si_band _sifields._sigpoll.si_band
#define si_fd _sifields._sigpoll.si_fd
#define si_call_addr _sifields._sigsys._call_addr
#define si_syscall _sifields._sigsys._syscall
#define si_arch _sifields._sigsys._arch
enum
{
SI_ASYNCNL = -60,
#define SI_ASYNCNL SI_ASYNCNL
SI_TKILL = -6,
#define SI_TKILL SI_TKILL
SI_SIGIO,
#define SI_SIGIO SI_SIGIO
SI_ASYNCIO,
#define SI_ASYNCIO SI_ASYNCIO
SI_MESGQ,
#define SI_MESGQ SI_MESGQ
SI_TIMER,
#define SI_TIMER SI_TIMER
SI_QUEUE,
#define SI_QUEUE SI_QUEUE
SI_USER,
#define SI_USER SI_USER
SI_KERNEL = 0x80
#define SI_KERNEL SI_KERNEL
};
enum
{
ILL_ILLOPC = 1,
#define ILL_ILLOPC ILL_ILLOPC
ILL_ILLOPN,
#define ILL_ILLOPN ILL_ILLOPN
ILL_ILLADR,
#define ILL_ILLADR ILL_ILLADR
ILL_ILLTRP,
#define ILL_ILLTRP ILL_ILLTRP
ILL_PRVOPC,
#define ILL_PRVOPC ILL_PRVOPC
ILL_PRVREG,
#define ILL_PRVREG ILL_PRVREG
ILL_COPROC,
#define ILL_COPROC ILL_COPROC
ILL_BADSTK
#define ILL_BADSTK ILL_BADSTK
};
enum
{
FPE_INTDIV = 1,
#define FPE_INTDIV FPE_INTDIV
FPE_INTOVF,
#define FPE_INTOVF FPE_INTOVF
FPE_FLTDIV,
#define FPE_FLTDIV FPE_FLTDIV
FPE_FLTOVF,
#define FPE_FLTOVF FPE_FLTOVF
FPE_FLTUND,
#define FPE_FLTUND FPE_FLTUND
FPE_FLTRES,
#define FPE_FLTRES FPE_FLTRES
FPE_FLTINV,
#define FPE_FLTINV FPE_FLTINV
FPE_FLTSUB
#define FPE_FLTSUB FPE_FLTSUB
};
enum
{
SEGV_MAPERR = 1,
#define SEGV_MAPERR SEGV_MAPERR
SEGV_ACCERR
#define SEGV_ACCERR SEGV_ACCERR
};
enum
{
BUS_ADRALN = 1,
#define BUS_ADRALN BUS_ADRALN
BUS_ADRERR,
#define BUS_ADRERR BUS_ADRERR
BUS_OBJERR,
#define BUS_OBJERR BUS_OBJERR
BUS_MCEERR_AR,
#define BUS_MCEERR_AR BUS_MCEERR_AR
BUS_MCEERR_AO
#define BUS_MCEERR_AO BUS_MCEERR_AO
};
enum
{
TRAP_BRKPT = 1,
#define TRAP_BRKPT TRAP_BRKPT
TRAP_TRACE
#define TRAP_TRACE TRAP_TRACE
};
enum
{
CLD_EXITED = 1,
#define CLD_EXITED CLD_EXITED
CLD_KILLED,
#define CLD_KILLED CLD_KILLED
CLD_DUMPED,
#define CLD_DUMPED CLD_DUMPED
CLD_TRAPPED,
#define CLD_TRAPPED CLD_TRAPPED
CLD_STOPPED,
#define CLD_STOPPED CLD_STOPPED
CLD_CONTINUED
#define CLD_CONTINUED CLD_CONTINUED
};
enum
{
POLL_IN = 1,
#define POLL_IN POLL_IN
POLL_OUT,
#define POLL_OUT POLL_OUT
POLL_MSG,
#define POLL_MSG POLL_MSG
POLL_ERR,
#define POLL_ERR POLL_ERR
POLL_PRI,
#define POLL_PRI POLL_PRI
POLL_HUP
#define POLL_HUP POLL_HUP
};
#undef __need_siginfo_t
typedef void (*__sighandler_t) (int);
extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
throw ();
extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler)
throw ();
extern __sighandler_t signal (int __sig, __sighandler_t __handler)
throw ();
extern __sighandler_t bsd_signal (int __sig, __sighandler_t __handler)
throw ();
extern int kill (__pid_t __pid, int __sig) throw ();
extern int killpg (__pid_t __pgrp, int __sig) throw ();
extern int raise (int __sig) throw ();
extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
throw ();
extern int gsignal (int __sig) throw ();
extern void psignal (int __sig, const char *__s);
extern void psiginfo (const siginfo_t *__pinfo, const char *__s);
extern int __sigpause (int __sig_or_mask, int __is_sig);
extern int sigpause (int __sig) __asm__ ("__xpg_sigpause");
#define sigmask(sig) __sigmask(sig)
extern int sigblock (int __mask) throw () __attribute__ ((__deprecated__));
extern int sigsetmask (int __mask) throw () __attribute__ ((__deprecated__));
extern int siggetmask (void) throw () __attribute__ ((__deprecated__));
#define NSIG _NSIG
typedef __sighandler_t sighandler_t;
typedef __sighandler_t sig_t;
extern int sigemptyset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
extern int sigfillset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
extern int sigaddset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
extern int sigdelset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
extern int sigismember (const sigset_t *__set, int __signo)
throw () __attribute__ ((__nonnull__ (1)));
extern int sigisemptyset (const sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
extern int sigandset (sigset_t *__set, const sigset_t *__left,
const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
extern int sigorset (sigset_t *__set, const sigset_t *__left,
const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
struct sigaction
{
union
{
__sighandler_t sa_handler;
void (*sa_sigaction) (int, siginfo_t *, void *);
}
__sigaction_handler;
#define sa_handler __sigaction_handler.sa_handler
#define sa_sigaction __sigaction_handler.sa_sigaction
__sigset_t sa_mask;
int sa_flags;
void (*sa_restorer) (void);
};
#define SA_NOCLDSTOP 1
#define SA_NOCLDWAIT 2
#define SA_SIGINFO 4
#define SA_ONSTACK 0x08000000
#define SA_RESTART 0x10000000
#define SA_NODEFER 0x40000000
#define SA_RESETHAND 0x80000000
#define SA_INTERRUPT 0x20000000
#define SA_NOMASK SA_NODEFER
#define SA_ONESHOT SA_RESETHAND
#define SA_STACK SA_ONSTACK
#define SIG_BLOCK 0
#define SIG_UNBLOCK 1
#define SIG_SETMASK 2
extern int sigprocmask (int __how, const sigset_t *__restrict __set,
sigset_t *__restrict __oset) throw ();
extern int sigsuspend (const sigset_t *__set) __attribute__ ((__nonnull__ (1)));
extern int sigaction (int __sig, const struct sigaction *__restrict __act,
struct sigaction *__restrict __oact) throw ();
extern int sigpending (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
extern int sigwait (const sigset_t *__restrict __set, int *__restrict __sig)
__attribute__ ((__nonnull__ (1, 2)));
extern int sigwaitinfo (const sigset_t *__restrict __set,
siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1)));
extern int sigtimedwait (const sigset_t *__restrict __set,
siginfo_t *__restrict __info,
const struct timespec *__restrict __timeout)
__attribute__ ((__nonnull__ (1)));
extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val)
throw ();
extern const char *const _sys_siglist[65];
extern const char *const sys_siglist[65];
struct sigvec
{
__sighandler_t sv_handler;
int sv_mask;
int sv_flags;
#define sv_onstack sv_flags
};
#define SV_ONSTACK (1 << 0)
#define SV_INTERRUPT (1 << 1)
#define SV_RESETHAND (1 << 2)
extern int sigvec (int __sig, const struct sigvec *__vec,
struct sigvec *__ovec) throw ();
#define _BITS_SIGCONTEXT_H 1
#define FP_XSTATE_MAGIC1 0x46505853U
#define FP_XSTATE_MAGIC2 0x46505845U
#define FP_XSTATE_MAGIC2_SIZE sizeof(FP_XSTATE_MAGIC2)
struct _fpx_sw_bytes
{
__uint32_t magic1;
__uint32_t extended_size;
__uint64_t xstate_bv;
__uint32_t xstate_size;
__uint32_t padding[7];
};
struct _fpreg
{
unsigned short significand[4];
unsigned short exponent;
};
struct _fpxreg
{
unsigned short significand[4];
unsigned short exponent;
unsigned short padding[3];
};
struct _xmmreg
{
__uint32_t element[4];
};
struct _fpstate
{
__uint16_t cwd;
__uint16_t swd;
__uint16_t ftw;
__uint16_t fop;
__uint64_t rip;
__uint64_t rdp;
__uint32_t mxcsr;
__uint32_t mxcr_mask;
struct _fpxreg _st[8];
struct _xmmreg _xmm[16];
__uint32_t padding[24];
};
struct sigcontext
{
__uint64_t r8;
__uint64_t r9;
__uint64_t r10;
__uint64_t r11;
__uint64_t r12;
__uint64_t r13;
__uint64_t r14;
__uint64_t r15;
__uint64_t rdi;
__uint64_t rsi;
__uint64_t rbp;
__uint64_t rbx;
__uint64_t rdx;
__uint64_t rax;
__uint64_t rcx;
__uint64_t rsp;
__uint64_t rip;
__uint64_t eflags;
unsigned short cs;
unsigned short gs;
unsigned short fs;
unsigned short __pad0;
__uint64_t err;
__uint64_t trapno;
__uint64_t oldmask;
__uint64_t cr2;
__extension__ union
{
struct _fpstate * fpstate;
__uint64_t __fpstate_word;
};
__uint64_t __reserved1 [8];
};
struct _xsave_hdr
{
__uint64_t xstate_bv;
__uint64_t reserved1[2];
__uint64_t reserved2[5];
};
struct _ymmh_state
{
__uint32_t ymmh_space[64];
};
struct _xstate
{
struct _fpstate fpstate;
struct _xsave_hdr xstate_hdr;
struct _ymmh_state ymmh;
};
extern int sigreturn (struct sigcontext *__scp) throw ();
#define __need_size_t
#undef __need_ptrdiff_t
#undef __need_size_t
#undef __need_wchar_t
#undef NULL
#define NULL __null
#undef __need_NULL
#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
extern int siginterrupt (int __sig, int __interrupt) throw ();
struct sigstack
{
void *ss_sp;
int ss_onstack;
};
enum
{
SS_ONSTACK = 1,
#define SS_ONSTACK SS_ONSTACK
SS_DISABLE
#define SS_DISABLE SS_DISABLE
};
#define MINSIGSTKSZ 2048
#define SIGSTKSZ 8192
typedef struct sigaltstack
{
void *ss_sp;
int ss_flags;
size_t ss_size;
} stack_t;
#define _SYS_UCONTEXT_H 1
__extension__ typedef long long int greg_t;
#define NGREG 23
typedef greg_t gregset_t[23];
enum
{
REG_R8 = 0,
#define REG_R8 REG_R8
REG_R9,
#define REG_R9 REG_R9
REG_R10,
#define REG_R10 REG_R10
REG_R11,
#define REG_R11 REG_R11
REG_R12,
#define REG_R12 REG_R12
REG_R13,
#define REG_R13 REG_R13
REG_R14,
#define REG_R14 REG_R14
REG_R15,
#define REG_R15 REG_R15
REG_RDI,
#define REG_RDI REG_RDI
REG_RSI,
#define REG_RSI REG_RSI
REG_RBP,
#define REG_RBP REG_RBP
REG_RBX,
#define REG_RBX REG_RBX
REG_RDX,
#define REG_RDX REG_RDX
REG_RAX,
#define REG_RAX REG_RAX
REG_RCX,
#define REG_RCX REG_RCX
REG_RSP,
#define REG_RSP REG_RSP
REG_RIP,
#define REG_RIP REG_RIP
REG_EFL,
#define REG_EFL REG_EFL
REG_CSGSFS,
#define REG_CSGSFS REG_CSGSFS
REG_ERR,
#define REG_ERR REG_ERR
REG_TRAPNO,
#define REG_TRAPNO REG_TRAPNO
REG_OLDMASK,
#define REG_OLDMASK REG_OLDMASK
REG_CR2
#define REG_CR2 REG_CR2
};
struct _libc_fpxreg
{
unsigned short int significand[4];
unsigned short int exponent;
unsigned short int padding[3];
};
struct _libc_xmmreg
{
__uint32_t element[4];
};
struct _libc_fpstate
{
__uint16_t cwd;
__uint16_t swd;
__uint16_t ftw;
__uint16_t fop;
__uint64_t rip;
__uint64_t rdp;
__uint32_t mxcsr;
__uint32_t mxcr_mask;
struct _libc_fpxreg _st[8];
struct _libc_xmmreg _xmm[16];
__uint32_t padding[24];
};
typedef struct _libc_fpstate *fpregset_t;
typedef struct
{
gregset_t gregs;
fpregset_t fpregs;
__extension__ unsigned long long __reserved1 [8];
} mcontext_t;
typedef struct ucontext
{
unsigned long int uc_flags;
struct ucontext *uc_link;
stack_t uc_stack;
mcontext_t uc_mcontext;
__sigset_t uc_sigmask;
struct _libc_fpstate __fpregs_mem;
} ucontext_t;
extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
throw () __attribute__ ((__deprecated__));
extern int sigaltstack (const struct sigaltstack *__restrict __ss,
struct sigaltstack *__restrict __oss) throw ();
extern int sighold (int __sig) throw ();
extern int sigrelse (int __sig) throw ();
extern int sigignore (int __sig) throw ();
extern __sighandler_t sigset (int __sig, __sighandler_t __disp) throw ();
#define _BITS_SIGTHREAD_H 1
extern int pthread_sigmask (int __how,
const __sigset_t *__restrict __newmask,
__sigset_t *__restrict __oldmask)throw ();
extern int pthread_kill (pthread_t __threadid, int __signo) throw ();
extern int pthread_sigqueue (pthread_t __threadid, int __signo,
const union sigval __value) throw ();
extern int __libc_current_sigrtmin (void) throw ();
extern int __libc_current_sigrtmax (void) throw ();
}
#define BOOST_ASIO_DETAIL_SIGNAL_HANDLER_HPP
#define BOOST_ASIO_DETAIL_SIGNAL_OP_HPP
namespace boost {
namespace asio {
namespace detail {
class signal_op
: public operation
{
public:
boost::system::error_code ec_;
int signal_number_;
protected:
signal_op(func_type func)
;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Handler>
class signal_handler : public signal_op
{
public:
struct ptr { Handler* h; void* v; signal_handler* p; ~ptr() ; void reset() ; };
signal_handler(Handler& h)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
Handler handler_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
enum { max_signal_number = 65 };
extern inline struct signal_state* get_signal_state();
extern "C" inline void boost_asio_signal_handler(int signal_number);
class signal_set_service
{
public:
class registration
{
public:
registration()
;
private:
friend class signal_set_service;
int signal_number_;
op_queue<signal_op>* queue_;
std::size_t undelivered_;
registration* next_in_table_;
registration* prev_in_table_;
registration* next_in_set_;
};
class implementation_type
{
public:
implementation_type()
;
private:
friend class signal_set_service;
op_queue<signal_op> queue_;
registration* signals_;
};
inline signal_set_service(boost::asio::io_service& io_service);
inline ~signal_set_service();
inline void shutdown_service();
inline void fork_service(
boost::asio::io_service::fork_event fork_ev);
inline void construct(implementation_type& impl);
inline void destroy(implementation_type& impl);
inline boost::system::error_code add(implementation_type& impl,
int signal_number, boost::system::error_code& ec);
inline boost::system::error_code remove(implementation_type& impl,
int signal_number, boost::system::error_code& ec);
inline boost::system::error_code clear(implementation_type& impl,
boost::system::error_code& ec);
inline boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec);
template <typename Handler>
void async_wait(implementation_type& impl, Handler& handler)
;
inline static void deliver_signal(int signal_number);
private:
inline static void add_service(signal_set_service* service);
inline static void remove_service(signal_set_service* service);
inline static void open_descriptors();
inline static void close_descriptors();
inline void start_wait_op(implementation_type& impl, signal_op* op);
io_service_impl& io_service_;
class pipe_read_op;
reactor& reactor_;
reactor::per_descriptor_data reactor_data_;
registration* registrations_[max_signal_number];
signal_set_service* next_;
signal_set_service* prev_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_SIGNAL_SET_SERVICE_IPP
#define BOOST_ASIO_DETAIL_SIGNAL_BLOCKER_HPP
#define BOOST_ASIO_DETAIL_POSIX_SIGNAL_BLOCKER_HPP
#define _GLIBCXX_CSIGNAL 1
#undef raise
namespace std
{
using ::sig_atomic_t;
using ::signal;
using ::raise;
}
namespace boost {
namespace asio {
namespace detail {
class posix_signal_blocker
: private noncopyable
{
public:
posix_signal_blocker()
;
~posix_signal_blocker()
;
void block()
;
void unblock()
;
private:
bool blocked_;
sigset_t old_mask_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
typedef posix_signal_blocker signal_blocker;
}
}
}
#define BOOST_ASIO_DETAIL_STATIC_MUTEX_HPP
#define BOOST_ASIO_DETAIL_POSIX_STATIC_MUTEX_HPP
namespace boost {
namespace asio {
namespace detail {
struct posix_static_mutex
{
typedef boost::asio::detail::scoped_lock<posix_static_mutex> scoped_lock;
void init()
;
void lock()
;
void unlock()
;
::pthread_mutex_t mutex_;
};
#define BOOST_ASIO_POSIX_STATIC_MUTEX_INIT { PTHREAD_MUTEX_INITIALIZER }
}
}
}
namespace boost {
namespace asio {
namespace detail {
typedef posix_static_mutex static_mutex;
#define BOOST_ASIO_STATIC_MUTEX_INIT BOOST_ASIO_POSIX_STATIC_MUTEX_INIT
}
}
}
namespace boost {
namespace asio {
namespace detail {
struct signal_state
{
static_mutex mutex_;
int read_descriptor_;
int write_descriptor_;
bool fork_prepared_;
class signal_set_service* service_list_;
std::size_t registration_count_[max_signal_number];
};
signal_state* get_signal_state()
;
void boost_asio_signal_handler(int signal_number)
;
class signal_set_service::pipe_read_op : public reactor_op
{
public:
pipe_read_op()
;
static bool do_perform(reactor_op*)
;
static void do_complete(io_service_impl* , operation* base,
const boost::system::error_code& ,
std::size_t )
;
};
}
}
}
namespace boost {
namespace asio {
class signal_set_service
: public boost::asio::detail::service_base<signal_set_service>
{
public:
public:
typedef detail::signal_set_service::implementation_type implementation_type;
explicit signal_set_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void destroy(implementation_type& impl)
;
boost::system::error_code add(implementation_type& impl,
int signal_number, boost::system::error_code& ec)
;
boost::system::error_code remove(implementation_type& impl,
int signal_number, boost::system::error_code& ec)
;
boost::system::error_code clear(implementation_type& impl,
boost::system::error_code& ec)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
template <typename SignalHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<SignalHandler, void (boost::system::error_code, int)>::type>::type
async_wait(implementation_type& impl,
SignalHandler&& handler)
;
private:
void shutdown_service()
;
void fork_service(boost::asio::io_service::fork_event event)
;
detail::signal_set_service service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename SignalSetService = signal_set_service>
class basic_signal_set
: public basic_io_object<SignalSetService>
{
public:
explicit basic_signal_set(boost::asio::io_service& io_service)
;
basic_signal_set(boost::asio::io_service& io_service, int signal_number_1)
;
basic_signal_set(boost::asio::io_service& io_service, int signal_number_1,
int signal_number_2)
;
basic_signal_set(boost::asio::io_service& io_service, int signal_number_1,
int signal_number_2, int signal_number_3)
;
void add(int signal_number)
;
boost::system::error_code add(int signal_number,
boost::system::error_code& ec)
;
void remove(int signal_number)
;
boost::system::error_code remove(int signal_number,
boost::system::error_code& ec)
;
void clear()
;
boost::system::error_code clear(boost::system::error_code& ec)
;
void cancel()
;
boost::system::error_code cancel(boost::system::error_code& ec)
;
template <typename SignalHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<SignalHandler, void (boost::system::error_code, int)>::type>::type
async_wait(SignalHandler&& handler)
;
};
}
}
#define BOOST_ASIO_BASIC_SOCKET_ACCEPTOR_HPP
#define BOOST_ASIO_SOCKET_ACCEPTOR_SERVICE_HPP
namespace boost {
namespace asio {
template <typename Protocol>
class socket_acceptor_service
: public boost::asio::detail::service_base<socket_acceptor_service<Protocol> >
{
public:
typedef Protocol protocol_type;
typedef typename protocol_type::endpoint endpoint_type;
private:
typedef detail::reactive_socket_service<Protocol> service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
typedef typename service_impl_type::native_handle_type native_type;
typedef typename service_impl_type::native_handle_type native_handle_type;
explicit socket_acceptor_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
socket_acceptor_service& other_service,
implementation_type& other_impl)
;
template <typename Protocol1>
void converting_move_construct(implementation_type& impl,
typename socket_acceptor_service<
Protocol1>::implementation_type& other_impl,
typename enable_if<is_convertible<
Protocol1, Protocol>::value>::type* = 0)
;
void destroy(implementation_type& impl)
;
boost::system::error_code open(implementation_type& impl,
const protocol_type& protocol, boost::system::error_code& ec)
;
boost::system::error_code assign(implementation_type& impl,
const protocol_type& protocol, const native_handle_type& native_acceptor,
boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
boost::system::error_code bind(implementation_type& impl,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
boost::system::error_code listen(implementation_type& impl, int backlog,
boost::system::error_code& ec)
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_type native(implementation_type& impl)
;
native_handle_type native_handle(implementation_type& impl)
;
template <typename SettableSocketOption>
boost::system::error_code set_option(implementation_type& impl,
const SettableSocketOption& option, boost::system::error_code& ec)
;
template <typename GettableSocketOption>
boost::system::error_code get_option(const implementation_type& impl,
GettableSocketOption& option, boost::system::error_code& ec) const
;
template <typename IoControlCommand>
boost::system::error_code io_control(implementation_type& impl,
IoControlCommand& command, boost::system::error_code& ec)
;
bool non_blocking(const implementation_type& impl) const
;
boost::system::error_code non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const implementation_type& impl) const
;
boost::system::error_code native_non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
endpoint_type local_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
template <typename Protocol1, typename SocketService>
boost::system::error_code accept(implementation_type& impl,
basic_socket<Protocol1, SocketService>& peer,
endpoint_type* peer_endpoint, boost::system::error_code& ec,
typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
;
template <typename Protocol1, typename SocketService, typename AcceptHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<AcceptHandler, void (boost::system::error_code)>::type>::type
async_accept(implementation_type& impl,
basic_socket<Protocol1, SocketService>& peer,
endpoint_type* peer_endpoint,
AcceptHandler&& handler,
typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename Protocol,
typename SocketAcceptorService = socket_acceptor_service<Protocol> >
class basic_socket_acceptor
: public basic_io_object<SocketAcceptorService>,
public socket_base
{
public:
typedef typename SocketAcceptorService::native_handle_type native_type;
typedef typename SocketAcceptorService::native_handle_type native_handle_type;
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
explicit basic_socket_acceptor(boost::asio::io_service& io_service)
;
basic_socket_acceptor(boost::asio::io_service& io_service,
const protocol_type& protocol)
;
basic_socket_acceptor(boost::asio::io_service& io_service,
const endpoint_type& endpoint, bool reuse_addr = true)
;
basic_socket_acceptor(boost::asio::io_service& io_service,
const protocol_type& protocol, const native_handle_type& native_acceptor)
;
basic_socket_acceptor(basic_socket_acceptor&& other)
;
basic_socket_acceptor& operator=(basic_socket_acceptor&& other)
;
template <typename Protocol1, typename SocketAcceptorService1>
friend class basic_socket_acceptor;
template <typename Protocol1, typename SocketAcceptorService1>
basic_socket_acceptor(
basic_socket_acceptor<Protocol1, SocketAcceptorService1>&& other,
typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
;
template <typename Protocol1, typename SocketAcceptorService1>
typename enable_if<is_convertible<Protocol1, Protocol>::value,
basic_socket_acceptor>::type& operator=(
basic_socket_acceptor<Protocol1, SocketAcceptorService1>&& other)
;
void open(const protocol_type& protocol = protocol_type())
;
boost::system::error_code open(const protocol_type& protocol,
boost::system::error_code& ec)
;
void assign(const protocol_type& protocol,
const native_handle_type& native_acceptor)
;
boost::system::error_code assign(const protocol_type& protocol,
const native_handle_type& native_acceptor, boost::system::error_code& ec)
;
bool is_open() const
;
void bind(const endpoint_type& endpoint)
;
boost::system::error_code bind(const endpoint_type& endpoint,
boost::system::error_code& ec)
;
void listen(int backlog = socket_base::max_connections)
;
boost::system::error_code listen(int backlog, boost::system::error_code& ec)
;
void close()
;
boost::system::error_code close(boost::system::error_code& ec)
;
native_type native()
;
native_handle_type native_handle()
;
void cancel()
;
boost::system::error_code cancel(boost::system::error_code& ec)
;
template <typename SettableSocketOption>
void set_option(const SettableSocketOption& option)
;
template <typename SettableSocketOption>
boost::system::error_code set_option(const SettableSocketOption& option,
boost::system::error_code& ec)
;
template <typename GettableSocketOption>
void get_option(GettableSocketOption& option)
;
template <typename GettableSocketOption>
boost::system::error_code get_option(GettableSocketOption& option,
boost::system::error_code& ec)
;
template <typename IoControlCommand>
void io_control(IoControlCommand& command)
;
template <typename IoControlCommand>
boost::system::error_code io_control(IoControlCommand& command,
boost::system::error_code& ec)
;
bool non_blocking() const
;
void non_blocking(bool mode)
;
boost::system::error_code non_blocking(
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking() const
;
void native_non_blocking(bool mode)
;
boost::system::error_code native_non_blocking(
bool mode, boost::system::error_code& ec)
;
endpoint_type local_endpoint() const
;
endpoint_type local_endpoint(boost::system::error_code& ec) const
;
template <typename Protocol1, typename SocketService>
void accept(basic_socket<Protocol1, SocketService>& peer,
typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
;
template <typename Protocol1, typename SocketService>
boost::system::error_code accept(
basic_socket<Protocol1, SocketService>& peer,
boost::system::error_code& ec,
typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
;
template <typename Protocol1, typename SocketService, typename AcceptHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<AcceptHandler, void (boost::system::error_code)>::type>::type
async_accept(basic_socket<Protocol1, SocketService>& peer,
AcceptHandler&& handler,
typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
;
template <typename SocketService>
void accept(basic_socket<protocol_type, SocketService>& peer,
endpoint_type& peer_endpoint)
;
template <typename SocketService>
boost::system::error_code accept(
basic_socket<protocol_type, SocketService>& peer,
endpoint_type& peer_endpoint, boost::system::error_code& ec)
;
template <typename SocketService, typename AcceptHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<AcceptHandler, void (boost::system::error_code)>::type>::type
async_accept(basic_socket<protocol_type, SocketService>& peer,
endpoint_type& peer_endpoint, AcceptHandler&& handler)
;
};
}
}
#define BOOST_ASIO_BASIC_SOCKET_IOSTREAM_HPP
#define BOOST_ASIO_BASIC_SOCKET_STREAMBUF_HPP
#define BOOST_ASIO_DETAIL_ARRAY_HPP
namespace boost {
namespace asio {
namespace detail {
using std::array;
}
}
}
#define BOOST_ASIO_STREAM_SOCKET_SERVICE_HPP
namespace boost {
namespace asio {
template <typename Protocol>
class stream_socket_service
: public boost::asio::detail::service_base<stream_socket_service<Protocol> >
{
public:
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
private:
typedef detail::reactive_socket_service<Protocol> service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
typedef typename service_impl_type::native_handle_type native_type;
typedef typename service_impl_type::native_handle_type native_handle_type;
explicit stream_socket_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
stream_socket_service& other_service,
implementation_type& other_impl)
;
template <typename Protocol1>
void converting_move_construct(implementation_type& impl,
typename stream_socket_service<
Protocol1>::implementation_type& other_impl,
typename enable_if<is_convertible<
Protocol1, Protocol>::value>::type* = 0)
;
void destroy(implementation_type& impl)
;
boost::system::error_code open(implementation_type& impl,
const protocol_type& protocol, boost::system::error_code& ec)
;
boost::system::error_code assign(implementation_type& impl,
const protocol_type& protocol, const native_handle_type& native_socket,
boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_type native(implementation_type& impl)
;
native_handle_type native_handle(implementation_type& impl)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
bool at_mark(const implementation_type& impl,
boost::system::error_code& ec) const
;
std::size_t available(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code bind(implementation_type& impl,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
boost::system::error_code connect(implementation_type& impl,
const endpoint_type& peer_endpoint, boost::system::error_code& ec)
;
template <typename ConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ConnectHandler, void (boost::system::error_code)>::type>::type
async_connect(implementation_type& impl,
const endpoint_type& peer_endpoint,
ConnectHandler&& handler)
;
template <typename SettableSocketOption>
boost::system::error_code set_option(implementation_type& impl,
const SettableSocketOption& option, boost::system::error_code& ec)
;
template <typename GettableSocketOption>
boost::system::error_code get_option(const implementation_type& impl,
GettableSocketOption& option, boost::system::error_code& ec) const
;
template <typename IoControlCommand>
boost::system::error_code io_control(implementation_type& impl,
IoControlCommand& command, boost::system::error_code& ec)
;
bool non_blocking(const implementation_type& impl) const
;
boost::system::error_code non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const implementation_type& impl) const
;
boost::system::error_code native_non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
endpoint_type local_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
endpoint_type remote_endpoint(const implementation_type& impl,
boost::system::error_code& ec) const
;
boost::system::error_code shutdown(implementation_type& impl,
socket_base::shutdown_type what, boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t send(implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(implementation_type& impl,
const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(implementation_type& impl,
const MutableBufferSequence& buffers,
socket_base::message_flags flags,
ReadHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
#define BOOST_ASIO_DEADLINE_TIMER_HPP
namespace boost {
namespace asio {
typedef basic_deadline_timer<boost::posix_time::ptime> deadline_timer;
}
}
namespace boost {
namespace asio {
namespace detail {
class socket_streambuf_base
{
protected:
io_service io_service_;
};
}
template <typename Protocol,
typename StreamSocketService = stream_socket_service<Protocol>,
typename Time = boost::posix_time::ptime,
typename TimeTraits = boost::asio::time_traits<Time>,
typename TimerService = deadline_timer_service<Time, TimeTraits> >
class basic_socket_streambuf
: public std::streambuf,
private detail::socket_streambuf_base,
public basic_socket<Protocol, StreamSocketService>
{
private:
typedef TimeTraits traits_helper;
public:
typedef typename Protocol::endpoint endpoint_type;
typedef typename traits_helper::time_type time_type;
typedef typename traits_helper::duration_type duration_type;
basic_socket_streambuf()
;
virtual ~basic_socket_streambuf()
;
basic_socket_streambuf<Protocol, StreamSocketService,
Time, TimeTraits, TimerService>* connect(
const endpoint_type& endpoint)
;
template <typename... T>
basic_socket_streambuf<Protocol, StreamSocketService,
Time, TimeTraits, TimerService>* connect(T... x)
;
basic_socket_streambuf<Protocol, StreamSocketService,
Time, TimeTraits, TimerService>* close()
;
const boost::system::error_code& puberror() const
;
time_type expires_at() const
;
void expires_at(const time_type& expiry_time)
;
duration_type expires_from_now() const
;
void expires_from_now(const duration_type& expiry_time)
;
protected:
int_type underflow()
;
int_type overflow(int_type c)
;
int sync()
;
std::streambuf* setbuf(char_type* s, std::streamsize n)
;
virtual const boost::system::error_code& error() const
;
private:
void init_buffers()
;
template <typename ResolverQuery>
void resolve_and_connect(const ResolverQuery& query)
;
struct io_handler;
friend struct io_handler;
struct io_handler
{
basic_socket_streambuf* this_;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred = 0)
;
};
struct timer_handler;
friend struct timer_handler;
struct timer_handler
{
basic_socket_streambuf* this_;
void operator()(const boost::system::error_code&)
;
};
void construct_timer()
;
void destroy_timer()
;
void start_timer()
;
enum { putback_max = 8 };
enum { buffer_size = 512 };
boost::asio::detail::array<char, buffer_size> get_buffer_;
boost::asio::detail::array<char, buffer_size> put_buffer_;
bool unbuffered_;
boost::system::error_code ec_;
std::size_t bytes_transferred_;
TimerService* timer_service_;
typename TimerService::implementation_type timer_implementation_;
enum state { no_timer, timer_is_pending, timer_has_expired } timer_state_;
};
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Protocol, typename StreamSocketService,
typename Time, typename TimeTraits, typename TimerService>
class socket_iostream_base
{
protected:
basic_socket_streambuf<Protocol, StreamSocketService,
Time, TimeTraits, TimerService> streambuf_;
};
}
template <typename Protocol,
typename StreamSocketService = stream_socket_service<Protocol>,
typename Time = boost::posix_time::ptime,
typename TimeTraits = boost::asio::time_traits<Time>,
typename TimerService = deadline_timer_service<Time, TimeTraits> >
class basic_socket_iostream
: private detail::socket_iostream_base<Protocol,
StreamSocketService, Time, TimeTraits, TimerService>,
public std::basic_iostream<char>
{
private:
typedef TimeTraits traits_helper;
public:
typedef typename Protocol::endpoint endpoint_type;
typedef typename traits_helper::time_type time_type;
typedef typename traits_helper::duration_type duration_type;
basic_socket_iostream()
;
template <typename... T>
explicit basic_socket_iostream(T... x)
;
template <typename... T>
void connect(T... x)
;
void close()
;
basic_socket_streambuf<Protocol, StreamSocketService,
Time, TimeTraits, TimerService>* rdbuf() const
;
const boost::system::error_code& error() const
;
time_type expires_at() const
;
void expires_at(const time_type& expiry_time)
;
duration_type expires_from_now() const
;
void expires_from_now(const duration_type& expiry_time)
;
};
}
}
#define BOOST_ASIO_BASIC_STREAM_SOCKET_HPP
namespace boost {
namespace asio {
template <typename Protocol,
typename StreamSocketService = stream_socket_service<Protocol> >
class basic_stream_socket
: public basic_socket<Protocol, StreamSocketService>
{
public:
typedef typename StreamSocketService::native_handle_type native_type;
typedef typename StreamSocketService::native_handle_type native_handle_type;
typedef Protocol protocol_type;
typedef typename Protocol::endpoint endpoint_type;
explicit basic_stream_socket(boost::asio::io_service& io_service)
;
basic_stream_socket(boost::asio::io_service& io_service,
const protocol_type& protocol)
;
basic_stream_socket(boost::asio::io_service& io_service,
const endpoint_type& endpoint)
;
basic_stream_socket(boost::asio::io_service& io_service,
const protocol_type& protocol, const native_handle_type& native_socket)
;
basic_stream_socket(basic_stream_socket&& other)
;
basic_stream_socket& operator=(basic_stream_socket&& other)
;
template <typename Protocol1, typename StreamSocketService1>
basic_stream_socket(
basic_stream_socket<Protocol1, StreamSocketService1>&& other,
typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
;
template <typename Protocol1, typename StreamSocketService1>
typename enable_if<is_convertible<Protocol1, Protocol>::value,
basic_stream_socket>::type& operator=(
basic_stream_socket<Protocol1, StreamSocketService1>&& other)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags)
;
template <typename ConstBufferSequence>
std::size_t send(const ConstBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_send(const ConstBufferSequence& buffers,
socket_base::message_flags flags,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags)
;
template <typename MutableBufferSequence>
std::size_t receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_receive(const MutableBufferSequence& buffers,
socket_base::message_flags flags,
ReadHandler&& handler)
{
typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
return this->get_service().async_receive(this->get_implementation(),
buffers, flags, static_cast<ReadHandler&&>(handler));
}
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers)
{
boost::system::error_code ec;
std::size_t s = this->get_service().send(
this->get_implementation(), buffers, 0, ec);
boost::asio::detail::throw_error(ec, "write_some");
return s;
}
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers,
boost::system::error_code& ec)
{
return this->get_service().send(this->get_implementation(), buffers, 0, ec);
}
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(const ConstBufferSequence& buffers,
WriteHandler&& handler)
{
typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
return this->get_service().async_send(this->get_implementation(),
buffers, 0, static_cast<WriteHandler&&>(handler));
}
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers)
{
boost::system::error_code ec;
std::size_t s = this->get_service().receive(
this->get_implementation(), buffers, 0, ec);
boost::asio::detail::throw_error(ec, "read_some");
return s;
}
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers,
boost::system::error_code& ec)
{
return this->get_service().receive(
this->get_implementation(), buffers, 0, ec);
}
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(const MutableBufferSequence& buffers,
ReadHandler&& handler)
{
typedef typename handler_type<ReadHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
return this->get_service().async_receive(this->get_implementation(),
buffers, 0, static_cast<ReadHandler&&>(handler));
}
};
}
}
#define BOOST_ASIO_BASIC_STREAMBUF_HPP
#define BOOST_ASIO_BASIC_STREAMBUF_FWD_HPP
namespace boost {
namespace asio {
template <typename Allocator = std::allocator<char> >
class basic_streambuf;
}
}
namespace boost {
namespace asio {
template <typename Allocator>
class basic_streambuf
: public std::streambuf,
private noncopyable
{
public:
typedef boost::asio::const_buffers_1 const_buffers_type;
typedef boost::asio::mutable_buffers_1 mutable_buffers_type;
explicit basic_streambuf(
std::size_t maximum_size = (std::numeric_limits<std::size_t>::max)(),
const Allocator& allocator = Allocator())
: max_size_(maximum_size),
buffer_(allocator)
{
std::size_t pend = (std::min<std::size_t>)(max_size_, buffer_delta);
buffer_.resize((std::max<std::size_t>)(pend, 1));
setg(&buffer_[0], &buffer_[0], &buffer_[0]);
setp(&buffer_[0], &buffer_[0] + pend);
}
std::size_t size() const
{
return pptr() - gptr();
}
std::size_t max_size() const
{
return max_size_;
}
const_buffers_type data() const
;
mutable_buffers_type prepare(std::size_t n)
;
void commit(std::size_t n)
;
void consume(std::size_t n)
;
protected:
enum { buffer_delta = 128 };
int_type underflow()
;
int_type overflow(int_type c)
;
void reserve(std::size_t n)
;
private:
std::size_t max_size_;
std::vector<char_type, Allocator> buffer_;
friend std::size_t read_size_helper(
basic_streambuf& sb, std::size_t max_size)
;
};
template <typename Allocator>
std::size_t read_size_helper(
basic_streambuf<Allocator>& sb, std::size_t max_size)
;
}
}
#define BOOST_ASIO_BASIC_WAITABLE_TIMER_HPP
#define BOOST_ASIO_WAIT_TRAITS_HPP
namespace boost {
namespace asio {
template <typename Clock>
struct wait_traits
{
static typename Clock::duration to_wait_duration(
const typename Clock::duration& d)
;
};
}
}
#define BOOST_ASIO_WAITABLE_TIMER_SERVICE_HPP
#define BOOST_ASIO_DETAIL_CHRONO_TIME_TRAITS_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Clock, typename WaitTraits>
struct chrono_time_traits
{
typedef Clock clock_type;
typedef typename clock_type::duration duration_type;
typedef typename clock_type::time_point time_type;
typedef typename duration_type::period period_type;
static time_type now()
;
static time_type add(const time_type& t, const duration_type& d)
;
static duration_type subtract(const time_type& t1, const time_type& t2)
;
static bool less_than(const time_type& t1, const time_type& t2)
;
class posix_time_duration
{
public:
explicit posix_time_duration(const duration_type& d)
;
int64_t ticks() const
;
int64_t total_seconds() const
;
int64_t total_milliseconds() const
;
int64_t total_microseconds() const
;
private:
template <int64_t Num, int64_t Den>
int64_t duration_cast() const
;
duration_type d_;
};
static posix_time_duration to_posix_duration(const duration_type& d)
;
};
}
}
}
namespace boost {
namespace asio {
template <typename Clock,
typename WaitTraits = boost::asio::wait_traits<Clock> >
class waitable_timer_service
: public boost::asio::detail::service_base<
waitable_timer_service<Clock, WaitTraits> >
{
public:
typedef Clock clock_type;
typedef typename clock_type::duration duration;
typedef typename clock_type::time_point time_point;
typedef WaitTraits traits_type;
private:
typedef detail::deadline_timer_service<
detail::chrono_time_traits<Clock, WaitTraits> > service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
explicit waitable_timer_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void destroy(implementation_type& impl)
;
std::size_t cancel(implementation_type& impl, boost::system::error_code& ec)
;
std::size_t cancel_one(implementation_type& impl,
boost::system::error_code& ec)
;
time_point expires_at(const implementation_type& impl) const
;
std::size_t expires_at(implementation_type& impl,
const time_point& expiry_time, boost::system::error_code& ec)
;
duration expires_from_now(const implementation_type& impl) const
;
std::size_t expires_from_now(implementation_type& impl,
const duration& expiry_time, boost::system::error_code& ec)
;
void wait(implementation_type& impl, boost::system::error_code& ec)
;
template <typename WaitHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WaitHandler, void (boost::system::error_code)>::type>::type
async_wait(implementation_type& impl,
WaitHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
namespace boost {
namespace asio {
template <typename Clock,
typename WaitTraits = boost::asio::wait_traits<Clock>,
typename WaitableTimerService = waitable_timer_service<Clock, WaitTraits> >
class basic_waitable_timer
: public basic_io_object<WaitableTimerService>
{
public:
typedef Clock clock_type;
typedef typename clock_type::duration duration;
typedef typename clock_type::time_point time_point;
typedef WaitTraits traits_type;
explicit basic_waitable_timer(boost::asio::io_service& io_service)
;
basic_waitable_timer(boost::asio::io_service& io_service,
const time_point& expiry_time)
;
basic_waitable_timer(boost::asio::io_service& io_service,
const duration& expiry_time)
;
std::size_t cancel()
;
std::size_t cancel(boost::system::error_code& ec)
;
std::size_t cancel_one()
;
std::size_t cancel_one(boost::system::error_code& ec)
;
time_point expires_at() const
;
std::size_t expires_at(const time_point& expiry_time)
;
std::size_t expires_at(const time_point& expiry_time,
boost::system::error_code& ec)
;
duration expires_from_now() const
;
std::size_t expires_from_now(const duration& expiry_time)
;
std::size_t expires_from_now(const duration& expiry_time,
boost::system::error_code& ec)
{
return this->service.expires_from_now(
this->implementation, expiry_time, ec);
}
void wait()
{
boost::system::error_code ec;
this->service.wait(this->implementation, ec);
boost::asio::detail::throw_error(ec, "wait");
}
void wait(boost::system::error_code& ec)
{
this->service.wait(this->implementation, ec);
}
template <typename WaitHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WaitHandler, void (boost::system::error_code)>::type>::type
async_wait(WaitHandler&& handler)
{
typedef typename handler_type<WaitHandler, void(boost::system::error_code)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "WaitHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> __attribute__((__unused__)) type_check;
return this->service.async_wait(this->implementation,
static_cast<WaitHandler&&>(handler));
}
};
}
}
#define BOOST_ASIO_BUFFERED_READ_STREAM_FWD_HPP
namespace boost {
namespace asio {
template <typename Stream>
class buffered_read_stream;
}
}
#define BOOST_ASIO_BUFFERED_READ_STREAM_HPP
#define BOOST_ASIO_DETAIL_BUFFER_RESIZE_GUARD_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Buffer>
class buffer_resize_guard
{
public:
buffer_resize_guard(Buffer& buffer)
: buffer_(buffer),
old_size_(buffer.size())
{
}
~buffer_resize_guard()
{
if (old_size_ != (std::numeric_limits<size_t>::max)())
{
buffer_.resize(old_size_);
}
}
void commit()
{
old_size_ = (std::numeric_limits<size_t>::max)();
}
private:
Buffer& buffer_;
size_t old_size_;
};
}
}
}
#define BOOST_ASIO_DETAIL_BUFFERED_STREAM_STORAGE_HPP
namespace boost {
namespace asio {
namespace detail {
class buffered_stream_storage
{
public:
typedef unsigned char byte_type;
typedef std::size_t size_type;
explicit buffered_stream_storage(std::size_t buffer_capacity)
: begin_offset_(0),
end_offset_(0),
buffer_(buffer_capacity)
{
}
void clear()
{
begin_offset_ = 0;
end_offset_ = 0;
}
mutable_buffer data()
{
return boost::asio::buffer(buffer_) + begin_offset_;
}
const_buffer data() const
{
return boost::asio::buffer(buffer_) + begin_offset_;
}
bool empty() const
{
return begin_offset_ == end_offset_;
}
size_type size() const
{
return end_offset_ - begin_offset_;
}
void resize(size_type length)
{
(static_cast<void> (0));
if (begin_offset_ + length <= capacity())
{
end_offset_ = begin_offset_ + length;
}
else
{
using namespace std;
memmove(&buffer_[0], &buffer_[0] + begin_offset_, size());
end_offset_ = length;
begin_offset_ = 0;
}
}
size_type capacity() const
{
return buffer_.size();
}
void consume(size_type count)
{
(static_cast<void> (0));
begin_offset_ += count;
if (empty())
clear();
}
private:
size_type begin_offset_;
size_type end_offset_;
std::vector<byte_type> buffer_;
};
}
}
}
namespace boost {
namespace asio {
template <typename Stream>
class buffered_read_stream
: private noncopyable
{
public:
typedef typename remove_reference<Stream>::type next_layer_type;
typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
static const std::size_t default_buffer_size = 1024;
template <typename Arg>
explicit buffered_read_stream(Arg& a)
: next_layer_(a),
storage_(default_buffer_size)
{
}
template <typename Arg>
buffered_read_stream(Arg& a, std::size_t buffer_size)
: next_layer_(a),
storage_(buffer_size)
{
}
next_layer_type& next_layer()
{
return next_layer_;
}
lowest_layer_type& lowest_layer()
{
return next_layer_.lowest_layer();
}
const lowest_layer_type& lowest_layer() const
{
return next_layer_.lowest_layer();
}
boost::asio::io_service& get_io_service()
{
return next_layer_.get_io_service();
}
void close()
{
next_layer_.close();
}
boost::system::error_code close(boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
std::size_t fill();
std::size_t fill(boost::system::error_code& ec);
template <typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_fill(ReadHandler&& handler);
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers);
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers,
boost::system::error_code& ec);
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(const MutableBufferSequence& buffers,
ReadHandler&& handler);
template <typename MutableBufferSequence>
std::size_t peek(const MutableBufferSequence& buffers);
template <typename MutableBufferSequence>
std::size_t peek(const MutableBufferSequence& buffers,
boost::system::error_code& ec);
std::size_t in_avail()
;
std::size_t in_avail(boost::system::error_code& ec)
;
private:
template <typename MutableBufferSequence>
std::size_t copy(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t peek_copy(const MutableBufferSequence& buffers)
;
Stream next_layer_;
detail::buffered_stream_storage storage_;
};
}
}
#define BOOST_ASIO_IMPL_BUFFERED_READ_STREAM_HPP
namespace boost {
namespace asio {
namespace detail
{
template <typename ReadHandler>
class buffered_fill_handler
{
public:
buffered_fill_handler(detail::buffered_stream_storage& storage,
std::size_t previous_size, ReadHandler& handler)
;
buffered_fill_handler(const buffered_fill_handler& other)
;
buffered_fill_handler(buffered_fill_handler&& other)
;
void operator()(const boost::system::error_code& ec,
const std::size_t bytes_transferred)
;
detail::buffered_stream_storage& storage_;
std::size_t previous_size_;
ReadHandler handler_;
};
template <typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
buffered_fill_handler<ReadHandler>* this_handler)
;
template <typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
buffered_fill_handler<ReadHandler>* this_handler)
;
template <typename ReadHandler>
bool asio_handler_is_continuation(
buffered_fill_handler<ReadHandler>* this_handler)
;
template <typename Function, typename ReadHandler>
void asio_handler_invoke(Function& function,
buffered_fill_handler<ReadHandler>* this_handler)
;
template <typename Function, typename ReadHandler>
void asio_handler_invoke(const Function& function,
buffered_fill_handler<ReadHandler>* this_handler)
;
}
namespace detail
{
template <typename MutableBufferSequence, typename ReadHandler>
class buffered_read_some_handler
{
public:
buffered_read_some_handler(detail::buffered_stream_storage& storage,
const MutableBufferSequence& buffers, ReadHandler& handler)
;
buffered_read_some_handler(const buffered_read_some_handler& other)
;
buffered_read_some_handler(buffered_read_some_handler&& other)
;
void operator()(const boost::system::error_code& ec, std::size_t)
;
detail::buffered_stream_storage& storage_;
MutableBufferSequence buffers_;
ReadHandler handler_;
};
template <typename MutableBufferSequence, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
buffered_read_some_handler<
MutableBufferSequence, ReadHandler>* this_handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
buffered_read_some_handler<
MutableBufferSequence, ReadHandler>* this_handler)
;
template <typename MutableBufferSequence, typename ReadHandler>
bool asio_handler_is_continuation(
buffered_read_some_handler<
MutableBufferSequence, ReadHandler>* this_handler)
;
template <typename Function, typename MutableBufferSequence,
typename ReadHandler>
void asio_handler_invoke(Function& function,
buffered_read_some_handler<
MutableBufferSequence, ReadHandler>* this_handler)
;
template <typename Function, typename MutableBufferSequence,
typename ReadHandler>
void asio_handler_invoke(const Function& function,
buffered_read_some_handler<
MutableBufferSequence, ReadHandler>* this_handler)
;
}
}
}
#define BOOST_ASIO_BUFFERED_STREAM_FWD_HPP
namespace boost {
namespace asio {
template <typename Stream>
class buffered_stream;
}
}
#define BOOST_ASIO_BUFFERED_STREAM_HPP
#define BOOST_ASIO_BUFFERED_WRITE_STREAM_HPP
#define BOOST_ASIO_BUFFERED_WRITE_STREAM_FWD_HPP
namespace boost {
namespace asio {
template <typename Stream>
class buffered_write_stream;
}
}
#define BOOST_ASIO_COMPLETION_CONDITION_HPP
namespace boost {
namespace asio {
namespace detail {
enum { default_max_transfer_size = 65536 };
std::size_t adapt_completion_condition_result(bool result)
;
std::size_t adapt_completion_condition_result(std::size_t result)
;
class transfer_all_t
{
public:
typedef std::size_t result_type;
template <typename Error>
std::size_t operator()(const Error& err, std::size_t)
;
};
class transfer_at_least_t
{
public:
typedef std::size_t result_type;
explicit transfer_at_least_t(std::size_t minimum)
;
template <typename Error>
std::size_t operator()(const Error& err, std::size_t bytes_transferred)
;
private:
std::size_t minimum_;
};
class transfer_exactly_t
{
public:
typedef std::size_t result_type;
explicit transfer_exactly_t(std::size_t size)
;
template <typename Error>
std::size_t operator()(const Error& err, std::size_t bytes_transferred)
;
private:
std::size_t size_;
};
}
detail::transfer_all_t transfer_all()
;
detail::transfer_at_least_t transfer_at_least(std::size_t minimum)
;
detail::transfer_exactly_t transfer_exactly(std::size_t size)
;
}
}
#define BOOST_ASIO_WRITE_HPP
namespace boost {
namespace asio {
template <typename SyncWriteStream, typename ConstBufferSequence>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers);
template <typename SyncWriteStream, typename ConstBufferSequence>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
boost::system::error_code& ec);
template <typename SyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
CompletionCondition completion_condition);
template <typename SyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
CompletionCondition completion_condition, boost::system::error_code& ec);
template <typename SyncWriteStream, typename Allocator>
std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b);
template <typename SyncWriteStream, typename Allocator>
std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
boost::system::error_code& ec);
template <typename SyncWriteStream, typename Allocator,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition);
template <typename SyncWriteStream, typename Allocator,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition, boost::system::error_code& ec);
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
WriteHandler&& handler);
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
CompletionCondition completion_condition,
WriteHandler&& handler);
template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
WriteHandler&& handler);
template <typename AsyncWriteStream, typename Allocator,
typename CompletionCondition, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition,
WriteHandler&& handler);
}
}
#define BOOST_ASIO_IMPL_WRITE_HPP
#define BOOST_ASIO_DETAIL_BASE_FROM_COMPLETION_COND_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename CompletionCondition>
class base_from_completion_cond
{
protected:
explicit base_from_completion_cond(CompletionCondition completion_condition)
;
std::size_t check_for_completion(
const boost::system::error_code& ec,
std::size_t total_transferred)
;
private:
CompletionCondition completion_condition_;
};
template <>
class base_from_completion_cond<transfer_all_t>
{
protected:
explicit base_from_completion_cond(transfer_all_t)
;
static std::size_t check_for_completion(
const boost::system::error_code& ec,
std::size_t total_transferred)
;
};
}
}
}
#define BOOST_ASIO_DETAIL_CONSUMING_BUFFERS_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Buffer, typename Buffer_Iterator>
class consuming_buffers_iterator
{
public:
typedef std::ptrdiff_t difference_type;
typedef Buffer value_type;
typedef const Buffer* pointer;
typedef const Buffer& reference;
typedef std::forward_iterator_tag iterator_category;
consuming_buffers_iterator()
;
consuming_buffers_iterator(bool at_end, const Buffer& first,
Buffer_Iterator begin_remainder, Buffer_Iterator end_remainder,
std::size_t max_size)
;
const Buffer& operator*() const
;
const Buffer* operator->() const
;
consuming_buffers_iterator& operator++()
;
consuming_buffers_iterator operator++(int)
;
friend bool operator==(const consuming_buffers_iterator& a,
const consuming_buffers_iterator& b)
;
friend bool operator!=(const consuming_buffers_iterator& a,
const consuming_buffers_iterator& b)
;
private:
void increment()
;
bool equal(const consuming_buffers_iterator& other) const
;
const Buffer& dereference() const
;
bool at_end_;
Buffer first_;
Buffer_Iterator begin_remainder_;
Buffer_Iterator end_remainder_;
std::size_t offset_;
std::size_t max_size_;
};
template <typename Buffer, typename Buffers>
class consuming_buffers
{
public:
typedef Buffer value_type;
typedef consuming_buffers_iterator<Buffer, typename Buffers::const_iterator>
const_iterator;
consuming_buffers(const Buffers& buffers)
: buffers_(buffers),
at_end_(buffers_.begin() == buffers_.end()),
begin_remainder_(buffers_.begin()),
max_size_((std::numeric_limits<std::size_t>::max)())
{
if (!at_end_)
{
first_ = *buffers_.begin();
++begin_remainder_;
}
}
consuming_buffers(const consuming_buffers& other)
: buffers_(other.buffers_),
at_end_(other.at_end_),
first_(other.first_),
begin_remainder_(buffers_.begin()),
max_size_(other.max_size_)
{
typename Buffers::const_iterator first = other.buffers_.begin();
typename Buffers::const_iterator second = other.begin_remainder_;
std::advance(begin_remainder_, std::distance(first, second));
}
consuming_buffers& operator=(const consuming_buffers& other)
{
buffers_ = other.buffers_;
at_end_ = other.at_end_;
first_ = other.first_;
begin_remainder_ = buffers_.begin();
typename Buffers::const_iterator first = other.buffers_.begin();
typename Buffers::const_iterator second = other.begin_remainder_;
std::advance(begin_remainder_, std::distance(first, second));
max_size_ = other.max_size_;
return *this;
}
const_iterator begin() const
;
const_iterator end() const
;
void prepare(std::size_t max_size)
;
void consume(std::size_t size)
;
private:
Buffers buffers_;
bool at_end_;
Buffer first_;
typename Buffers::const_iterator begin_remainder_;
std::size_t max_size_;
};
template <typename Buffer>
class consuming_buffers<Buffer, boost::asio::null_buffers>
: public boost::asio::null_buffers
{
public:
consuming_buffers(const boost::asio::null_buffers&)
;
void prepare(std::size_t)
;
void consume(std::size_t)
;
};
}
}
}
#define BOOST_ASIO_DETAIL_DEPENDENT_TYPE_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename DependsOn, typename T>
struct dependent_type
{
typedef T type;
};
}
}
}
namespace boost {
namespace asio {
template <typename SyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
CompletionCondition completion_condition, boost::system::error_code& ec)
;
template <typename SyncWriteStream, typename ConstBufferSequence>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers)
;
template <typename SyncWriteStream, typename ConstBufferSequence>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename SyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
CompletionCondition completion_condition)
;
template <typename SyncWriteStream, typename Allocator,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s,
boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition, boost::system::error_code& ec)
;
template <typename SyncWriteStream, typename Allocator>
std::size_t write(SyncWriteStream& s,
boost::asio::basic_streambuf<Allocator>& b)
;
template <typename SyncWriteStream, typename Allocator>
std::size_t write(SyncWriteStream& s,
boost::asio::basic_streambuf<Allocator>& b,
boost::system::error_code& ec)
;
template <typename SyncWriteStream, typename Allocator,
typename CompletionCondition>
std::size_t write(SyncWriteStream& s,
boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition)
;
namespace detail
{
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition, typename WriteHandler>
class write_op
: detail::base_from_completion_cond<CompletionCondition>
{
public:
write_op(AsyncWriteStream& stream, const ConstBufferSequence& buffers,
CompletionCondition completion_condition, WriteHandler& handler)
;
write_op(const write_op& other)
;
write_op(write_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncWriteStream& stream_;
boost::asio::detail::consuming_buffers<
const_buffer, ConstBufferSequence> buffers_;
int start_;
std::size_t total_transferred_;
WriteHandler handler_;
};
template <typename AsyncWriteStream,
typename CompletionCondition, typename WriteHandler>
class write_op<AsyncWriteStream, boost::asio::mutable_buffers_1,
CompletionCondition, WriteHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
write_op(AsyncWriteStream& stream,
const boost::asio::mutable_buffers_1& buffers,
CompletionCondition completion_condition,
WriteHandler& handler)
;
write_op(const write_op& other)
;
write_op(write_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncWriteStream& stream_;
boost::asio::mutable_buffer buffer_;
int start_;
std::size_t total_transferred_;
WriteHandler handler_;
};
template <typename AsyncWriteStream,
typename CompletionCondition, typename WriteHandler>
class write_op<AsyncWriteStream, boost::asio::const_buffers_1,
CompletionCondition, WriteHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
write_op(AsyncWriteStream& stream,
const boost::asio::const_buffers_1& buffers,
CompletionCondition completion_condition,
WriteHandler& handler)
;
write_op(const write_op& other)
;
write_op(write_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncWriteStream& stream_;
boost::asio::const_buffer buffer_;
int start_;
std::size_t total_transferred_;
WriteHandler handler_;
};
template <typename AsyncWriteStream, typename Elem,
typename CompletionCondition, typename WriteHandler>
class write_op<AsyncWriteStream, boost::array<Elem, 2>,
CompletionCondition, WriteHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
write_op(AsyncWriteStream& stream, const boost::array<Elem, 2>& buffers,
CompletionCondition completion_condition, WriteHandler& handler)
;
write_op(const write_op& other)
;
write_op(write_op&& other)
: detail::base_from_completion_cond<CompletionCondition>(other),
stream_(other.stream_),
buffers_(other.buffers_),
start_(other.start_),
total_transferred_(other.total_transferred_),
handler_(static_cast<WriteHandler&&>(other.handler_))
{
}
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
{
typename boost::asio::detail::dependent_type<Elem,
boost::array<boost::asio::const_buffer, 2> >::type bufs = {{
boost::asio::const_buffer(buffers_[0]),
boost::asio::const_buffer(buffers_[1]) }};
std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
std::size_t n = 0;
switch (start_ = start)
{
case 1:
n = this->check_for_completion(ec, total_transferred_);
for (;;)
{
bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
bufs[1] = boost::asio::buffer(
bufs[1] + (total_transferred_ < buffer_size0
? 0 : total_transferred_ - buffer_size0),
n - boost::asio::buffer_size(bufs[0]));
stream_.async_write_some(bufs, static_cast<write_op&&>(*this));
return; default:
total_transferred_ += bytes_transferred;
if ((!ec && bytes_transferred == 0)
|| (n = this->check_for_completion(ec, total_transferred_)) == 0
|| total_transferred_ == buffer_size0 + buffer_size1)
break;
}
handler_(ec, static_cast<const std::size_t&>(total_transferred_));
}
}
AsyncWriteStream& stream_;
boost::array<Elem, 2> buffers_;
int start_;
std::size_t total_transferred_;
WriteHandler handler_;
};
template <typename AsyncWriteStream, typename Elem,
typename CompletionCondition, typename WriteHandler>
class write_op<AsyncWriteStream, std::array<Elem, 2>,
CompletionCondition, WriteHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
write_op(AsyncWriteStream& stream, const std::array<Elem, 2>& buffers,
CompletionCondition completion_condition, WriteHandler& handler)
: detail::base_from_completion_cond<
CompletionCondition>(completion_condition),
stream_(stream),
buffers_(buffers),
start_(0),
total_transferred_(0),
handler_(static_cast<WriteHandler&&>(handler))
{
}
write_op(const write_op& other)
: detail::base_from_completion_cond<CompletionCondition>(other),
stream_(other.stream_),
buffers_(other.buffers_),
start_(other.start_),
total_transferred_(other.total_transferred_),
handler_(other.handler_)
{
}
write_op(write_op&& other)
: detail::base_from_completion_cond<CompletionCondition>(other),
stream_(other.stream_),
buffers_(other.buffers_),
start_(other.start_),
total_transferred_(other.total_transferred_),
handler_(static_cast<WriteHandler&&>(other.handler_))
{
}
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
{
typename boost::asio::detail::dependent_type<Elem,
std::array<boost::asio::const_buffer, 2> >::type bufs = {{
boost::asio::const_buffer(buffers_[0]),
boost::asio::const_buffer(buffers_[1]) }};
std::size_t buffer_size0 = boost::asio::buffer_size(bufs[0]);
std::size_t buffer_size1 = boost::asio::buffer_size(bufs[1]);
std::size_t n = 0;
switch (start_ = start)
{
case 1:
n = this->check_for_completion(ec, total_transferred_);
for (;;)
{
bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
bufs[1] = boost::asio::buffer(
bufs[1] + (total_transferred_ < buffer_size0
? 0 : total_transferred_ - buffer_size0),
n - boost::asio::buffer_size(bufs[0]));
stream_.async_write_some(bufs, static_cast<write_op&&>(*this));
return; default:
total_transferred_ += bytes_transferred;
if ((!ec && bytes_transferred == 0)
|| (n = this->check_for_completion(ec, total_transferred_)) == 0
|| total_transferred_ == buffer_size0 + buffer_size1)
break;
}
handler_(ec, static_cast<const std::size_t&>(total_transferred_));
}
}
AsyncWriteStream& stream_;
std::array<Elem, 2> buffers_;
int start_;
std::size_t total_transferred_;
WriteHandler handler_;
};
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition, typename WriteHandler>
inline void* asio_handler_allocate(std::size_t size,
write_op<AsyncWriteStream, ConstBufferSequence,
CompletionCondition, WriteHandler>* this_handler)
{
return boost_asio_handler_alloc_helpers::allocate(
size, this_handler->handler_);
}
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition, typename WriteHandler>
inline void asio_handler_deallocate(void* pointer, std::size_t size,
write_op<AsyncWriteStream, ConstBufferSequence,
CompletionCondition, WriteHandler>* this_handler)
{
boost_asio_handler_alloc_helpers::deallocate(
pointer, size, this_handler->handler_);
}
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition, typename WriteHandler>
inline bool asio_handler_is_continuation(
write_op<AsyncWriteStream, ConstBufferSequence,
CompletionCondition, WriteHandler>* this_handler)
{
return this_handler->start_ == 0 ? true
: boost_asio_handler_cont_helpers::is_continuation(
this_handler->handler_);
}
template <typename Function, typename AsyncWriteStream,
typename ConstBufferSequence, typename CompletionCondition,
typename WriteHandler>
inline void asio_handler_invoke(Function& function,
write_op<AsyncWriteStream, ConstBufferSequence,
CompletionCondition, WriteHandler>* this_handler)
{
boost_asio_handler_invoke_helpers::invoke(
function, this_handler->handler_);
}
template <typename Function, typename AsyncWriteStream,
typename ConstBufferSequence, typename CompletionCondition,
typename WriteHandler>
inline void asio_handler_invoke(const Function& function,
write_op<AsyncWriteStream, ConstBufferSequence,
CompletionCondition, WriteHandler>* this_handler)
{
boost_asio_handler_invoke_helpers::invoke(
function, this_handler->handler_);
}
}
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename CompletionCondition, typename WriteHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
CompletionCondition completion_condition,
WriteHandler&& handler)
{
typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
detail::async_result_init<
WriteHandler, void (boost::system::error_code, std::size_t)> init(
static_cast<WriteHandler&&>(handler));
detail::write_op<AsyncWriteStream, ConstBufferSequence,
CompletionCondition, typename handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>(
s, buffers, completion_condition, init.handler)(
boost::system::error_code(), 0, 1);
return init.result.get();
}
template <typename AsyncWriteStream, typename ConstBufferSequence,
typename WriteHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
WriteHandler&& handler)
{
typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
detail::async_result_init<
WriteHandler, void (boost::system::error_code, std::size_t)> init(
static_cast<WriteHandler&&>(handler));
detail::write_op<AsyncWriteStream, ConstBufferSequence,
detail::transfer_all_t, typename handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>(
s, buffers, transfer_all(), init.handler)(
boost::system::error_code(), 0, 1);
return init.result.get();
}
namespace detail
{
template <typename Allocator, typename WriteHandler>
class write_streambuf_handler
{
public:
write_streambuf_handler(boost::asio::basic_streambuf<Allocator>& streambuf,
WriteHandler& handler)
: streambuf_(streambuf),
handler_(static_cast<WriteHandler&&>(handler))
{
}
write_streambuf_handler(const write_streambuf_handler& other)
: streambuf_(other.streambuf_),
handler_(other.handler_)
{
}
write_streambuf_handler(write_streambuf_handler&& other)
: streambuf_(other.streambuf_),
handler_(static_cast<WriteHandler&&>(other.handler_))
{
}
void operator()(const boost::system::error_code& ec,
const std::size_t bytes_transferred)
{
streambuf_.consume(bytes_transferred);
handler_(ec, bytes_transferred);
}
boost::asio::basic_streambuf<Allocator>& streambuf_;
WriteHandler handler_;
};
template <typename Allocator, typename WriteHandler>
inline void* asio_handler_allocate(std::size_t size,
write_streambuf_handler<Allocator, WriteHandler>* this_handler)
{
return boost_asio_handler_alloc_helpers::allocate(
size, this_handler->handler_);
}
template <typename Allocator, typename WriteHandler>
inline void asio_handler_deallocate(void* pointer, std::size_t size,
write_streambuf_handler<Allocator, WriteHandler>* this_handler)
{
boost_asio_handler_alloc_helpers::deallocate(
pointer, size, this_handler->handler_);
}
template <typename Allocator, typename WriteHandler>
inline bool asio_handler_is_continuation(
write_streambuf_handler<Allocator, WriteHandler>* this_handler)
{
return boost_asio_handler_cont_helpers::is_continuation(
this_handler->handler_);
}
template <typename Function, typename Allocator, typename WriteHandler>
inline void asio_handler_invoke(Function& function,
write_streambuf_handler<Allocator, WriteHandler>* this_handler)
{
boost_asio_handler_invoke_helpers::invoke(
function, this_handler->handler_);
}
template <typename Function, typename Allocator, typename WriteHandler>
inline void asio_handler_invoke(const Function& function,
write_streambuf_handler<Allocator, WriteHandler>* this_handler)
{
boost_asio_handler_invoke_helpers::invoke(
function, this_handler->handler_);
}
}
template <typename AsyncWriteStream, typename Allocator,
typename CompletionCondition, typename WriteHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s,
boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition,
WriteHandler&& handler)
{
typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
detail::async_result_init<
WriteHandler, void (boost::system::error_code, std::size_t)> init(
static_cast<WriteHandler&&>(handler));
async_write(s, b.data(), completion_condition,
detail::write_streambuf_handler<Allocator, typename handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>(
b, init.handler));
return init.result.get();
}
template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write(AsyncWriteStream& s,
boost::asio::basic_streambuf<Allocator>& b,
WriteHandler&& handler)
{
typedef typename handler_type<WriteHandler, void(boost::system::error_code, std::size_t)>::type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
detail::async_result_init<
WriteHandler, void (boost::system::error_code, std::size_t)> init(
static_cast<WriteHandler&&>(handler));
async_write(s, b.data(), transfer_all(),
detail::write_streambuf_handler<Allocator, typename handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>(
b, init.handler));
return init.result.get();
}
}
}
namespace boost {
namespace asio {
template <typename Stream>
class buffered_write_stream
: private noncopyable
{
public:
typedef typename remove_reference<Stream>::type next_layer_type;
typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
static const std::size_t default_buffer_size = 1024;
template <typename Arg>
explicit buffered_write_stream(Arg& a)
: next_layer_(a),
storage_(default_buffer_size)
{
}
template <typename Arg>
buffered_write_stream(Arg& a, std::size_t buffer_size)
: next_layer_(a),
storage_(buffer_size)
{
}
next_layer_type& next_layer()
;
lowest_layer_type& lowest_layer()
;
const lowest_layer_type& lowest_layer() const
;
boost::asio::io_service& get_io_service()
;
void close()
;
boost::system::error_code close(boost::system::error_code& ec)
;
std::size_t flush();
std::size_t flush(boost::system::error_code& ec);
template <typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_flush(WriteHandler&& handler);
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers);
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers,
boost::system::error_code& ec);
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(const ConstBufferSequence& buffers,
WriteHandler&& handler);
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t peek(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t peek(const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
std::size_t in_avail()
;
std::size_t in_avail(boost::system::error_code& ec)
;
private:
template <typename ConstBufferSequence>
std::size_t copy(const ConstBufferSequence& buffers);
Stream next_layer_;
detail::buffered_stream_storage storage_;
};
}
}
#define BOOST_ASIO_IMPL_BUFFERED_WRITE_STREAM_HPP
namespace boost {
namespace asio {
namespace detail
{
template <typename WriteHandler>
class buffered_flush_handler
{
public:
buffered_flush_handler(detail::buffered_stream_storage& storage,
WriteHandler& handler)
;
buffered_flush_handler(const buffered_flush_handler& other)
;
buffered_flush_handler(buffered_flush_handler&& other)
;
void operator()(const boost::system::error_code& ec,
const std::size_t bytes_written)
;
detail::buffered_stream_storage& storage_;
WriteHandler handler_;
};
template <typename WriteHandler>
void* asio_handler_allocate(std::size_t size,
buffered_flush_handler<WriteHandler>* this_handler)
;
template <typename WriteHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
buffered_flush_handler<WriteHandler>* this_handler)
;
template <typename WriteHandler>
bool asio_handler_is_continuation(
buffered_flush_handler<WriteHandler>* this_handler)
;
template <typename Function, typename WriteHandler>
void asio_handler_invoke(Function& function,
buffered_flush_handler<WriteHandler>* this_handler)
;
template <typename Function, typename WriteHandler>
void asio_handler_invoke(const Function& function,
buffered_flush_handler<WriteHandler>* this_handler)
;
}
namespace detail
{
template <typename ConstBufferSequence, typename WriteHandler>
class buffered_write_some_handler
{
public:
buffered_write_some_handler(detail::buffered_stream_storage& storage,
const ConstBufferSequence& buffers, WriteHandler& handler)
;
buffered_write_some_handler(const buffered_write_some_handler& other)
;
buffered_write_some_handler(buffered_write_some_handler&& other)
;
void operator()(const boost::system::error_code& ec, std::size_t)
;
detail::buffered_stream_storage& storage_;
ConstBufferSequence buffers_;
WriteHandler handler_;
};
template <typename ConstBufferSequence, typename WriteHandler>
void* asio_handler_allocate(std::size_t size,
buffered_write_some_handler<
ConstBufferSequence, WriteHandler>* this_handler)
;
template <typename ConstBufferSequence, typename WriteHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
buffered_write_some_handler<
ConstBufferSequence, WriteHandler>* this_handler)
;
template <typename ConstBufferSequence, typename WriteHandler>
bool asio_handler_is_continuation(
buffered_write_some_handler<
ConstBufferSequence, WriteHandler>* this_handler)
;
template <typename Function, typename ConstBufferSequence,
typename WriteHandler>
void asio_handler_invoke(Function& function,
buffered_write_some_handler<
ConstBufferSequence, WriteHandler>* this_handler)
;
template <typename Function, typename ConstBufferSequence,
typename WriteHandler>
void asio_handler_invoke(const Function& function,
buffered_write_some_handler<
ConstBufferSequence, WriteHandler>* this_handler)
;
}
}
}
namespace boost {
namespace asio {
template <typename Stream>
class buffered_stream
: private noncopyable
{
public:
typedef typename remove_reference<Stream>::type next_layer_type;
typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
template <typename Arg>
explicit buffered_stream(Arg& a)
;
template <typename Arg>
explicit buffered_stream(Arg& a, std::size_t read_buffer_size,
std::size_t write_buffer_size)
;
next_layer_type& next_layer()
;
lowest_layer_type& lowest_layer()
;
const lowest_layer_type& lowest_layer() const
;
boost::asio::io_service& get_io_service()
;
void close()
;
boost::system::error_code close(boost::system::error_code& ec)
;
std::size_t flush()
;
std::size_t flush(boost::system::error_code& ec)
;
template <typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_flush(WriteHandler&& handler)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
std::size_t fill()
;
std::size_t fill(boost::system::error_code& ec)
;
template <typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_fill(ReadHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t peek(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t peek(const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
std::size_t in_avail()
;
std::size_t in_avail(boost::system::error_code& ec)
;
private:
typedef buffered_write_stream<Stream> write_stream_type;
write_stream_type inner_stream_impl_;
typedef buffered_read_stream<write_stream_type&> read_stream_type;
read_stream_type stream_impl_;
};
}
}
#define BOOST_ASIO_BUFFERS_ITERATOR_HPP
namespace boost {
namespace asio {
namespace detail
{
template <bool IsMutable>
struct buffers_iterator_types_helper;
template <>
struct buffers_iterator_types_helper<false>
{
typedef const_buffer buffer_type;
template <typename ByteType>
struct byte_type
{
typedef typename add_const<ByteType>::type type;
};
};
template <>
struct buffers_iterator_types_helper<true>
{
typedef mutable_buffer buffer_type;
template <typename ByteType>
struct byte_type
{
typedef ByteType type;
};
};
template <typename BufferSequence, typename ByteType>
struct buffers_iterator_types
{
enum
{
is_mutable = is_convertible<
typename BufferSequence::value_type,
mutable_buffer>::value
};
typedef buffers_iterator_types_helper<is_mutable> helper;
typedef typename helper::buffer_type buffer_type;
typedef typename helper::template byte_type<ByteType>::type byte_type;
};
}
template <typename BufferSequence, typename ByteType = char>
class buffers_iterator
{
private:
typedef typename detail::buffers_iterator_types<
BufferSequence, ByteType>::buffer_type buffer_type;
public:
typedef std::ptrdiff_t difference_type;
typedef ByteType value_type;
typedef typename detail::buffers_iterator_types<
BufferSequence, ByteType>::byte_type* pointer;
typedef typename detail::buffers_iterator_types<
BufferSequence, ByteType>::byte_type& reference;
typedef std::random_access_iterator_tag iterator_category;
buffers_iterator()
;
static buffers_iterator begin(const BufferSequence& buffers)
;
static buffers_iterator end(const BufferSequence& buffers)
;
reference operator*() const
;
pointer operator->() const
;
reference operator[](std::ptrdiff_t difference) const
;
buffers_iterator& operator++()
;
buffers_iterator operator++(int)
;
buffers_iterator& operator--()
;
buffers_iterator operator--(int)
;
buffers_iterator& operator+=(std::ptrdiff_t difference)
;
buffers_iterator& operator-=(std::ptrdiff_t difference)
;
friend buffers_iterator operator+(const buffers_iterator& iter,
std::ptrdiff_t difference)
;
friend buffers_iterator operator+(std::ptrdiff_t difference,
const buffers_iterator& iter)
;
friend buffers_iterator operator-(const buffers_iterator& iter,
std::ptrdiff_t difference)
;
friend std::ptrdiff_t operator-(const buffers_iterator& a,
const buffers_iterator& b)
;
friend bool operator==(const buffers_iterator& a, const buffers_iterator& b)
;
friend bool operator!=(const buffers_iterator& a, const buffers_iterator& b)
;
friend bool operator<(const buffers_iterator& a, const buffers_iterator& b)
;
friend bool operator<=(const buffers_iterator& a, const buffers_iterator& b)
;
friend bool operator>(const buffers_iterator& a, const buffers_iterator& b)
;
friend bool operator>=(const buffers_iterator& a, const buffers_iterator& b)
;
private:
reference dereference() const
;
bool equal(const buffers_iterator& other) const
;
void increment()
;
void decrement()
;
void advance(std::ptrdiff_t n)
;
std::ptrdiff_t distance_to(const buffers_iterator& other) const
;
buffer_type current_buffer_;
std::size_t current_buffer_position_;
typename BufferSequence::const_iterator begin_;
typename BufferSequence::const_iterator current_;
typename BufferSequence::const_iterator end_;
std::size_t position_;
};
template <typename BufferSequence>
buffers_iterator<BufferSequence> buffers_begin(
const BufferSequence& buffers)
;
template <typename BufferSequence>
buffers_iterator<BufferSequence> buffers_end(
const BufferSequence& buffers)
;
}
}
#define BOOST_ASIO_CONNECT_HPP
namespace boost {
namespace asio {
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin);
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, boost::system::error_code& ec);
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end);
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, boost::system::error_code& ec);
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, ConnectCondition connect_condition);
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
ConnectCondition connect_condition, boost::system::error_code& ec);
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
Iterator end, ConnectCondition connect_condition);
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, ConnectCondition connect_condition,
boost::system::error_code& ec);
template <typename Protocol, typename SocketService,
typename Iterator, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, ComposedConnectHandler&& handler);
template <typename Protocol, typename SocketService,
typename Iterator, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end,
ComposedConnectHandler&& handler);
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
ConnectCondition connect_condition,
ComposedConnectHandler&& handler);
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, ConnectCondition connect_condition,
ComposedConnectHandler&& handler);
}
}
#define BOOST_ASIO_IMPL_CONNECT_HPP
namespace boost {
namespace asio {
namespace detail
{
struct default_connect_condition
{
template <typename Iterator>
Iterator operator()(const boost::system::error_code&, Iterator next)
;
};
}
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin)
;
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, boost::system::error_code& ec)
;
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end)
;
template <typename Protocol, typename SocketService, typename Iterator>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, boost::system::error_code& ec)
;
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, ConnectCondition connect_condition)
;
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, ConnectCondition connect_condition,
boost::system::error_code& ec)
;
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, ConnectCondition connect_condition)
;
template <typename Protocol, typename SocketService,
typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, ConnectCondition connect_condition,
boost::system::error_code& ec)
;
namespace detail
{
template <typename ConnectCondition>
class base_from_connect_condition
{
protected:
explicit base_from_connect_condition(
const ConnectCondition& connect_condition)
;
template <typename Iterator>
void check_condition(const boost::system::error_code& ec,
Iterator& iter, Iterator& end)
;
private:
ConnectCondition connect_condition_;
};
template <>
class base_from_connect_condition<default_connect_condition>
{
protected:
explicit base_from_connect_condition(const default_connect_condition&)
;
template <typename Iterator>
void check_condition(const boost::system::error_code&, Iterator&, Iterator&)
;
};
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
class connect_op : base_from_connect_condition<ConnectCondition>
{
public:
connect_op(basic_socket<Protocol, SocketService>& sock,
const Iterator& begin, const Iterator& end,
const ConnectCondition& connect_condition,
ComposedConnectHandler& handler)
;
connect_op(const connect_op& other)
;
connect_op(connect_op&& other)
;
void operator()(boost::system::error_code ec, int start = 0)
;
basic_socket<Protocol, SocketService>& socket_;
Iterator iter_;
Iterator end_;
int start_;
ComposedConnectHandler handler_;
};
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
void* asio_handler_allocate(std::size_t size,
connect_op<Protocol, SocketService, Iterator,
ConnectCondition, ComposedConnectHandler>* this_handler)
;
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
connect_op<Protocol, SocketService, Iterator,
ConnectCondition, ComposedConnectHandler>* this_handler)
;
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
bool asio_handler_is_continuation(
connect_op<Protocol, SocketService, Iterator,
ConnectCondition, ComposedConnectHandler>* this_handler)
;
template <typename Function, typename Protocol,
typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
void asio_handler_invoke(Function& function,
connect_op<Protocol, SocketService, Iterator,
ConnectCondition, ComposedConnectHandler>* this_handler)
;
template <typename Function, typename Protocol,
typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
void asio_handler_invoke(const Function& function,
connect_op<Protocol, SocketService, Iterator,
ConnectCondition, ComposedConnectHandler>* this_handler)
;
}
template <typename Protocol, typename SocketService,
typename Iterator, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, ComposedConnectHandler&& handler)
;
template <typename Protocol, typename SocketService,
typename Iterator, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end,
ComposedConnectHandler&& handler)
;
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, ConnectCondition connect_condition,
ComposedConnectHandler&& handler)
;
template <typename Protocol, typename SocketService, typename Iterator,
typename ConnectCondition, typename ComposedConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ComposedConnectHandler, void (boost::system::error_code, Iterator)>::type>::type
async_connect(basic_socket<Protocol, SocketService>& s,
Iterator begin, Iterator end, ConnectCondition connect_condition,
ComposedConnectHandler&& handler)
;
}
}
#define BOOST_ASIO_COROUTINE_HPP
namespace boost {
namespace asio {
namespace detail {
class coroutine_ref;
}
class coroutine
{
public:
coroutine() ;
bool is_child() const ;
bool is_parent() const ;
bool is_complete() const ;
private:
friend class detail::coroutine_ref;
int value_;
};
namespace detail {
class coroutine_ref
{
public:
coroutine_ref(coroutine& c) ;
coroutine_ref(coroutine* c) ;
~coroutine_ref() ;
operator int() const ;
int& operator=(int v) ;
private:
void operator=(const coroutine_ref&);
int& value_;
bool modified_;
};
}
}
}
#define BOOST_ASIO_CORO_REENTER(c) switch (::boost::asio::detail::coroutine_ref _coro_value = c) case -1: if (_coro_value) { goto terminate_coroutine; terminate_coroutine: _coro_value = -1; goto bail_out_of_coroutine; bail_out_of_coroutine: break; } else case 0:
#define BOOST_ASIO_CORO_YIELD_IMPL(n) for (_coro_value = (n);;) if (_coro_value == 0) { case (n): ; break; } else switch (_coro_value ? 0 : 1) for (;;) case -1: if (_coro_value) goto terminate_coroutine; else for (;;) case 1: if (_coro_value) goto bail_out_of_coroutine; else case 0:
#define BOOST_ASIO_CORO_FORK_IMPL(n) for (_coro_value = -(n);; _coro_value = (n)) if (_coro_value == (n)) { case -(n): ; break; } else
#define BOOST_ASIO_CORO_YIELD BOOST_ASIO_CORO_YIELD_IMPL(__LINE__)
#define BOOST_ASIO_CORO_FORK BOOST_ASIO_CORO_FORK_IMPL(__LINE__)
#define BOOST_ASIO_GENERIC_BASIC_ENDPOINT_HPP
#define BOOST_ASIO_GENERIC_DETAIL_ENDPOINT_HPP
namespace boost {
namespace asio {
namespace generic {
namespace detail {
class endpoint
{
public:
inline endpoint();
inline endpoint(const void* sock_addr,
std::size_t sock_addr_size, int sock_protocol);
endpoint(const endpoint& other)
;
endpoint& operator=(const endpoint& other)
;
int family() const
;
int protocol() const
;
boost::asio::detail::socket_addr_type* data()
;
const boost::asio::detail::socket_addr_type* data() const
;
std::size_t size() const
;
inline void resize(std::size_t size);
std::size_t capacity() const
;
inline friend bool operator==(
const endpoint& e1, const endpoint& e2);
inline friend bool operator<(
const endpoint& e1, const endpoint& e2);
private:
union data_union
{
boost::asio::detail::socket_addr_type base;
boost::asio::detail::sockaddr_storage_type generic;
} data_;
std::size_t size_;
int protocol_;
inline void init(const void* sock_addr,
std::size_t sock_addr_size, int sock_protocol);
};
}
}
}
}
#define BOOST_ASIO_GENERIC_DETAIL_IMPL_ENDPOINT_IPP
namespace boost {
namespace asio {
namespace generic {
namespace detail {
bool operator==(const endpoint& e1, const endpoint& e2)
;
bool operator<(const endpoint& e1, const endpoint& e2)
;
}
}
}
}
namespace boost {
namespace asio {
namespace generic {
template <typename Protocol>
class basic_endpoint
{
public:
typedef Protocol protocol_type;
typedef boost::asio::detail::socket_addr_type data_type;
basic_endpoint()
;
basic_endpoint(const void* socket_address,
std::size_t socket_address_size, int socket_protocol = 0)
;
template <typename Endpoint>
basic_endpoint(const Endpoint& endpoint)
;
basic_endpoint(const basic_endpoint& other)
;
basic_endpoint(basic_endpoint&& other)
;
basic_endpoint& operator=(const basic_endpoint& other)
;
basic_endpoint& operator=(basic_endpoint&& other)
;
protocol_type protocol() const
;
data_type* data()
;
const data_type* data() const
;
std::size_t size() const
;
void resize(std::size_t new_size)
;
std::size_t capacity() const
;
friend bool operator==(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator!=(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator<(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator>(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator<=(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator>=(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
private:
boost::asio::generic::detail::endpoint impl_;
};
}
}
}
#define BOOST_ASIO_GENERIC_DATAGRAM_PROTOCOL_HPP
namespace boost {
namespace asio {
namespace generic {
class datagram_protocol
{
public:
datagram_protocol(int address_family, int socket_protocol)
;
template <typename Protocol>
datagram_protocol(const Protocol& source_protocol)
;
int type() const
;
int protocol() const
;
int family() const
;
friend bool operator==(const datagram_protocol& p1,
const datagram_protocol& p2)
;
friend bool operator!=(const datagram_protocol& p1,
const datagram_protocol& p2)
;
typedef basic_endpoint<datagram_protocol> endpoint;
typedef basic_datagram_socket<datagram_protocol> socket;
private:
int family_;
int protocol_;
};
}
}
}
#define BOOST_ASIO_GENERIC_RAW_PROTOCOL_HPP
namespace boost {
namespace asio {
namespace generic {
class raw_protocol
{
public:
raw_protocol(int address_family, int socket_protocol)
;
template <typename Protocol>
raw_protocol(const Protocol& source_protocol)
;
int type() const
;
int protocol() const
;
int family() const
;
friend bool operator==(const raw_protocol& p1, const raw_protocol& p2)
;
friend bool operator!=(const raw_protocol& p1, const raw_protocol& p2)
;
typedef basic_endpoint<raw_protocol> endpoint;
typedef basic_raw_socket<raw_protocol> socket;
private:
int family_;
int protocol_;
};
}
}
}
#define BOOST_ASIO_GENERIC_SEQ_PACKET_PROTOCOL_HPP
namespace boost {
namespace asio {
namespace generic {
class seq_packet_protocol
{
public:
seq_packet_protocol(int address_family, int socket_protocol)
;
template <typename Protocol>
seq_packet_protocol(const Protocol& source_protocol)
;
int type() const
;
int protocol() const
;
int family() const
;
friend bool operator==(const seq_packet_protocol& p1,
const seq_packet_protocol& p2)
;
friend bool operator!=(const seq_packet_protocol& p1,
const seq_packet_protocol& p2)
;
typedef basic_endpoint<seq_packet_protocol> endpoint;
typedef basic_seq_packet_socket<seq_packet_protocol> socket;
private:
int family_;
int protocol_;
};
}
}
}
#define BOOST_ASIO_GENERIC_STREAM_PROTOCOL_HPP
namespace boost {
namespace asio {
namespace generic {
class stream_protocol
{
public:
stream_protocol(int address_family, int socket_protocol)
;
template <typename Protocol>
stream_protocol(const Protocol& source_protocol)
;
int type() const
;
int protocol() const
;
int family() const
;
friend bool operator==(const stream_protocol& p1, const stream_protocol& p2)
;
friend bool operator!=(const stream_protocol& p1, const stream_protocol& p2)
;
typedef basic_endpoint<stream_protocol> endpoint;
typedef basic_stream_socket<stream_protocol> socket;
typedef basic_socket_iostream<stream_protocol> iostream;
private:
int family_;
int protocol_;
};
}
}
}
#define BOOST_ASIO_IP_ADDRESS_HPP
#define BOOST_ASIO_IP_ADDRESS_V4_HPP
#define BOOST_ASIO_DETAIL_WINSOCK_INIT_HPP
namespace boost {
namespace asio {
namespace ip {
class address_v4
{
public:
typedef boost::asio::detail::array<unsigned char, 4> bytes_type;
address_v4()
;
inline explicit address_v4(const bytes_type& bytes);
inline explicit address_v4(unsigned long addr);
address_v4(const address_v4& other)
;
address_v4(address_v4&& other)
;
address_v4& operator=(const address_v4& other)
;
address_v4& operator=(address_v4&& other)
;
inline bytes_type to_bytes() const;
inline unsigned long to_ulong() const;
inline std::string to_string() const;
inline std::string to_string(boost::system::error_code& ec) const;
inline static address_v4 from_string(const char* str);
inline static address_v4 from_string(
const char* str, boost::system::error_code& ec);
inline static address_v4 from_string(const std::string& str);
inline static address_v4 from_string(
const std::string& str, boost::system::error_code& ec);
inline bool is_loopback() const;
inline bool is_unspecified() const;
inline bool is_class_a() const;
inline bool is_class_b() const;
inline bool is_class_c() const;
inline bool is_multicast() const;
friend bool operator==(const address_v4& a1, const address_v4& a2)
;
friend bool operator!=(const address_v4& a1, const address_v4& a2)
;
friend bool operator<(const address_v4& a1, const address_v4& a2)
;
friend bool operator>(const address_v4& a1, const address_v4& a2)
;
friend bool operator<=(const address_v4& a1, const address_v4& a2)
;
friend bool operator>=(const address_v4& a1, const address_v4& a2)
;
static address_v4 any()
;
static address_v4 loopback()
;
static address_v4 broadcast()
;
inline static address_v4 broadcast(
const address_v4& addr, const address_v4& mask);
inline static address_v4 netmask(const address_v4& addr);
private:
boost::asio::detail::in4_addr_type addr_;
};
template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os, const address_v4& addr);
}
}
}
#define BOOST_ASIO_IP_IMPL_ADDRESS_V4_HPP
namespace boost {
namespace asio {
namespace ip {
template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os, const address_v4& addr)
;
}
}
}
#define BOOST_ASIO_IP_IMPL_ADDRESS_V4_IPP
namespace boost {
namespace asio {
namespace ip {
bool address_v4::is_loopback() const
{
return (to_ulong() & 0xFF000000) == 0x7F000000;
}
bool address_v4::is_unspecified() const
{
return to_ulong() == 0;
}
bool address_v4::is_class_a() const
{
return (to_ulong() & 0x80000000) == 0;
}
bool address_v4::is_class_b() const
{
return (to_ulong() & 0xC0000000) == 0x80000000;
}
bool address_v4::is_class_c() const
{
return (to_ulong() & 0xE0000000) == 0xC0000000;
}
bool address_v4::is_multicast() const
{
return (to_ulong() & 0xF0000000) == 0xE0000000;
}
}
}
}
#define BOOST_ASIO_IP_ADDRESS_V6_HPP
namespace boost {
namespace asio {
namespace ip {
class address_v6
{
public:
typedef boost::asio::detail::array<unsigned char, 16> bytes_type;
inline address_v6();
inline explicit address_v6(const bytes_type& bytes,
unsigned long scope_id = 0);
inline address_v6(const address_v6& other);
inline address_v6(address_v6&& other);
inline address_v6& operator=(const address_v6& other);
inline address_v6& operator=(address_v6&& other);
unsigned long scope_id() const
;
void scope_id(unsigned long id)
;
inline bytes_type to_bytes() const;
inline std::string to_string() const;
inline std::string to_string(boost::system::error_code& ec) const;
inline static address_v6 from_string(const char* str);
inline static address_v6 from_string(
const char* str, boost::system::error_code& ec);
inline static address_v6 from_string(const std::string& str);
inline static address_v6 from_string(
const std::string& str, boost::system::error_code& ec);
inline address_v4 to_v4() const;
inline bool is_loopback() const;
inline bool is_unspecified() const;
inline bool is_link_local() const;
inline bool is_site_local() const;
inline bool is_v4_mapped() const;
inline bool is_v4_compatible() const;
inline bool is_multicast() const;
inline bool is_multicast_global() const;
inline bool is_multicast_link_local() const;
inline bool is_multicast_node_local() const;
inline bool is_multicast_org_local() const;
inline bool is_multicast_site_local() const;
inline friend bool operator==(
const address_v6& a1, const address_v6& a2);
friend bool operator!=(const address_v6& a1, const address_v6& a2)
;
inline friend bool operator<(
const address_v6& a1, const address_v6& a2);
friend bool operator>(const address_v6& a1, const address_v6& a2)
;
friend bool operator<=(const address_v6& a1, const address_v6& a2)
;
friend bool operator>=(const address_v6& a1, const address_v6& a2)
;
static address_v6 any()
;
inline static address_v6 loopback();
inline static address_v6 v4_mapped(const address_v4& addr);
inline static address_v6 v4_compatible(const address_v4& addr);
private:
boost::asio::detail::in6_addr_type addr_;
unsigned long scope_id_;
};
template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os, const address_v6& addr);
}
}
}
#define BOOST_ASIO_IP_IMPL_ADDRESS_V6_HPP
namespace boost {
namespace asio {
namespace ip {
template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os, const address_v6& addr)
;
}
}
}
#define BOOST_ASIO_IP_IMPL_ADDRESS_V6_IPP
namespace boost {
namespace asio {
namespace ip {
bool address_v6::is_loopback() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
&& (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
&& (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
&& (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
&& (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
&& (addr_.__in6_u.__u6_addr8[10] == 0) && (addr_.__in6_u.__u6_addr8[11] == 0)
&& (addr_.__in6_u.__u6_addr8[12] == 0) && (addr_.__in6_u.__u6_addr8[13] == 0)
&& (addr_.__in6_u.__u6_addr8[14] == 0) && (addr_.__in6_u.__u6_addr8[15] == 1));
}
bool address_v6::is_unspecified() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
&& (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
&& (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
&& (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
&& (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
&& (addr_.__in6_u.__u6_addr8[10] == 0) && (addr_.__in6_u.__u6_addr8[11] == 0)
&& (addr_.__in6_u.__u6_addr8[12] == 0) && (addr_.__in6_u.__u6_addr8[13] == 0)
&& (addr_.__in6_u.__u6_addr8[14] == 0) && (addr_.__in6_u.__u6_addr8[15] == 0));
}
bool address_v6::is_link_local() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0xfe) && ((addr_.__in6_u.__u6_addr8[1] & 0xc0) == 0x80));
}
bool address_v6::is_site_local() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0xfe) && ((addr_.__in6_u.__u6_addr8[1] & 0xc0) == 0xc0));
}
bool address_v6::is_v4_mapped() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
&& (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
&& (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
&& (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
&& (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
&& (addr_.__in6_u.__u6_addr8[10] == 0xff) && (addr_.__in6_u.__u6_addr8[11] == 0xff));
}
bool address_v6::is_v4_compatible() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
&& (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
&& (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
&& (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
&& (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
&& (addr_.__in6_u.__u6_addr8[10] == 0) && (addr_.__in6_u.__u6_addr8[11] == 0)
&& !((addr_.__in6_u.__u6_addr8[12] == 0)
&& (addr_.__in6_u.__u6_addr8[13] == 0)
&& (addr_.__in6_u.__u6_addr8[14] == 0)
&& ((addr_.__in6_u.__u6_addr8[15] == 0) || (addr_.__in6_u.__u6_addr8[15] == 1))));
}
bool address_v6::is_multicast() const
{
return (addr_.__in6_u.__u6_addr8[0] == 0xff);
}
bool address_v6::is_multicast_global() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x0e));
}
bool address_v6::is_multicast_link_local() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x02));
}
bool address_v6::is_multicast_node_local() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x01));
}
bool address_v6::is_multicast_org_local() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x08));
}
bool address_v6::is_multicast_site_local() const
{
return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x05));
}
bool operator==(const address_v6& a1, const address_v6& a2)
;
bool operator<(const address_v6& a1, const address_v6& a2)
;
}
}
}
namespace boost {
namespace asio {
namespace ip {
class address
{
public:
inline address();
inline address(const boost::asio::ip::address_v4& ipv4_address);
inline address(const boost::asio::ip::address_v6& ipv6_address);
inline address(const address& other);
inline address(address&& other);
inline address& operator=(const address& other);
inline address& operator=(address&& other);
inline address& operator=(
const boost::asio::ip::address_v4& ipv4_address);
inline address& operator=(
const boost::asio::ip::address_v6& ipv6_address);
bool is_v4() const
;
bool is_v6() const
;
inline boost::asio::ip::address_v4 to_v4() const;
inline boost::asio::ip::address_v6 to_v6() const;
inline std::string to_string() const;
inline std::string to_string(boost::system::error_code& ec) const;
inline static address from_string(const char* str);
inline static address from_string(
const char* str, boost::system::error_code& ec);
inline static address from_string(const std::string& str);
inline static address from_string(
const std::string& str, boost::system::error_code& ec);
inline bool is_loopback() const;
inline bool is_unspecified() const;
inline bool is_multicast() const;
inline friend bool operator==(const address& a1, const address& a2);
friend bool operator!=(const address& a1, const address& a2)
;
inline friend bool operator<(const address& a1, const address& a2);
friend bool operator>(const address& a1, const address& a2)
;
friend bool operator<=(const address& a1, const address& a2)
;
friend bool operator>=(const address& a1, const address& a2)
;
private:
enum { ipv4, ipv6 } type_;
boost::asio::ip::address_v4 ipv4_address_;
boost::asio::ip::address_v6 ipv6_address_;
};
template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os, const address& addr);
}
}
}
#define BOOST_ASIO_IP_IMPL_ADDRESS_HPP
namespace boost {
namespace asio {
namespace ip {
template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os, const address& addr)
;
}
}
}
#define BOOST_ASIO_IP_IMPL_ADDRESS_IPP
namespace boost {
namespace asio {
namespace ip {
bool address::is_loopback() const
{
return (type_ == ipv4)
? ipv4_address_.is_loopback()
: ipv6_address_.is_loopback();
}
bool address::is_unspecified() const
{
return (type_ == ipv4)
? ipv4_address_.is_unspecified()
: ipv6_address_.is_unspecified();
}
bool address::is_multicast() const
{
return (type_ == ipv4)
? ipv4_address_.is_multicast()
: ipv6_address_.is_multicast();
}
bool operator==(const address& a1, const address& a2)
;
bool operator<(const address& a1, const address& a2)
;
}
}
}
#define BOOST_ASIO_IP_BASIC_ENDPOINT_HPP
#define BOOST_ASIO_IP_DETAIL_ENDPOINT_HPP
namespace boost {
namespace asio {
namespace ip {
namespace detail {
class endpoint
{
public:
inline endpoint();
inline endpoint(int family, unsigned short port_num);
inline endpoint(const boost::asio::ip::address& addr,
unsigned short port_num);
endpoint(const endpoint& other)
;
endpoint& operator=(const endpoint& other)
;
boost::asio::detail::socket_addr_type* data()
;
const boost::asio::detail::socket_addr_type* data() const
;
std::size_t size() const
;
inline void resize(std::size_t new_size);
std::size_t capacity() const
;
inline unsigned short port() const;
inline void port(unsigned short port_num);
inline boost::asio::ip::address address() const;
inline void address(const boost::asio::ip::address& addr);
inline friend bool operator==(
const endpoint& e1, const endpoint& e2);
inline friend bool operator<(
const endpoint& e1, const endpoint& e2);
bool is_v4() const
;
inline std::string to_string(boost::system::error_code& ec) const;
private:
union data_union
{
boost::asio::detail::socket_addr_type base;
boost::asio::detail::sockaddr_in4_type v4;
boost::asio::detail::sockaddr_in6_type v6;
} data_;
};
}
}
}
}
#define BOOST_ASIO_IP_DETAIL_IMPL_ENDPOINT_IPP
namespace boost {
namespace asio {
namespace ip {
namespace detail {
bool operator==(const endpoint& e1, const endpoint& e2)
;
bool operator<(const endpoint& e1, const endpoint& e2)
;
}
}
}
}
namespace boost {
namespace asio {
namespace ip {
template <typename InternetProtocol>
class basic_endpoint
{
public:
typedef InternetProtocol protocol_type;
typedef boost::asio::detail::socket_addr_type data_type;
basic_endpoint()
;
basic_endpoint(const InternetProtocol& internet_protocol,
unsigned short port_num)
;
basic_endpoint(const boost::asio::ip::address& addr, unsigned short port_num)
;
basic_endpoint(const basic_endpoint& other)
;
basic_endpoint(basic_endpoint&& other)
;
basic_endpoint& operator=(const basic_endpoint& other)
;
basic_endpoint& operator=(basic_endpoint&& other)
;
protocol_type protocol() const
;
data_type* data()
;
const data_type* data() const
;
std::size_t size() const
;
void resize(std::size_t new_size)
;
std::size_t capacity() const
;
unsigned short port() const
;
void port(unsigned short port_num)
;
boost::asio::ip::address address() const
;
void address(const boost::asio::ip::address& addr)
;
friend bool operator==(const basic_endpoint<InternetProtocol>& e1,
const basic_endpoint<InternetProtocol>& e2)
;
friend bool operator!=(const basic_endpoint<InternetProtocol>& e1,
const basic_endpoint<InternetProtocol>& e2)
;
friend bool operator<(const basic_endpoint<InternetProtocol>& e1,
const basic_endpoint<InternetProtocol>& e2)
;
friend bool operator>(const basic_endpoint<InternetProtocol>& e1,
const basic_endpoint<InternetProtocol>& e2)
;
friend bool operator<=(const basic_endpoint<InternetProtocol>& e1,
const basic_endpoint<InternetProtocol>& e2)
;
friend bool operator>=(const basic_endpoint<InternetProtocol>& e1,
const basic_endpoint<InternetProtocol>& e2)
;
private:
boost::asio::ip::detail::endpoint impl_;
};
template <typename Elem, typename Traits, typename InternetProtocol>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os,
const basic_endpoint<InternetProtocol>& endpoint);
}
}
}
#define BOOST_ASIO_IP_IMPL_BASIC_ENDPOINT_HPP
namespace boost {
namespace asio {
namespace ip {
template <typename Elem, typename Traits, typename InternetProtocol>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os,
const basic_endpoint<InternetProtocol>& endpoint)
;
}
}
}
#define BOOST_ASIO_IP_BASIC_RESOLVER_HPP
#define BOOST_ASIO_IP_BASIC_RESOLVER_ITERATOR_HPP
#define BOOST_ASIO_IP_BASIC_RESOLVER_ENTRY_HPP
namespace boost {
namespace asio {
namespace ip {
template <typename InternetProtocol>
class basic_resolver_entry
{
public:
typedef InternetProtocol protocol_type;
typedef typename InternetProtocol::endpoint endpoint_type;
basic_resolver_entry()
;
basic_resolver_entry(const endpoint_type& ep,
const std::string& host, const std::string& service)
;
endpoint_type endpoint() const
;
operator endpoint_type() const
;
std::string host_name() const
;
std::string service_name() const
;
private:
endpoint_type endpoint_;
std::string host_name_;
std::string service_name_;
};
}
}
}
namespace boost {
namespace asio {
namespace ip {
template <typename InternetProtocol>
class basic_resolver_iterator
{
public:
typedef std::ptrdiff_t difference_type;
typedef basic_resolver_entry<InternetProtocol> value_type;
typedef const basic_resolver_entry<InternetProtocol>* pointer;
typedef const basic_resolver_entry<InternetProtocol>& reference;
typedef std::forward_iterator_tag iterator_category;
basic_resolver_iterator()
;
static basic_resolver_iterator create(
boost::asio::detail::addrinfo_type* address_info,
const std::string& host_name, const std::string& service_name)
;
static basic_resolver_iterator create(
const typename InternetProtocol::endpoint& endpoint,
const std::string& host_name, const std::string& service_name)
;
template <typename EndpointIterator>
static basic_resolver_iterator create(
EndpointIterator begin, EndpointIterator end,
const std::string& host_name, const std::string& service_name)
;
const basic_resolver_entry<InternetProtocol>& operator*() const
;
const basic_resolver_entry<InternetProtocol>* operator->() const
;
basic_resolver_iterator& operator++()
;
basic_resolver_iterator operator++(int)
;
friend bool operator==(const basic_resolver_iterator& a,
const basic_resolver_iterator& b)
;
friend bool operator!=(const basic_resolver_iterator& a,
const basic_resolver_iterator& b)
;
private:
void increment()
;
bool equal(const basic_resolver_iterator& other) const
;
const basic_resolver_entry<InternetProtocol>& dereference() const
;
typedef std::vector<basic_resolver_entry<InternetProtocol> > values_type;
boost::asio::detail::shared_ptr<values_type> values_;
std::size_t index_;
};
}
}
}
#define BOOST_ASIO_IP_BASIC_RESOLVER_QUERY_HPP
#define BOOST_ASIO_IP_RESOLVER_QUERY_BASE_HPP
namespace boost {
namespace asio {
namespace ip {
class resolver_query_base
{
public:
enum flags
{
canonical_name = 0x0002,
passive = 0x0001,
numeric_host = 0x0004,
numeric_service = 0x0400,
v4_mapped = 0x0008,
all_matching = 0x0010,
address_configured = 0x0020
};
friend flags operator&(flags x, flags y)
;
friend flags operator|(flags x, flags y)
;
friend flags operator^(flags x, flags y)
;
friend flags operator~(flags x)
;
friend flags& operator&=(flags& x, flags y)
;
friend flags& operator|=(flags& x, flags y)
;
friend flags& operator^=(flags& x, flags y)
;
protected:
~resolver_query_base()
;
};
}
}
}
namespace boost {
namespace asio {
namespace ip {
template <typename InternetProtocol>
class basic_resolver_query
: public resolver_query_base
{
public:
typedef InternetProtocol protocol_type;
basic_resolver_query(const std::string& service,
resolver_query_base::flags resolve_flags = passive | address_configured)
;
basic_resolver_query(const protocol_type& protocol,
const std::string& service,
resolver_query_base::flags resolve_flags = passive | address_configured)
;
basic_resolver_query(const std::string& host, const std::string& service,
resolver_query_base::flags resolve_flags = address_configured)
;
basic_resolver_query(const protocol_type& protocol,
const std::string& host, const std::string& service,
resolver_query_base::flags resolve_flags = address_configured)
;
const boost::asio::detail::addrinfo_type& hints() const
;
std::string host_name() const
;
std::string service_name() const
;
private:
boost::asio::detail::addrinfo_type hints_;
std::string host_name_;
std::string service_name_;
};
}
}
}
#define BOOST_ASIO_IP_RESOLVER_SERVICE_HPP
#define BOOST_ASIO_DETAIL_RESOLVER_SERVICE_HPP
#define BOOST_ASIO_DETAIL_RESOLVER_ENDPOINT_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Protocol, typename Handler>
class resolve_endpoint_op : public operation
{
public:
struct ptr { Handler* h; void* v; resolve_endpoint_op* p; ~ptr() ; void reset() ; };
typedef typename Protocol::endpoint endpoint_type;
typedef boost::asio::ip::basic_resolver_iterator<Protocol> iterator_type;
resolve_endpoint_op(socket_ops::weak_cancel_token_type cancel_token,
const endpoint_type& endpoint, io_service_impl& ios, Handler& handler)
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
socket_ops::weak_cancel_token_type cancel_token_;
endpoint_type endpoint_;
io_service_impl& io_service_impl_;
Handler handler_;
boost::system::error_code ec_;
iterator_type iter_;
};
}
}
}
#define BOOST_ASIO_DETAIL_RESOLVE_OP_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Protocol, typename Handler>
class resolve_op : public operation
{
public:
struct ptr { Handler* h; void* v; resolve_op* p; ~ptr() ; void reset() ; };
typedef boost::asio::ip::basic_resolver_query<Protocol> query_type;
typedef boost::asio::ip::basic_resolver_iterator<Protocol> iterator_type;
resolve_op(socket_ops::weak_cancel_token_type cancel_token,
const query_type& query, io_service_impl& ios, Handler& handler)
;
~resolve_op()
;
static void do_complete(io_service_impl* owner, operation* base,
const boost::system::error_code& ,
std::size_t )
;
private:
socket_ops::weak_cancel_token_type cancel_token_;
query_type query_;
io_service_impl& io_service_impl_;
Handler handler_;
boost::system::error_code ec_;
boost::asio::detail::addrinfo_type* addrinfo_;
};
}
}
}
#define BOOST_ASIO_DETAIL_RESOLVER_SERVICE_BASE_HPP
#define BOOST_ASIO_DETAIL_THREAD_HPP
#define BOOST_ASIO_DETAIL_POSIX_THREAD_HPP
namespace boost {
namespace asio {
namespace detail {
extern "C"
{
inline void* boost_asio_detail_posix_thread_function(void* arg);
}
class posix_thread
: private noncopyable
{
public:
template <typename Function>
posix_thread(Function f, unsigned int = 0)
;
inline ~posix_thread();
inline void join();
private:
friend void* boost_asio_detail_posix_thread_function(void* arg);
class func_base
{
public:
virtual ~func_base() ;
virtual void run() = 0;
};
struct auto_func_base_ptr
{
func_base* ptr;
~auto_func_base_ptr() ;
};
template <typename Function>
class func
: public func_base
{
public:
func(Function f)
;
virtual void run()
;
private:
Function f_;
};
inline void start_thread(func_base* arg);
::pthread_t thread_;
bool joined_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_POSIX_THREAD_IPP
namespace boost {
namespace asio {
namespace detail {
void* boost_asio_detail_posix_thread_function(void* arg)
;
}
}
}
namespace boost {
namespace asio {
namespace detail {
typedef posix_thread thread;
}
}
}
namespace boost {
namespace asio {
namespace detail {
class resolver_service_base
{
public:
typedef socket_ops::shared_cancel_token_type implementation_type;
inline resolver_service_base(boost::asio::io_service& io_service);
inline ~resolver_service_base();
inline void shutdown_service();
inline void fork_service(
boost::asio::io_service::fork_event fork_ev);
inline void construct(implementation_type& impl);
inline void destroy(implementation_type&);
inline void cancel(implementation_type& impl);
protected:
inline void start_resolve_op(operation* op);
class auto_addrinfo
: private boost::asio::detail::noncopyable
{
public:
explicit auto_addrinfo(boost::asio::detail::addrinfo_type* ai)
;
~auto_addrinfo()
;
operator boost::asio::detail::addrinfo_type*()
;
private:
boost::asio::detail::addrinfo_type* ai_;
};
class work_io_service_runner;
inline void start_work_thread();
io_service_impl& io_service_impl_;
private:
boost::asio::detail::mutex mutex_;
boost::asio::detail::scoped_ptr<boost::asio::io_service> work_io_service_;
io_service_impl& work_io_service_impl_;
boost::asio::detail::scoped_ptr<boost::asio::io_service::work> work_;
boost::asio::detail::scoped_ptr<boost::asio::detail::thread> work_thread_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_RESOLVER_SERVICE_BASE_IPP
namespace boost {
namespace asio {
namespace detail {
class resolver_service_base::work_io_service_runner
{
public:
work_io_service_runner(boost::asio::io_service& io_service) ;
void operator()() ;
private:
boost::asio::io_service& io_service_;
};
}
}
}
namespace boost {
namespace asio {
namespace detail {
template <typename Protocol>
class resolver_service : public resolver_service_base
{
public:
typedef socket_ops::shared_cancel_token_type implementation_type;
typedef typename Protocol::endpoint endpoint_type;
typedef boost::asio::ip::basic_resolver_query<Protocol> query_type;
typedef boost::asio::ip::basic_resolver_iterator<Protocol> iterator_type;
resolver_service(boost::asio::io_service& io_service)
;
iterator_type resolve(implementation_type&, const query_type& query,
boost::system::error_code& ec)
;
template <typename Handler>
void async_resolve(implementation_type& impl,
const query_type& query, Handler& handler)
;
iterator_type resolve(implementation_type&,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
template <typename Handler>
void async_resolve(implementation_type& impl,
const endpoint_type& endpoint, Handler& handler)
;
};
}
}
}
namespace boost {
namespace asio {
namespace ip {
template <typename InternetProtocol>
class resolver_service
: public boost::asio::detail::service_base<
resolver_service<InternetProtocol> >
{
public:
typedef InternetProtocol protocol_type;
typedef typename InternetProtocol::endpoint endpoint_type;
typedef basic_resolver_query<InternetProtocol> query_type;
typedef basic_resolver_iterator<InternetProtocol> iterator_type;
private:
typedef boost::asio::detail::resolver_service<InternetProtocol>
service_impl_type;
public:
typedef typename service_impl_type::implementation_type implementation_type;
explicit resolver_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void destroy(implementation_type& impl)
;
void cancel(implementation_type& impl)
;
iterator_type resolve(implementation_type& impl, const query_type& query,
boost::system::error_code& ec)
;
template <typename ResolveHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ResolveHandler, void (boost::system::error_code, iterator_type)>::type>::type
async_resolve(implementation_type& impl, const query_type& query,
ResolveHandler&& handler)
;
iterator_type resolve(implementation_type& impl,
const endpoint_type& endpoint, boost::system::error_code& ec)
;
template <typename ResolveHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ResolveHandler, void (boost::system::error_code, iterator_type)>::type>::type
async_resolve(implementation_type& impl, const endpoint_type& endpoint,
ResolveHandler&& handler)
;
private:
void shutdown_service()
;
void fork_service(boost::asio::io_service::fork_event event)
;
service_impl_type service_impl_;
};
}
}
}
namespace boost {
namespace asio {
namespace ip {
template <typename InternetProtocol,
typename ResolverService = resolver_service<InternetProtocol> >
class basic_resolver
: public basic_io_object<ResolverService>
{
public:
typedef InternetProtocol protocol_type;
typedef typename InternetProtocol::endpoint endpoint_type;
typedef basic_resolver_query<InternetProtocol> query;
typedef basic_resolver_iterator<InternetProtocol> iterator;
explicit basic_resolver(boost::asio::io_service& io_service)
;
void cancel()
;
iterator resolve(const query& q)
;
iterator resolve(const query& q, boost::system::error_code& ec)
;
template <typename ResolveHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ResolveHandler, void (boost::system::error_code, iterator)>::type>::type
async_resolve(const query& q,
ResolveHandler&& handler)
;
iterator resolve(const endpoint_type& e)
;
iterator resolve(const endpoint_type& e, boost::system::error_code& ec)
;
template <typename ResolveHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ResolveHandler, void (boost::system::error_code, iterator)>::type>::type
async_resolve(const endpoint_type& e,
ResolveHandler&& handler)
;
};
}
}
}
#define BOOST_ASIO_IP_HOST_NAME_HPP
namespace boost {
namespace asio {
namespace ip {
inline std::string host_name();
inline std::string host_name(boost::system::error_code& ec);
}
}
}
#define BOOST_ASIO_IP_IMPL_HOST_NAME_IPP
namespace boost {
namespace asio {
namespace ip {
std::string host_name()
;
std::string host_name(boost::system::error_code& ec)
;
}
}
}
#define BOOST_ASIO_IP_ICMP_HPP
namespace boost {
namespace asio {
namespace ip {
class icmp
{
public:
typedef basic_endpoint<icmp> endpoint;
static icmp v4()
;
static icmp v6()
;
int type() const
;
int protocol() const
;
int family() const
;
typedef basic_raw_socket<icmp> socket;
typedef basic_resolver<icmp> resolver;
friend bool operator==(const icmp& p1, const icmp& p2)
;
friend bool operator!=(const icmp& p1, const icmp& p2)
;
private:
explicit icmp(int protocol_id, int protocol_family)
;
int protocol_;
int family_;
};
}
}
}
#define BOOST_ASIO_IP_MULTICAST_HPP
#define BOOST_ASIO_IP_DETAIL_SOCKET_OPTION_HPP
namespace boost {
namespace asio {
namespace ip {
namespace detail {
namespace socket_option {
template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
class multicast_enable_loopback
{
public:
typedef int ipv4_value_type;
typedef int ipv6_value_type;
multicast_enable_loopback()
;
explicit multicast_enable_loopback(bool v)
;
multicast_enable_loopback& operator=(bool v)
;
bool value() const
;
operator bool() const
;
bool operator!() const
;
template <typename Protocol>
int level(const Protocol& protocol) const
;
template <typename Protocol>
int name(const Protocol& protocol) const
;
template <typename Protocol>
void* data(const Protocol& protocol)
;
template <typename Protocol>
const void* data(const Protocol& protocol) const
;
template <typename Protocol>
std::size_t size(const Protocol& protocol) const
;
template <typename Protocol>
void resize(const Protocol& protocol, std::size_t s)
;
private:
ipv4_value_type ipv4_value_;
ipv6_value_type ipv6_value_;
};
template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
class unicast_hops
{
public:
unicast_hops()
;
explicit unicast_hops(int v)
;
unicast_hops& operator=(int v)
;
int value() const
;
template <typename Protocol>
int level(const Protocol& protocol) const
;
template <typename Protocol>
int name(const Protocol& protocol) const
;
template <typename Protocol>
int* data(const Protocol&)
;
template <typename Protocol>
const int* data(const Protocol&) const
;
template <typename Protocol>
std::size_t size(const Protocol&) const
;
template <typename Protocol>
void resize(const Protocol&, std::size_t s)
;
private:
int value_;
};
template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
class multicast_hops
{
public:
typedef unsigned char ipv4_value_type;
typedef int ipv6_value_type;
multicast_hops()
;
explicit multicast_hops(int v)
;
multicast_hops& operator=(int v)
;
int value() const
;
template <typename Protocol>
int level(const Protocol& protocol) const
;
template <typename Protocol>
int name(const Protocol& protocol) const
;
template <typename Protocol>
void* data(const Protocol& protocol)
;
template <typename Protocol>
const void* data(const Protocol& protocol) const
;
template <typename Protocol>
std::size_t size(const Protocol& protocol) const
;
template <typename Protocol>
void resize(const Protocol& protocol, std::size_t s)
;
private:
ipv4_value_type ipv4_value_;
ipv6_value_type ipv6_value_;
};
template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
class multicast_request
{
public:
multicast_request()
;
explicit multicast_request(const boost::asio::ip::address& multicast_address)
;
explicit multicast_request(
const boost::asio::ip::address_v4& multicast_address,
const boost::asio::ip::address_v4& network_interface
= boost::asio::ip::address_v4::any())
;
explicit multicast_request(
const boost::asio::ip::address_v6& multicast_address,
unsigned long network_interface = 0)
;
template <typename Protocol>
int level(const Protocol& protocol) const
;
template <typename Protocol>
int name(const Protocol& protocol) const
;
template <typename Protocol>
const void* data(const Protocol& protocol) const
;
template <typename Protocol>
std::size_t size(const Protocol& protocol) const
;
private:
boost::asio::detail::in4_mreq_type ipv4_value_;
boost::asio::detail::in6_mreq_type ipv6_value_;
};
template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
class network_interface
{
public:
network_interface()
;
explicit network_interface(const boost::asio::ip::address_v4& ipv4_interface)
;
explicit network_interface(unsigned int ipv6_interface)
;
template <typename Protocol>
int level(const Protocol& protocol) const
;
template <typename Protocol>
int name(const Protocol& protocol) const
;
template <typename Protocol>
const void* data(const Protocol& protocol) const
;
template <typename Protocol>
std::size_t size(const Protocol& protocol) const
;
private:
boost::asio::detail::in4_addr_type ipv4_value_;
unsigned int ipv6_value_;
};
}
}
}
}
}
namespace boost {
namespace asio {
namespace ip {
namespace multicast {
typedef boost::asio::ip::detail::socket_option::multicast_request<
IPPROTO_IP,
35,
IPPROTO_IPV6,
20> join_group;
typedef boost::asio::ip::detail::socket_option::multicast_request<
IPPROTO_IP,
36,
IPPROTO_IPV6,
21> leave_group;
typedef boost::asio::ip::detail::socket_option::network_interface<
IPPROTO_IP,
32,
IPPROTO_IPV6,
17> outbound_interface;
typedef boost::asio::ip::detail::socket_option::multicast_hops<
IPPROTO_IP,
33,
IPPROTO_IPV6,
18> hops;
typedef boost::asio::ip::detail::socket_option::multicast_enable_loopback<
IPPROTO_IP,
34,
IPPROTO_IPV6,
19> enable_loopback;
}
}
}
}
#define BOOST_ASIO_IP_TCP_HPP
namespace boost {
namespace asio {
namespace ip {
class tcp
{
public:
typedef basic_endpoint<tcp> endpoint;
static tcp v4()
;
static tcp v6()
;
int type() const
;
int protocol() const
;
int family() const
;
typedef basic_stream_socket<tcp> socket;
typedef basic_socket_acceptor<tcp> acceptor;
typedef basic_resolver<tcp> resolver;
typedef basic_socket_iostream<tcp> iostream;
typedef boost::asio::detail::socket_option::boolean<
IPPROTO_TCP, 1> no_delay;
friend bool operator==(const tcp& p1, const tcp& p2)
;
friend bool operator!=(const tcp& p1, const tcp& p2)
;
private:
explicit tcp(int protocol_family)
;
int family_;
};
}
}
}
#define BOOST_ASIO_IP_UDP_HPP
namespace boost {
namespace asio {
namespace ip {
class udp
{
public:
typedef basic_endpoint<udp> endpoint;
static udp v4()
;
static udp v6()
;
int type() const
;
int protocol() const
;
int family() const
;
typedef basic_datagram_socket<udp> socket;
typedef basic_resolver<udp> resolver;
friend bool operator==(const udp& p1, const udp& p2)
;
friend bool operator!=(const udp& p1, const udp& p2)
;
private:
explicit udp(int protocol_family)
;
int family_;
};
}
}
}
#define BOOST_ASIO_IP_UNICAST_HPP
namespace boost {
namespace asio {
namespace ip {
namespace unicast {
typedef boost::asio::ip::detail::socket_option::unicast_hops<
IPPROTO_IP,
2,
IPPROTO_IPV6,
16> hops;
}
}
}
}
#define BOOST_ASIO_IP_V6_ONLY_HPP
namespace boost {
namespace asio {
namespace ip {
typedef boost::asio::detail::socket_option::boolean<
IPPROTO_IPV6, 26> v6_only;
}
}
}
#define BOOST_ASIO_IS_READ_BUFFERED_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Stream>
char is_read_buffered_helper(buffered_stream<Stream>* s);
template <typename Stream>
char is_read_buffered_helper(buffered_read_stream<Stream>* s);
struct is_read_buffered_big_type { char data[10]; };
is_read_buffered_big_type is_read_buffered_helper(...);
}
template <typename Stream>
class is_read_buffered
{
public:
static const bool value = sizeof(detail::is_read_buffered_helper((Stream*)0)) == 1;
};
}
}
#define BOOST_ASIO_IS_WRITE_BUFFERED_HPP
namespace boost {
namespace asio {
namespace detail {
template <typename Stream>
char is_write_buffered_helper(buffered_stream<Stream>* s);
template <typename Stream>
char is_write_buffered_helper(buffered_write_stream<Stream>* s);
struct is_write_buffered_big_type { char data[10]; };
is_write_buffered_big_type is_write_buffered_helper(...);
}
template <typename Stream>
class is_write_buffered
{
public:
static const bool value = sizeof(detail::is_write_buffered_helper((Stream*)0)) == 1;
};
}
}
#define BOOST_ASIO_LOCAL_BASIC_ENDPOINT_HPP
#define BOOST_ASIO_LOCAL_DETAIL_ENDPOINT_HPP
namespace boost {
namespace asio {
namespace local {
namespace detail {
class endpoint
{
public:
inline endpoint();
inline endpoint(const char* path_name);
inline endpoint(const std::string& path_name);
endpoint(const endpoint& other)
;
endpoint& operator=(const endpoint& other)
;
boost::asio::detail::socket_addr_type* data()
;
const boost::asio::detail::socket_addr_type* data() const
;
std::size_t size() const
;
inline void resize(std::size_t size);
std::size_t capacity() const
;
inline std::string path() const;
inline void path(const char* p);
inline void path(const std::string& p);
inline friend bool operator==(
const endpoint& e1, const endpoint& e2);
inline friend bool operator<(
const endpoint& e1, const endpoint& e2);
private:
union data_union
{
boost::asio::detail::socket_addr_type base;
boost::asio::detail::sockaddr_un_type local;
} data_;
std::size_t path_length_;
inline void init(const char* path, std::size_t path_length);
};
}
}
}
}
#define BOOST_ASIO_LOCAL_DETAIL_IMPL_ENDPOINT_IPP
namespace boost {
namespace asio {
namespace local {
namespace detail {
bool operator==(const endpoint& e1, const endpoint& e2)
;
bool operator<(const endpoint& e1, const endpoint& e2)
;
}
}
}
}
namespace boost {
namespace asio {
namespace local {
template <typename Protocol>
class basic_endpoint
{
public:
typedef Protocol protocol_type;
typedef boost::asio::detail::socket_addr_type data_type;
basic_endpoint()
;
basic_endpoint(const char* path_name)
;
basic_endpoint(const std::string& path_name)
;
basic_endpoint(const basic_endpoint& other)
;
basic_endpoint(basic_endpoint&& other)
;
basic_endpoint& operator=(const basic_endpoint& other)
;
basic_endpoint& operator=(basic_endpoint&& other)
;
protocol_type protocol() const
;
data_type* data()
;
const data_type* data() const
;
std::size_t size() const
;
void resize(std::size_t new_size)
;
std::size_t capacity() const
;
std::string path() const
;
void path(const char* p)
;
void path(const std::string& p)
;
friend bool operator==(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator!=(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator<(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator>(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator<=(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
friend bool operator>=(const basic_endpoint<Protocol>& e1,
const basic_endpoint<Protocol>& e2)
;
private:
boost::asio::local::detail::endpoint impl_;
};
template <typename Elem, typename Traits, typename Protocol>
std::basic_ostream<Elem, Traits>& operator<<(
std::basic_ostream<Elem, Traits>& os,
const basic_endpoint<Protocol>& endpoint)
;
}
}
}
#define BOOST_ASIO_LOCAL_CONNECT_PAIR_HPP
namespace boost {
namespace asio {
namespace local {
template <typename Protocol, typename SocketService1, typename SocketService2>
void connect_pair(
basic_socket<Protocol, SocketService1>& socket1,
basic_socket<Protocol, SocketService2>& socket2);
template <typename Protocol, typename SocketService1, typename SocketService2>
boost::system::error_code connect_pair(
basic_socket<Protocol, SocketService1>& socket1,
basic_socket<Protocol, SocketService2>& socket2,
boost::system::error_code& ec);
template <typename Protocol, typename SocketService1, typename SocketService2>
void connect_pair(
basic_socket<Protocol, SocketService1>& socket1,
basic_socket<Protocol, SocketService2>& socket2)
;
template <typename Protocol, typename SocketService1, typename SocketService2>
boost::system::error_code connect_pair(
basic_socket<Protocol, SocketService1>& socket1,
basic_socket<Protocol, SocketService2>& socket2,
boost::system::error_code& ec)
;
}
}
}
#define BOOST_ASIO_LOCAL_DATAGRAM_PROTOCOL_HPP
namespace boost {
namespace asio {
namespace local {
class datagram_protocol
{
public:
int type() const
;
int protocol() const
;
int family() const
;
typedef basic_endpoint<datagram_protocol> endpoint;
typedef basic_datagram_socket<datagram_protocol> socket;
};
}
}
}
#define BOOST_ASIO_LOCAL_STREAM_PROTOCOL_HPP
namespace boost {
namespace asio {
namespace local {
class stream_protocol
{
public:
int type() const
;
int protocol() const
;
int family() const
;
typedef basic_endpoint<stream_protocol> endpoint;
typedef basic_stream_socket<stream_protocol> socket;
typedef basic_socket_acceptor<stream_protocol> acceptor;
typedef basic_socket_iostream<stream_protocol> iostream;
};
}
}
}
#define BOOST_ASIO_PLACEHOLDERS_HPP
#define BOOST_BIND_ARG_HPP_INCLUDED
#define BOOST_IS_PLACEHOLDER_HPP_INCLUDED
namespace boost
{
template< class T > struct is_placeholder
{
enum _vt { value = 0 };
};
}
namespace boost
{
template< int I > struct arg
{
arg()
;
template< class T > arg( T const & )
;
};
template< int I > bool operator==( arg<I> const &, arg<I> const & )
;
template< int I > struct is_placeholder< arg<I> >
{
enum _vt { value = I };
};
template< int I > struct is_placeholder< arg<I> (*) () >
{
enum _vt { value = I };
};
}
namespace boost {
namespace asio {
namespace placeholders {
boost::arg<1> error()
;
boost::arg<2> bytes_transferred()
;
boost::arg<2> iterator()
;
boost::arg<2> signal_number()
;
}
}
}
#define BOOST_ASIO_POSIX_BASIC_DESCRIPTOR_HPP
#define BOOST_ASIO_POSIX_DESCRIPTOR_BASE_HPP
namespace boost {
namespace asio {
namespace posix {
class descriptor_base
{
public:
typedef boost::asio::detail::io_control::non_blocking_io non_blocking_io;
typedef boost::asio::detail::io_control::bytes_readable bytes_readable;
protected:
~descriptor_base()
;
};
}
}
}
namespace boost {
namespace asio {
namespace posix {
template <typename DescriptorService>
class basic_descriptor
: public basic_io_object<DescriptorService>,
public descriptor_base
{
public:
typedef typename DescriptorService::native_handle_type native_type;
typedef typename DescriptorService::native_handle_type native_handle_type;
typedef basic_descriptor<DescriptorService> lowest_layer_type;
explicit basic_descriptor(boost::asio::io_service& io_service)
;
basic_descriptor(boost::asio::io_service& io_service,
const native_handle_type& native_descriptor)
;
basic_descriptor(basic_descriptor&& other)
;
basic_descriptor& operator=(basic_descriptor&& other)
;
lowest_layer_type& lowest_layer()
;
const lowest_layer_type& lowest_layer() const
;
void assign(const native_handle_type& native_descriptor)
;
boost::system::error_code assign(const native_handle_type& native_descriptor,
boost::system::error_code& ec)
;
bool is_open() const
;
void close()
;
boost::system::error_code close(boost::system::error_code& ec)
;
native_type native()
;
native_handle_type native_handle()
;
native_handle_type release()
;
void cancel()
;
boost::system::error_code cancel(boost::system::error_code& ec)
;
template <typename IoControlCommand>
void io_control(IoControlCommand& command)
;
template <typename IoControlCommand>
boost::system::error_code io_control(IoControlCommand& command,
boost::system::error_code& ec)
;
bool non_blocking() const
;
void non_blocking(bool mode)
;
boost::system::error_code non_blocking(
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking() const
;
void native_non_blocking(bool mode)
;
boost::system::error_code native_non_blocking(
bool mode, boost::system::error_code& ec)
;
protected:
~basic_descriptor()
;
};
}
}
}
#define BOOST_ASIO_POSIX_BASIC_STREAM_DESCRIPTOR_HPP
#define BOOST_ASIO_POSIX_STREAM_DESCRIPTOR_SERVICE_HPP
namespace boost {
namespace asio {
namespace posix {
class stream_descriptor_service
: public boost::asio::detail::service_base<stream_descriptor_service>
{
public:
private:
typedef detail::reactive_descriptor_service service_impl_type;
public:
typedef service_impl_type::implementation_type implementation_type;
typedef service_impl_type::native_handle_type native_type;
typedef service_impl_type::native_handle_type native_handle_type;
explicit stream_descriptor_service(boost::asio::io_service& io_service)
;
void construct(implementation_type& impl)
;
void move_construct(implementation_type& impl,
implementation_type& other_impl)
;
void move_assign(implementation_type& impl,
stream_descriptor_service& other_service,
implementation_type& other_impl)
;
void destroy(implementation_type& impl)
;
boost::system::error_code assign(implementation_type& impl,
const native_handle_type& native_descriptor,
boost::system::error_code& ec)
;
bool is_open(const implementation_type& impl) const
;
boost::system::error_code close(implementation_type& impl,
boost::system::error_code& ec)
;
native_type native(implementation_type& impl)
;
native_handle_type native_handle(implementation_type& impl)
;
native_handle_type release(implementation_type& impl)
;
boost::system::error_code cancel(implementation_type& impl,
boost::system::error_code& ec)
;
template <typename IoControlCommand>
boost::system::error_code io_control(implementation_type& impl,
IoControlCommand& command, boost::system::error_code& ec)
;
bool non_blocking(const implementation_type& impl) const
;
boost::system::error_code non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
bool native_non_blocking(const implementation_type& impl) const
;
boost::system::error_code native_non_blocking(implementation_type& impl,
bool mode, boost::system::error_code& ec)
;
template <typename ConstBufferSequence>
std::size_t write_some(implementation_type& impl,
const ConstBufferSequence& buffers, boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(implementation_type& impl,
const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t read_some(implementation_type& impl,
const MutableBufferSequence& buffers, boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(implementation_type& impl,
const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
private:
void shutdown_service()
;
service_impl_type service_impl_;
};
}
}
}
namespace boost {
namespace asio {
namespace posix {
template <typename StreamDescriptorService = stream_descriptor_service>
class basic_stream_descriptor
: public basic_descriptor<StreamDescriptorService>
{
public:
typedef typename StreamDescriptorService::native_handle_type native_type;
typedef typename StreamDescriptorService::native_handle_type
native_handle_type;
explicit basic_stream_descriptor(boost::asio::io_service& io_service)
;
basic_stream_descriptor(boost::asio::io_service& io_service,
const native_handle_type& native_descriptor)
;
basic_stream_descriptor(basic_stream_descriptor&& other)
;
basic_stream_descriptor& operator=(basic_stream_descriptor&& other)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers)
;
template <typename ConstBufferSequence>
std::size_t write_some(const ConstBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_some(const ConstBufferSequence& buffers,
WriteHandler&& handler)
;
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers)
;
template <typename MutableBufferSequence>
std::size_t read_some(const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_some(const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
};
}
}
}
#define BOOST_ASIO_POSIX_STREAM_DESCRIPTOR_HPP
namespace boost {
namespace asio {
namespace posix {
typedef basic_stream_descriptor<> stream_descriptor;
}
}
}
#define BOOST_ASIO_READ_HPP
namespace boost {
namespace asio {
template <typename SyncReadStream, typename MutableBufferSequence>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers);
template <typename SyncReadStream, typename MutableBufferSequence>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
boost::system::error_code& ec);
template <typename SyncReadStream, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
CompletionCondition completion_condition);
template <typename SyncReadStream, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
CompletionCondition completion_condition, boost::system::error_code& ec);
template <typename SyncReadStream, typename Allocator>
std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b);
template <typename SyncReadStream, typename Allocator>
std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
boost::system::error_code& ec);
template <typename SyncReadStream, typename Allocator,
typename CompletionCondition>
std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition);
template <typename SyncReadStream, typename Allocator,
typename CompletionCondition>
std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition, boost::system::error_code& ec);
template <typename AsyncReadStream, typename MutableBufferSequence,
typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
ReadHandler&& handler);
template <typename AsyncReadStream, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
CompletionCondition completion_condition,
ReadHandler&& handler);
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
ReadHandler&& handler);
template <typename AsyncReadStream, typename Allocator,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition,
ReadHandler&& handler);
}
}
#define BOOST_ASIO_IMPL_READ_HPP
namespace boost {
namespace asio {
template <typename SyncReadStream, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
CompletionCondition completion_condition, boost::system::error_code& ec)
;
template <typename SyncReadStream, typename MutableBufferSequence>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers)
;
template <typename SyncReadStream, typename MutableBufferSequence>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename SyncReadStream, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
CompletionCondition completion_condition)
;
template <typename SyncReadStream, typename Allocator,
typename CompletionCondition>
std::size_t read(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition, boost::system::error_code& ec)
;
template <typename SyncReadStream, typename Allocator>
std::size_t read(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b)
;
template <typename SyncReadStream, typename Allocator>
std::size_t read(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
boost::system::error_code& ec)
;
template <typename SyncReadStream, typename Allocator,
typename CompletionCondition>
std::size_t read(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition)
;
namespace detail
{
template <typename AsyncReadStream, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
class read_op
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_op(AsyncReadStream& stream, const MutableBufferSequence& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_op(const read_op& other)
;
read_op(read_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::asio::detail::consuming_buffers<
mutable_buffer, MutableBufferSequence> buffers_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncReadStream,
typename CompletionCondition, typename ReadHandler>
class read_op<AsyncReadStream, boost::asio::mutable_buffers_1,
CompletionCondition, ReadHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_op(AsyncReadStream& stream,
const boost::asio::mutable_buffers_1& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_op(const read_op& other)
;
read_op(read_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::asio::mutable_buffer buffer_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename Elem,
typename CompletionCondition, typename ReadHandler>
class read_op<AsyncReadStream, boost::array<Elem, 2>,
CompletionCondition, ReadHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_op(AsyncReadStream& stream, const boost::array<Elem, 2>& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_op(const read_op& other)
;
read_op(read_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::array<Elem, 2> buffers_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename Elem,
typename CompletionCondition, typename ReadHandler>
class read_op<AsyncReadStream, std::array<Elem, 2>,
CompletionCondition, ReadHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_op(AsyncReadStream& stream, const std::array<Elem, 2>& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_op(const read_op& other)
;
read_op(read_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
std::array<Elem, 2> buffers_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_op<AsyncReadStream, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_op<AsyncReadStream, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
bool asio_handler_is_continuation(
read_op<AsyncReadStream, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
void asio_handler_invoke(Function& function,
read_op<AsyncReadStream, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_op<AsyncReadStream, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
}
template <typename AsyncReadStream, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
CompletionCondition completion_condition,
ReadHandler&& handler)
;
template <typename AsyncReadStream, typename MutableBufferSequence,
typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
namespace detail
{
template <typename AsyncReadStream, typename Allocator,
typename CompletionCondition, typename ReadHandler>
class read_streambuf_op
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_streambuf_op(AsyncReadStream& stream,
basic_streambuf<Allocator>& streambuf,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_streambuf_op(const read_streambuf_op& other)
;
read_streambuf_op(read_streambuf_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::asio::basic_streambuf<Allocator>& streambuf_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename Allocator,
typename CompletionCondition, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_streambuf_op<AsyncReadStream, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator,
typename CompletionCondition, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_streambuf_op<AsyncReadStream, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator,
typename CompletionCondition, typename ReadHandler>
bool asio_handler_is_continuation(
read_streambuf_op<AsyncReadStream, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream,
typename Allocator, typename CompletionCondition, typename ReadHandler>
void asio_handler_invoke(Function& function,
read_streambuf_op<AsyncReadStream, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream,
typename Allocator, typename CompletionCondition, typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_streambuf_op<AsyncReadStream, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
}
template <typename AsyncReadStream, typename Allocator,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition,
ReadHandler&& handler)
;
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
ReadHandler&& handler)
;
}
}
#define BOOST_ASIO_READ_AT_HPP
namespace boost {
namespace asio {
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers);
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
boost::system::error_code& ec);
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition);
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition, boost::system::error_code& ec);
template <typename SyncRandomAccessReadDevice, typename Allocator>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, basic_streambuf<Allocator>& b);
template <typename SyncRandomAccessReadDevice, typename Allocator>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, basic_streambuf<Allocator>& b,
boost::system::error_code& ec);
template <typename SyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition);
template <typename SyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition, boost::system::error_code& ec);
template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
const MutableBufferSequence& buffers,
ReadHandler&& handler);
template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition,
ReadHandler&& handler);
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
basic_streambuf<Allocator>& b, ReadHandler&& handler);
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d,
uint64_t offset, basic_streambuf<Allocator>& b,
CompletionCondition completion_condition,
ReadHandler&& handler);
}
}
#define BOOST_ASIO_IMPL_READ_AT_HPP
namespace boost {
namespace asio {
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition, boost::system::error_code& ec)
;
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers)
;
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
boost::system::error_code& ec)
;
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition)
;
template <typename SyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition, boost::system::error_code& ec)
;
template <typename SyncRandomAccessReadDevice, typename Allocator>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, boost::asio::basic_streambuf<Allocator>& b)
;
template <typename SyncRandomAccessReadDevice, typename Allocator>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
boost::system::error_code& ec)
;
template <typename SyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition)
;
namespace detail
{
template <typename AsyncRandomAccessReadDevice,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
class read_at_op
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_at_op(AsyncRandomAccessReadDevice& device,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_at_op(const read_at_op& other)
;
read_at_op(read_at_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncRandomAccessReadDevice& device_;
uint64_t offset_;
boost::asio::detail::consuming_buffers<
mutable_buffer, MutableBufferSequence> buffers_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncRandomAccessReadDevice,
typename CompletionCondition, typename ReadHandler>
class read_at_op<AsyncRandomAccessReadDevice,
boost::asio::mutable_buffers_1, CompletionCondition, ReadHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_at_op(AsyncRandomAccessReadDevice& device,
uint64_t offset, const boost::asio::mutable_buffers_1& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_at_op(const read_at_op& other)
;
read_at_op(read_at_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncRandomAccessReadDevice& device_;
uint64_t offset_;
boost::asio::mutable_buffer buffer_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncRandomAccessReadDevice, typename Elem,
typename CompletionCondition, typename ReadHandler>
class read_at_op<AsyncRandomAccessReadDevice, boost::array<Elem, 2>,
CompletionCondition, ReadHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_at_op(AsyncRandomAccessReadDevice& device,
uint64_t offset, const boost::array<Elem, 2>& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_at_op(const read_at_op& other)
;
read_at_op(read_at_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncRandomAccessReadDevice& device_;
uint64_t offset_;
boost::array<Elem, 2> buffers_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncRandomAccessReadDevice, typename Elem,
typename CompletionCondition, typename ReadHandler>
class read_at_op<AsyncRandomAccessReadDevice, std::array<Elem, 2>,
CompletionCondition, ReadHandler>
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_at_op(AsyncRandomAccessReadDevice& device,
uint64_t offset, const std::array<Elem, 2>& buffers,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_at_op(const read_at_op& other)
;
read_at_op(read_at_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncRandomAccessReadDevice& device_;
uint64_t offset_;
std::array<Elem, 2> buffers_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncRandomAccessReadDevice,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncRandomAccessReadDevice,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncRandomAccessReadDevice,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
bool asio_handler_is_continuation(
read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncRandomAccessReadDevice,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
void asio_handler_invoke(Function& function,
read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncRandomAccessReadDevice,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncRandomAccessReadDevice,
typename MutableBufferSequence, typename CompletionCondition,
typename ReadHandler>
read_at_op<AsyncRandomAccessReadDevice,
MutableBufferSequence, CompletionCondition, ReadHandler>
make_read_at_op(AsyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition, ReadHandler handler)
;
}
template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
CompletionCondition completion_condition,
ReadHandler&& handler)
;
template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d,
uint64_t offset, const MutableBufferSequence& buffers,
ReadHandler&& handler)
;
namespace detail
{
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition, typename ReadHandler>
class read_at_streambuf_op
: detail::base_from_completion_cond<CompletionCondition>
{
public:
read_at_streambuf_op(AsyncRandomAccessReadDevice& device,
uint64_t offset, basic_streambuf<Allocator>& streambuf,
CompletionCondition completion_condition, ReadHandler& handler)
;
read_at_streambuf_op(const read_at_streambuf_op& other)
;
read_at_streambuf_op(read_at_streambuf_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncRandomAccessReadDevice& device_;
uint64_t offset_;
boost::asio::basic_streambuf<Allocator>& streambuf_;
int start_;
std::size_t total_transferred_;
ReadHandler handler_;
};
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition, typename ReadHandler>
bool asio_handler_is_continuation(
read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncRandomAccessReadDevice,
typename Allocator, typename CompletionCondition, typename ReadHandler>
void asio_handler_invoke(Function& function,
read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncRandomAccessReadDevice,
typename Allocator, typename CompletionCondition, typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
CompletionCondition, ReadHandler>* this_handler)
;
}
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d,
uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition,
ReadHandler&& handler)
;
template <typename AsyncRandomAccessReadDevice, typename Allocator,
typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_at(AsyncRandomAccessReadDevice& d,
uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
ReadHandler&& handler)
;
}
}
#define BOOST_ASIO_READ_UNTIL_HPP
#define BOOST_ASIO_DETAIL_REGEX_FWD_HPP
#define BOOST_REGEX_FWD_HPP
#define BOOST_REGEX_CONFIG_HPP
#define BOOST_REGEX_USER_CONFIG <boost/regex/user.hpp>
#define BOOST_RE_VERSION 320
#define BOOST_REGEX_CONFIG_CWCHAR_HPP
#undef __need_mbstate_t
#undef __need_wint_t
namespace std{
extern "C"{
}
}
#define BOOST_REGEX_DECL
#define BOOST_LIB_NAME boost_regex
#undef BOOST_LIB_NAME
#define BOOST_REGEX_CALL
#define BOOST_REGEX_CCALL
#define BOOST_REGEX_USE_CPP_LOCALE
#define BOOST_REGEX_MAX_STATE_COUNT 100000000
#define BOOST_REGEX_NOEH_ASSERT(x)
#define BOOST_REGEX_NON_RECURSIVE
#define BOOST_REGEX_BLOCKSIZE 4096
#define BOOST_REGEX_MAX_BLOCKS 1024
#define BOOST_REGEX_MAX_CACHE_BLOCKS 16
namespace boost{ namespace re_detail{
void* get_mem_block();
void put_mem_block(void*);
}}
#define BOOST_REGEX_FWD_HPP_INCLUDED
namespace boost{
template <class charT>
class cpp_regex_traits;
template <class charT>
struct c_regex_traits;
template <class charT>
class w32_regex_traits;
template <class charT, class implementationT = cpp_regex_traits<charT> >
struct regex_traits;
template <class charT, class traits = regex_traits<charT> >
class basic_regex;
typedef basic_regex<char, regex_traits<char> > regex;
typedef basic_regex<wchar_t, regex_traits<wchar_t> > wregex;
}
#define BOOST_REGEX_V4_MATCH_FLAGS
namespace boost{
namespace regex_constants{
typedef enum _match_flags
{
match_default = 0,
match_not_bol = 1,
match_not_eol = match_not_bol << 1,
match_not_bob = match_not_eol << 1,
match_not_eob = match_not_bob << 1,
match_not_bow = match_not_eob << 1,
match_not_eow = match_not_bow << 1,
match_not_dot_newline = match_not_eow << 1,
match_not_dot_null = match_not_dot_newline << 1,
match_prev_avail = match_not_dot_null << 1,
match_init = match_prev_avail << 1,
match_any = match_init << 1,
match_not_null = match_any << 1,
match_continuous = match_not_null << 1,
match_partial = match_continuous << 1,
match_stop = match_partial << 1,
match_not_initial_null = match_stop,
match_all = match_stop << 1,
match_perl = match_all << 1,
match_posix = match_perl << 1,
match_nosubs = match_posix << 1,
match_extra = match_nosubs << 1,
match_single_line = match_extra << 1,
match_unused1 = match_single_line << 1,
match_unused2 = match_unused1 << 1,
match_unused3 = match_unused2 << 1,
match_max = match_unused3,
format_perl = 0,
format_default = 0,
format_sed = match_max << 1,
format_all = format_sed << 1,
format_no_copy = format_all << 1,
format_first_only = format_no_copy << 1,
format_is_if = format_first_only << 1,
format_literal = format_is_if << 1
} match_flags;
typedef match_flags match_flag_type;
match_flags operator&(match_flags m1, match_flags m2)
;
match_flags operator|(match_flags m1, match_flags m2)
;
match_flags operator^(match_flags m1, match_flags m2)
;
match_flags operator~(match_flags m1)
;
match_flags& operator&=(match_flags& m1, match_flags m2)
;
match_flags& operator|=(match_flags& m1, match_flags m2)
;
match_flags& operator^=(match_flags& m1, match_flags m2)
;
}
using regex_constants::match_flag_type;
using regex_constants::match_default;
using regex_constants::match_not_bol;
using regex_constants::match_not_eol;
using regex_constants::match_not_bob;
using regex_constants::match_not_eob;
using regex_constants::match_not_bow;
using regex_constants::match_not_eow;
using regex_constants::match_not_dot_newline;
using regex_constants::match_not_dot_null;
using regex_constants::match_prev_avail;
using regex_constants::match_any;
using regex_constants::match_not_null;
using regex_constants::match_continuous;
using regex_constants::match_partial;
using regex_constants::match_all;
using regex_constants::match_perl;
using regex_constants::match_posix;
using regex_constants::match_nosubs;
using regex_constants::match_extra;
using regex_constants::match_single_line;
using regex_constants::format_all;
using regex_constants::format_sed;
using regex_constants::format_perl;
using regex_constants::format_default;
using regex_constants::format_no_copy;
using regex_constants::format_first_only;
}
namespace boost {
template <class BidiIterator>
struct sub_match;
template <class BidiIterator, class Allocator>
class match_results;
}
namespace boost {
namespace asio {
namespace detail
{
char (&has_result_type_helper(...))[2];
template <typename T>
char has_result_type_helper(T*, typename T::result_type* = 0);
template <typename T>
struct has_result_type
{
enum { value = (sizeof((has_result_type_helper)((T*)(0))) == 1) };
};
}
template <typename T>
struct is_match_condition
{
enum
{
value = boost::asio::is_function<
typename boost::asio::remove_pointer<T>::type>::value
|| detail::has_result_type<T>::value
};
};
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, char delim);
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, char delim,
boost::system::error_code& ec);
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const std::string& delim);
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const std::string& delim,
boost::system::error_code& ec);
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr);
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
boost::system::error_code& ec);
template <typename SyncReadStream, typename Allocator, typename MatchCondition>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, MatchCondition match_condition,
typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
template <typename SyncReadStream, typename Allocator, typename MatchCondition>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
MatchCondition match_condition, boost::system::error_code& ec,
typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
char delim, ReadHandler&& handler);
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const std::string& delim,
ReadHandler&& handler);
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
ReadHandler&& handler);
template <typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
MatchCondition match_condition, ReadHandler&& handler,
typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
}
}
#define BOOST_ASIO_IMPL_READ_UNTIL_HPP
namespace boost {
namespace asio {
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, char delim)
;
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, char delim,
boost::system::error_code& ec)
;
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const std::string& delim)
;
namespace detail
{
template <typename Iterator1, typename Iterator2>
std::pair<Iterator1, bool> partial_search(
Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2)
;
}
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const std::string& delim,
boost::system::error_code& ec)
;
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr)
;
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
boost::system::error_code& ec)
;
template <typename SyncReadStream, typename Allocator, typename MatchCondition>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
MatchCondition match_condition, boost::system::error_code& ec,
typename enable_if<is_match_condition<MatchCondition>::value>::type*)
;
template <typename SyncReadStream, typename Allocator, typename MatchCondition>
std::size_t read_until(SyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, MatchCondition match_condition,
typename enable_if<is_match_condition<MatchCondition>::value>::type*)
;
namespace detail
{
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
class read_until_delim_op
{
public:
read_until_delim_op(AsyncReadStream& stream,
boost::asio::basic_streambuf<Allocator>& streambuf,
char delim, ReadHandler& handler)
;
read_until_delim_op(const read_until_delim_op& other)
;
read_until_delim_op(read_until_delim_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::asio::basic_streambuf<Allocator>& streambuf_;
char delim_;
int start_;
std::size_t search_position_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_until_delim_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_until_delim_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
bool asio_handler_is_continuation(
read_until_delim_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream, typename Allocator,
typename ReadHandler>
void asio_handler_invoke(Function& function,
read_until_delim_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream, typename Allocator,
typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_until_delim_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
}
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, char delim,
ReadHandler&& handler)
;
namespace detail
{
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
class read_until_delim_string_op
{
public:
read_until_delim_string_op(AsyncReadStream& stream,
boost::asio::basic_streambuf<Allocator>& streambuf,
const std::string& delim, ReadHandler& handler)
;
read_until_delim_string_op(const read_until_delim_string_op& other)
;
read_until_delim_string_op(read_until_delim_string_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::asio::basic_streambuf<Allocator>& streambuf_;
std::string delim_;
int start_;
std::size_t search_position_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_until_delim_string_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_until_delim_string_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
bool asio_handler_is_continuation(
read_until_delim_string_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream,
typename Allocator, typename ReadHandler>
void asio_handler_invoke(Function& function,
read_until_delim_string_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream,
typename Allocator, typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_until_delim_string_op<AsyncReadStream,
Allocator, ReadHandler>* this_handler)
;
}
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const std::string& delim,
ReadHandler&& handler)
;
namespace detail
{
template <typename AsyncReadStream, typename Allocator,
typename RegEx, typename ReadHandler>
class read_until_expr_op
{
public:
read_until_expr_op(AsyncReadStream& stream,
boost::asio::basic_streambuf<Allocator>& streambuf,
const boost::regex& expr, ReadHandler& handler)
;
read_until_expr_op(const read_until_expr_op& other)
;
read_until_expr_op(read_until_expr_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::asio::basic_streambuf<Allocator>& streambuf_;
RegEx expr_;
int start_;
std::size_t search_position_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename Allocator,
typename RegEx, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_until_expr_op<AsyncReadStream,
Allocator, RegEx, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator,
typename RegEx, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_until_expr_op<AsyncReadStream,
Allocator, RegEx, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator,
typename RegEx, typename ReadHandler>
bool asio_handler_is_continuation(
read_until_expr_op<AsyncReadStream,
Allocator, RegEx, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream, typename Allocator,
typename RegEx, typename ReadHandler>
void asio_handler_invoke(Function& function,
read_until_expr_op<AsyncReadStream,
Allocator, RegEx, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream, typename Allocator,
typename RegEx, typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_until_expr_op<AsyncReadStream,
Allocator, RegEx, ReadHandler>* this_handler)
;
}
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
ReadHandler&& handler)
;
namespace detail
{
template <typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
class read_until_match_op
{
public:
read_until_match_op(AsyncReadStream& stream,
boost::asio::basic_streambuf<Allocator>& streambuf,
MatchCondition match_condition, ReadHandler& handler)
;
read_until_match_op(const read_until_match_op& other)
;
read_until_match_op(read_until_match_op&& other)
;
void operator()(const boost::system::error_code& ec,
std::size_t bytes_transferred, int start = 0)
;
AsyncReadStream& stream_;
boost::asio::basic_streambuf<Allocator>& streambuf_;
MatchCondition match_condition_;
int start_;
std::size_t search_position_;
ReadHandler handler_;
};
template <typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
void* asio_handler_allocate(std::size_t size,
read_until_match_op<AsyncReadStream,
Allocator, MatchCondition, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
void asio_handler_deallocate(void* pointer, std::size_t size,
read_until_match_op<AsyncReadStream,
Allocator, MatchCondition, ReadHandler>* this_handler)
;
template <typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
bool asio_handler_is_continuation(
read_until_match_op<AsyncReadStream,
Allocator, MatchCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
void asio_handler_invoke(Function& function,
read_until_match_op<AsyncReadStream,
Allocator, MatchCondition, ReadHandler>* this_handler)
;
template <typename Function, typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
void asio_handler_invoke(const Function& function,
read_until_match_op<AsyncReadStream,
Allocator, MatchCondition, ReadHandler>* this_handler)
;
}
template <typename AsyncReadStream, typename Allocator,
typename MatchCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<ReadHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_read_until(AsyncReadStream& s,
boost::asio::basic_streambuf<Allocator>& b,
MatchCondition match_condition, ReadHandler&& handler,
typename enable_if<is_match_condition<MatchCondition>::value>::type*)
;
}
}
#define BOOST_ASIO_SERIAL_PORT_HPP
namespace boost {
namespace asio {
typedef basic_serial_port<> serial_port;
}
}
#define BOOST_ASIO_SIGNAL_SET_HPP
namespace boost {
namespace asio {
typedef basic_signal_set<> signal_set;
}
}
#define BOOST_ASIO_STRAND_HPP
#define BOOST_ASIO_DETAIL_STRAND_SERVICE_HPP
namespace boost {
namespace asio {
namespace detail {
class strand_service
: public boost::asio::detail::service_base<strand_service>
{
private:
struct on_do_complete_exit;
struct on_dispatch_exit;
public:
class strand_impl
: public operation
{
public:
strand_impl();
private:
friend class strand_service;
friend struct on_do_complete_exit;
friend struct on_dispatch_exit;
boost::asio::detail::mutex mutex_;
bool locked_;
op_queue<operation> waiting_queue_;
op_queue<operation> ready_queue_;
};
typedef strand_impl* implementation_type;
inline explicit strand_service(boost::asio::io_service& io_service);
inline void shutdown_service();
inline void construct(implementation_type& impl);
template <typename Handler>
void dispatch(implementation_type& impl, Handler& handler);
template <typename Handler>
void post(implementation_type& impl, Handler& handler);
inline bool running_in_this_thread(
const implementation_type& impl) const;
private:
inline bool do_dispatch(implementation_type& impl, operation* op);
inline void do_post(implementation_type& impl,
operation* op, bool is_continuation);
inline static void do_complete(io_service_impl* owner,
operation* base, const boost::system::error_code& ec,
std::size_t bytes_transferred);
io_service_impl& io_service_;
boost::asio::detail::mutex mutex_;
enum { num_implementations = 193 };
scoped_ptr<strand_impl> implementations_[num_implementations];
std::size_t salt_;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_STRAND_SERVICE_HPP
namespace boost {
namespace asio {
namespace detail {
struct strand_service::on_dispatch_exit
{
io_service_impl* io_service_;
strand_impl* impl_;
~on_dispatch_exit()
;
};
}
}
}
#define BOOST_ASIO_DETAIL_IMPL_STRAND_SERVICE_IPP
namespace boost {
namespace asio {
namespace detail {
struct strand_service::on_do_complete_exit
{
io_service_impl* owner_;
strand_impl* impl_;
~on_do_complete_exit()
;
};
bool strand_service::running_in_this_thread(
const implementation_type& impl) const
{
return call_stack<strand_impl>::contains(impl) != 0;
}
bool strand_service::do_dispatch(implementation_type& impl, operation* op)
{
bool can_dispatch = io_service_.can_dispatch();
impl->mutex_.lock();
if (can_dispatch && !impl->locked_)
{
impl->locked_ = true;
impl->mutex_.unlock();
return true;
}
if (impl->locked_)
{
impl->waiting_queue_.push(op);
impl->mutex_.unlock();
}
else
{
impl->locked_ = true;
impl->mutex_.unlock();
impl->ready_queue_.push(op);
io_service_.post_immediate_completion(impl, false);
}
return false;
}
}
}
}
namespace boost {
namespace asio {
class io_service::strand
{
public:
explicit strand(boost::asio::io_service& io_service)
;
~strand()
;
boost::asio::io_service& get_io_service()
;
template <typename CompletionHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<CompletionHandler, void ()>::type>::type
dispatch(CompletionHandler&& handler)
;
template <typename CompletionHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<CompletionHandler, void ()>::type>::type
post(CompletionHandler&& handler)
;
template <typename Handler>
detail::wrapped_handler<strand, Handler, detail::is_continuation_if_running>
wrap(Handler handler)
;
bool running_in_this_thread() const
;
private:
boost::asio::detail::strand_service& service_;
boost::asio::detail::strand_service::implementation_type impl_;
};
typedef boost::asio::io_service::strand strand;
}
}
#define BOOST_ASIO_STREAMBUF_HPP
namespace boost {
namespace asio {
typedef basic_streambuf<> streambuf;
}
}
#define BOOST_ASIO_VERSION_HPP
#define BOOST_ASIO_VERSION 101001
#define BOOST_ASIO_WINDOWS_BASIC_HANDLE_HPP
#define BOOST_ASIO_WINDOWS_BASIC_OBJECT_HANDLE_HPP
#define BOOST_ASIO_WINDOWS_BASIC_RANDOM_ACCESS_HANDLE_HPP
#define BOOST_ASIO_WINDOWS_BASIC_STREAM_HANDLE_HPP
#define BOOST_ASIO_WINDOWS_OBJECT_HANDLE_HPP
#define BOOST_ASIO_WINDOWS_OBJECT_HANDLE_SERVICE_HPP
#define BOOST_ASIO_WINDOWS_OVERLAPPED_PTR_HPP
#define BOOST_ASIO_WINDOWS_RANDOM_ACCESS_HANDLE_HPP
#define BOOST_ASIO_WINDOWS_RANDOM_ACCESS_HANDLE_SERVICE_HPP
#define BOOST_ASIO_WINDOWS_STREAM_HANDLE_HPP
#define BOOST_ASIO_WINDOWS_STREAM_HANDLE_SERVICE_HPP
#define BOOST_ASIO_WRITE_AT_HPP
namespace boost {
namespace asio {
template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
uint64_t offset, const ConstBufferSequence& buffers);
template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
uint64_t offset, const ConstBufferSequence& buffers,
boost::system::error_code& ec);
template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
typename CompletionCondition>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
uint64_t offset, const ConstBufferSequence& buffers,
CompletionCondition completion_condition);
template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
typename CompletionCondition>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
uint64_t offset, const ConstBufferSequence& buffers,
CompletionCondition completion_condition, boost::system::error_code& ec);
template <typename SyncRandomAccessWriteDevice, typename Allocator>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
uint64_t offset, basic_streambuf<Allocator>& b);
template <typename SyncRandomAccessWriteDevice, typename Allocator>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
uint64_t offset, basic_streambuf<Allocator>& b,
boost::system::error_code& ec);
template <typename SyncRandomAccessWriteDevice, typename Allocator,
typename CompletionCondition>
std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
basic_streambuf<Allocator>& b, CompletionCondition completion_condition);
template <typename SyncRandomAccessWriteDevice, typename Allocator,
typename CompletionCondition>
std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
boost::system::error_code& ec);
template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
const ConstBufferSequence& buffers,
WriteHandler&& handler);
template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
typename CompletionCondition, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_at(AsyncRandomAccessWriteDevice& d,
uint64_t offset, const ConstBufferSequence& buffers,
CompletionCondition completion_condition,
WriteHandler&& handler);
template <typename AsyncRandomAccessWriteDevice, typename Allocator,
typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
basic_streambuf<Allocator>& b, WriteHandler&& handler);
template <typename AsyncRandomAccessWriteDevice, typename Allocator,
typename CompletionCondition, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::handler_type<WriteHandler, void (boost::system::error_code, std::size_t)>::type>::type
async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
WriteHandler&& handler);
}
}
int main(int, char**argv)
;
// this should reproduce the crash:
// /usr/lib/creduce/clang_delta --transformation=replace-function-def-with-decl --counter=246 /home/b/src/WebWhois/src/bug/clang_delta_crash_tmp_filehgeaNK.cc