#define __SIGNED_CHARS__ 1 #define __PRAGMA_REDEFINE_EXTNAME 1 #define __DATE__ "Feb 4 2014" #define __TIME__ "11:30:41" #define __STDC__ 1 #define __cilk 200 #define __cplusplus 201103L #define __STDC_HOSTED__ 1 #define _WCHAR_T 1 #define __CHAR16_T_AND_CHAR32_T 1 #define _BOOL 1 #define __ARRAY_OPERATORS 1 #define __RTTI 1 #define __EDG_RUNTIME_USES_NAMESPACES 1 #define __EDG_IA64_ABI 1 #define __LONG_DOUBLE_SIZE__ 80 #define __VARIADIC_TEMPLATES 1 #define __EDG_CONSTEXPR_ENABLED__ 1 #define __EDG__ 1 #define __EDG_VERSION__ 406 #define __EDG_SIZE_TYPE__ unsigned long #define __EDG_PTRDIFF_TYPE__ long #define __DECIMAL_BID_FORMAT__ 1 #define __DEC32_MAX__ 9.999999E96DF #define __DEC64_MAX__ 9.999999999999999E384DD #define __DEC128_MAX__ 9.999999999999999999999999999999999E6144DL #define __DEC32_MANT_DIG__ 7 #define __DEC64_MANT_DIG__ 16 #define __DEC128_MANT_DIG__ 34 #define __DEC32_MIN_EXP__ -94 #define __DEC64_MIN_EXP__ -382 #define __DEC128_MIN_EXP__ -6142 #define __DEC32_MAX_EXP__ 97 #define __DEC64_MAX_EXP__ 385 #define __DEC128_MAX_EXP__ 6145 #define __DEC32_EPSILON__ 1E-6DF #define __DEC64_EPSILON__ 1E-15DD #define __DEC128_EPSILON__ 1E-33DL #define __DEC32_MIN__ 1E-95DF #define __DEC64_MIN__ 1E-383DD #define __DEC128_MIN__ 1E-6143DL #define __DEC32_SUBNORMAL_MIN__ 0.000001E-95DF #define __DEC64_SUBNORMAL_MIN__ 0.000000000000001E-383DD #define __DEC128_SUBNORMAL_MIN__ 0.000000000000000000000000000000001E-6143DL #define __DBL_DIG__ 15 #define __DBL_MAX_10_EXP__ 308 #define __DBL_MIN_10_EXP__ -307 #define __DBL_HAS_DENORM__ 1 #define __FLT_DIG__ 6 #define __FLT_MAX_10_EXP__ 38 #define __FLT_MIN_10_EXP__ -37 #define __FLT_RADIX__ 2 #define __FLT_HAS_DENORM__ 1 #define __INT_MAX__ 2147483647 #define __LDBL_DIG__ 18 #define __LDBL_HAS_INFINITY__ 1 #define __LDBL_HAS_QUIET_NAN__ 1 #define __LDBL_MAX_10_EXP__ 4932 #define __LDBL_MIN_10_EXP__ -4931 #define __LDBL_HAS_DENORM__ 1 #define __DBL_HAS_INFINITY__ 1 #define __DBL_HAS_QUIET_NAN__ 1 #define __DECIMAL_DIG__ 21 #define __FINITE_MATH_ONLY__ 0 #define __FLT_HAS_INFINITY__ 1 #define __FLT_HAS_QUIET_NAN__ 1 #define __SCHAR_MAX__ 127 #define __SHRT_MAX__ 32767 #define __WCHAR_MAX__ 2147483647 #define __CHAR_BIT__ 8 #define __DBL_MANT_DIG__ 53 #define __DBL_MAX_EXP__ 1024 #define __TARG_DBL_MAX_EXP__ 1024 #define __DBL_MIN_EXP__ -1021 #define __FLT_MANT_DIG__ 24 #define __FLT_MAX_EXP__ 128 #define __FLT_MIN_EXP__ -125 #define __LDBL_MANT_DIG__ 64 #define __LDBL_MAX_EXP__ 16384 #define __LDBL_MIN_EXP__ -16381 #define __DBL_DENORM_MIN__ 4.9406564584124654e-324 #define __DBL_EPSILON__ 2.2204460492503131e-16 #define __DBL_MAX__ 1.7976931348623157e+308 #define __DBL_MIN__ 2.2250738585072014e-308 #define __FLT_DENORM_MIN__ 1.40129846e-45F #define __FLT_EPSILON__ 1.19209290e-7F #define __FLT_MAX__ 3.40282347e+38F #define __FLT_MIN__ 1.17549435e-38F #define __LDBL_DENORM_MIN__ 3.64519953188247460253e-4951L #define __LDBL_EPSILON__ 1.08420217248550443401e-19L #define __LDBL_MAX__ 1.18973149535723176502e+4932L #define __LDBL_MIN__ 3.36210314311209350626e-4932L #define __LONG_LONG_MAX__ 0x7fffffffffffffff #define __SIZEOF_DOUBLE__ 8 #define __SIZEOF_FLOAT__ 4 #define __SIZEOF_INT__ 4 #define __SIZEOF_LONG__ 8 #define __SIZEOF_LONG_DOUBLE__ 16 #define __SIZEOF_LONG_LONG__ 8 #define __SIZEOF_POINTER__ 8 #define __SIZEOF_PTRDIFF_T__ 8 #define __SIZEOF_SHORT__ 2 #define __SIZEOF_SIZE_T__ 8 #define __SIZEOF_WCHAR_T__ 4 #define __SIZEOF_WINT_T__ 4 #define __INTMAX_MAX__ 0x7fffffffffffffff #define __UINTMAX_MAX__ 0xffffffffffffffff #define __SIZE_MAX__ 18446744073709551615UL #define __BIGGEST_ALIGNMENT__ 64 #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 __WCHAR_MIN__ (-__WCHAR_MAX__ - 1) #define __WINT_MAX__ 4294967295U #define __WINT_MIN__ 0U #define __SIG_ATOMIC_MAX__ 2147483647 #define __SIG_ATOMIC_MIN__ (-__SIG_ATOMIC_MAX__ - 1) #define __INT8_MAX__ 127 #define __INT16_MAX__ 32767 #define __INT32_MAX__ 2147483647 #define __INT64_MAX__ 9223372036854775807L #define __UINT8_MAX__ 255 #define __UINT16_MAX__ 65535 #define __UINT32_MAX__ 4294967295U #define __UINT64_MAX__ 18446744073709551615UL #define __PTRDIFF_MAX__ 9223372036854775807L #define __INT_LEAST8_MAX__ 127 #define __INT_LEAST16_MAX__ 32767 #define __INT_LEAST32_MAX__ 2147483647 #define __INT_LEAST64_MAX__ 9223372036854775807L #define __UINT_LEAST8_MAX__ 255 #define __UINT_LEAST16_MAX__ 65535 #define __UINT_LEAST32_MAX__ 4294967295U #define __UINT_LEAST64_MAX__ 18446744073709551615UL #define __INT_FAST8_MAX__ 127 #define __INT_FAST16_MAX__ 9223372036854775807L #define __INT_FAST32_MAX__ 9223372036854775807L #define __INT_FAST64_MAX__ 9223372036854775807L #define __UINT_FAST8_MAX__ 255 #define __UINT_FAST16_MAX__ 18446744073709551615UL #define __UINT_FAST32_MAX__ 18446744073709551615UL #define __UINT_FAST64_MAX__ 18446744073709551615UL #define __INTPTR_MAX__ 9223372036854775807L #define __UINTPTR_MAX__ 18446744073709551615UL #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 __FLT_DECIMAL_DIG__ 9 #define __DBL_DECIMAL_DIG__ 17 #define __SIZEOF_INT128__ 16 #define __GXX_RTTI 1 #define __VERSION__ "Intel(R) C++ g++ 4.8 mode" #define __CHAR16_TYPE__ unsigned short #define __CHAR32_TYPE__ unsigned int #define __ATOMIC_RELAXED 0 #define __ATOMIC_CONSUME 1 #define __ATOMIC_ACQUIRE 2 #define __ATOMIC_RELEASE 3 #define __ATOMIC_ACQ_REL 4 #define __ATOMIC_SEQ_CST 5 #define __ATOMIC_HLE_ACQUIRE 65536 #define __ATOMIC_HLE_RELEASE 131072 #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 __INT8_TYPE__ signed char #define __UINT8_TYPE__ unsigned char #define __INT_FAST8_TYPE__ signed char #define __UINT_FAST8_TYPE__ unsigned char #define __INT_LEAST8_TYPE__ signed char #define __UINT_LEAST8_TYPE__ unsigned char #define __INT16_TYPE__ short int #define __UINT16_TYPE__ short unsigned int #define __INT_FAST16_TYPE__ long int #define __UINT_FAST16_TYPE__ long unsigned int #define __INT_LEAST16_TYPE__ short int #define __UINT_LEAST16_TYPE__ short unsigned int #define __INT32_TYPE__ int #define __UINT32_TYPE__ unsigned int #define __INT_FAST32_TYPE__ long int #define __UINT_FAST32_TYPE__ long unsigned int #define __INT_LEAST32_TYPE__ int #define __UINT_LEAST32_TYPE__ unsigned int #define __INT64_TYPE__ long int #define __UINT64_TYPE__ long unsigned int #define __INT_FAST64_TYPE__ long int #define __UINT_FAST64_TYPE__ long unsigned int #define __INT_LEAST64_TYPE__ long int #define __UINT_LEAST64_TYPE__ long unsigned int #define __INTPTR_TYPE__ long int #define __UINTPTR_TYPE__ long unsigned int #define __SIG_ATOMIC_TYPE__ int #define __HONOR_STD 1 #define __ICC 1400 #define __INTEL_COMPILER 1400 #define __INTEL_COMPILER_UPDATE 1 #define __PTRDIFF_TYPE__ long #define __SIZE_TYPE__ unsigned long #define __WCHAR_TYPE__ int #define __WINT_TYPE__ unsigned int #define __INTMAX_TYPE__ long int #define __UINTMAX_TYPE__ long unsigned int #define __INTEL_CXX11_MODE__ 1 #define __LONG_MAX__ 9223372036854775807L #define __QMSPP_ 1 #define __NO_MATH_INLINES 1 #define __NO_STRING_INLINES 1 #define __NO_INLINE__ 1 #define __GNUC_GNU_INLINE__ 1 #define __STRICT_ANSI__ 1 #define __GXX_EXPERIMENTAL_CXX0X__ 1 #define __GNUG__ 4 #define __GNUC__ 4 #define __GNUC_MINOR__ 8 #define __GNUC_PATCHLEVEL__ 0 #define __LP64__ 1 #define _LP64 1 #define _GNU_SOURCE 1 #define __DEPRECATED 1 #define __GXX_WEAK__ 1 #define __GXX_ABI_VERSION 1002 #define __USER_LABEL_PREFIX__ #define __REGISTER_PREFIX__ #define __INTEL_RTTI__ 1 #define __unix__ 1 #define __unix 1 #define __linux__ 1 #define __linux 1 #define __gnu_linux__ 1 #define __ELF__ 1 #define __x86_64 1 #define __x86_64__ 1 #define _MT 1 #define __INTEL_COMPILER_BUILD_DATE 20131008 #define __PIC__ 1 #define __pic__ 1 #define __INTEL_OFFLOAD 1 #define __i686 1 #define __i686__ 1 #define __pentiumpro 1 #define __pentiumpro__ 1 #define __pentium4 1 #define __pentium4__ 1 #define __tune_pentium4__ 1 #define __SSE2__ 1 #define __SSE__ 1 #define __MMX__ 1 #define _REENTRANT 1 #define _REENTRANT 1 #define _REENTRANT 1 #define QT_NO_URL_CAST_FROM_STRING 1 #define QT_NO_INTEGER_EVENT_COORDINATES 1 #define QT_BUILD_QML_LIB 1 #define QT_BUILDING_QT 1 #define QT_NO_CAST_TO_ASCII 1 #define QT_ASCII_CAST_WARNINGS 1 #define QT_USE_QSTRINGBUILDER 1 #define QT_DEPRECATED_WARNINGS 1 #define QT_DISABLE_DEPRECATED_BEFORE 0x050000 #define WTF_EXPORT_PRIVATE #define JS_EXPORT_PRIVATE #define WTFReportAssertionFailure qmlWTFReportAssertionFailure #define WTFReportBacktrace qmlWTFReportBacktrace #define WTFInvokeCrashHook qmlWTFInvokeCrashHook #define ENABLE_LLINT 0 #define ENABLE_DFG_JIT 0 #define ENABLE_DFG_JIT_UTILITY_METHODS 1 #define ENABLE_JIT_CONSTANT_BLINDING 0 #define BUILDING_QT__ 1 #define WTF_USE_UDIS86 0 #define QT_NO_EXCEPTIONS 1 #define QT_NETWORK_LIB 1 #define QT_CORE_LIB 1 #define QQMLLOCALE_H #define QQML_H #define QQMLPRIVATE_H #define QTQMLGLOBAL_H #define QGLOBAL_H #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 __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 #define _GCC_MAX_ALIGN_T #define _GXX_NULLPTR_T #define QT_VERSION_STR "5.2.0" #define QT_VERSION 0x050200 #define QT_VERSION_CHECK(major,minor,patch) ((major<<16)|(minor<<8)|(patch)) #define QT_EDITION QT_EDITION_OPENSOURCE #define QT_LARGEFILE_SUPPORT 64 #define QT_POINTER_SIZE 8 #define QT_REDUCE_RELOCATIONS #define QT_COMPILER_SUPPORTS_SSE2 #define QT_COMPILER_SUPPORTS_SSE3 #define QT_COMPILER_SUPPORTS_SSSE3 #define QT_COMPILER_SUPPORTS_SSE4_1 #define QT_COMPILER_SUPPORTS_SSE4_2 #define QT_COMPILER_SUPPORTS_AVX #define QT_COMPILER_SUPPORTS_AVX2 #define QT_NO_EGL #define QT_NO_EGLFS #define QT_NO_HARFBUZZ #define QT_NO_IMAGEFORMAT_JPEG #define QT_NO_OPENVG #define QT_NO_STYLE_GTK #define QT_NO_TABLET #define QT_NO_XINPUT #define QT_NO_ZLIB #define QT_RUNTIME_XCURSOR #define QT_RUNTIME_XFIXES #define QT_RUNTIME_XINERAMA #define QT_RUNTIME_XRANDR #define QT_SQL_MYSQL #define QT_SQL_TDS #define QT_USE_MATH_H_FLOATS #define QT_VISIBILITY_AVAILABLE #define QT_QPA_DEFAULT_PLATFORM_NAME "xcb" #define QT_SUPPORTS(FEATURE) (!defined(QT_NO_ ## FEATURE)) #define QT_STRINGIFY2(x) #x #define QT_STRINGIFY(x) QT_STRINGIFY2(x) #define QSYSTEMDETECTION_H #define Q_OS_LINUX #define Q_OS_UNIX #define QPROCESSORDETECTION_H #define Q_BIG_ENDIAN __ORDER_BIG_ENDIAN__ #define Q_LITTLE_ENDIAN __ORDER_LITTLE_ENDIAN__ #define Q_PROCESSOR_X86 6 #define Q_PROCESSOR_X86_64 #define Q_BYTE_ORDER Q_LITTLE_ENDIAN #define QCOMPILERDETECTION_H #define Q_CC_GNU #define Q_C_CALLBACKS #define Q_CC_INTEL #define Q_ASSUME_IMPL(expr) __assume(expr) #define Q_UNREACHABLE_IMPL() __builtin_unreachable() #define Q_DECL_EXPORT __attribute__((visibility("default"))) #define Q_DECL_IMPORT __attribute__((visibility("default"))) #define Q_DECL_HIDDEN __attribute__((visibility("hidden"))) #define Q_FUNC_INFO __PRETTY_FUNCTION__ #define Q_ALIGNOF(type) __alignof__(type) #define Q_TYPEOF(expr) __typeof__(expr) #define Q_DECL_DEPRECATED __attribute__ ((__deprecated__)) #define Q_DECL_ALIGN(n) __attribute__((__aligned__(n))) #define Q_DECL_UNUSED __attribute__((__unused__)) #define Q_LIKELY(expr) __builtin_expect(!!(expr), true) #define Q_UNLIKELY(expr) __builtin_expect(!!(expr), false) #define Q_NORETURN __attribute__((__noreturn__)) #define Q_REQUIRED_RESULT __attribute__ ((__warn_unused_result__)) #define Q_PACKED __attribute__ ((__packed__)) #define QT_NO_ARM_EABI #define Q_ALLOC_SIZE(x) __attribute__((alloc_size(x))) #define Q_COMPILER_AUTO_TYPE #define Q_COMPILER_CLASS_ENUM #define Q_COMPILER_DECLTYPE #define Q_COMPILER_DEFAULT_MEMBERS #define Q_COMPILER_DELETE_MEMBERS #define Q_COMPILER_EXTERN_TEMPLATES #define Q_COMPILER_LAMBDA #define Q_COMPILER_RVALUE_REFS #define Q_COMPILER_STATIC_ASSERT #define Q_COMPILER_THREAD_LOCAL #define Q_COMPILER_VARIADIC_MACROS #define Q_COMPILER_ATTRIBUTES #define Q_COMPILER_AUTO_FUNCTION #define Q_COMPILER_NULLPTR #define Q_COMPILER_TEMPLATE_ALIAS #define Q_COMPILER_UNICODE_STRINGS #define Q_COMPILER_VARIADIC_TEMPLATES #define Q_COMPILER_ATOMICS #define Q_COMPILER_INITIALIZER_LISTS #define Q_COMPILER_UNIFORM_INIT #define Q_COMPILER_NOEXCEPT #define Q_COMPILER_CONSTEXPR #define Q_COMPILER_DELEGATING_CONSTRUCTORS #define Q_COMPILER_EXPLICIT_OVERRIDES #define Q_COMPILER_NONSTATIC_MEMBER_INIT #define Q_COMPILER_RAW_STRINGS #define Q_COMPILER_REF_QUALIFIERS #define Q_COMPILER_UNRESTRICTED_UNIONS #define Q_NULLPTR nullptr #define Q_DECL_EQ_DEFAULT = default #define Q_DECL_EQ_DELETE = delete #define Q_COMPILER_DEFAULT_DELETE_MEMBERS #define Q_DECL_CONSTEXPR constexpr #define Q_DECL_OVERRIDE override #define Q_DECL_FINAL final #define Q_DECL_NOEXCEPT noexcept #define Q_DECL_NOEXCEPT_EXPR(x) noexcept(x) #define Q_DECL_NOTHROW Q_DECL_NOEXCEPT #define Q_DECL_VARIABLE_DEPRECATED Q_DECL_DEPRECATED #define Q_DECL_CF_RETURNS_RETAINED #define Q_DECL_NS_RETURNS_AUTORELEASED #define QT_STATIC_CONST static const #define QT_STATIC_CONST_IMPL const #define qMove(x) std::move(x) #define Q_UNREACHABLE() do { Q_ASSERT_X(false, "Q_UNREACHABLE()", "Q_UNREACHABLE was reached"); Q_UNREACHABLE_IMPL(); } while (0) #define Q_ASSUME(Expr) do { const bool valueOfExpression = Expr; Q_ASSERT_X(valueOfExpression, "Q_ASSUME()", "Assumption in Q_ASSUME(\"" #Expr "\") was not correct"); Q_ASSUME_IMPL(valueOfExpression); Q_UNUSED(valueOfExpression); } while (0) #define Q_OF_ELF #define _GLIBCXX_ALGORITHM 1 #define _GLIBCXX_UTILITY 1 #define _CPP_CPPCONFIG_WRAPPER 1 #define _GLIBCXX_CXX_CONFIG_H 1 #define __GLIBCXX__ 20130909 #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) (__builtin_abort()) #define _GLIBCXX_EXTERN_TEMPLATE 1 #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 #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 #define __KERNEL_STRICT_NAMES #define __GNUC_PREREQ(maj,min) ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min)) #define _ISOC95_SOURCE 1 #define _ISOC99_SOURCE 1 #define _ISOC11_SOURCE 1 #define _POSIX_SOURCE 1 #define _POSIX_C_SOURCE 200809L #define _XOPEN_SOURCE 700 #define _XOPEN_SOURCE_EXTENDED 1 #define _LARGEFILE64_SOURCE 1 #define _BSD_SOURCE 1 #define _SVID_SOURCE 1 #define __USE_ISOC11 1 #define __USE_ISOCXX11 1 #define __USE_POSIX 1 #define __USE_POSIX2 1 #define __USE_POSIX199309 1 #define __USE_POSIX199506 1 #define _ATFILE_SOURCE 1 #define __USE_XOPEN 1 #define __USE_XOPEN_EXTENDED 1 #define __USE_UNIX98 1 #define _LARGEFILE_SOURCE 1 #define __USE_XOPEN2K8 1 #define __USE_XOPEN2K8XSI 1 #define __USE_XOPEN2K 1 #define __USE_XOPEN2KXSI 1 #define __USE_ISOC95 1 #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_REENTRANT 1 #define __USE_FORTIFY_LEVEL 0 #define _STDC_PREDEF_H 1 #define __STDC_IEC_559__ 1 #define __STDC_IEC_559_COMPLEX__ 1 #define __STDC_ISO_10646__ 201103L #define __STDC_NO_THREADS__ 1 #define __GNU_LIBRARY__ 6 #define __GLIBC__ 2 #define __GLIBC_MINOR__ 18 #define __GLIBC_PREREQ(maj,min) ((__GLIBC__ << 16) + __GLIBC_MINOR__ >= ((maj) << 16) + (min)) #define _SYS_CDEFS_H 1 #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 __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 #define _GLIBCXX_CPU_DEFINES 1 #define _GLIBCXX_PSEUDO_VISIBILITY(V) #define _GLIBCXX_WEAK_DEFINITION #define _GLIBCXX_FAST_MATH 0 #define __N(msgid) (msgid) #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_SLEEP 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_USLEEP 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_GETTIME_SYSCALL 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_NLS 1 #define _GLIBCXX_USE_RANDOM_TR1 1 #define _GLIBCXX_USE_SC_NPROCESSORS_ONLN 1 #define _GLIBCXX_USE_WCHAR_T 1 #define _GLIBCXX_VERBOSE 1 #define _GLIBCXX_X86_RDRAND 1 #define _GTHREAD_USE_MUTEX_TIMEDLOCK 1 #define _STL_RELOPS_H 1 #define _STL_PAIR_H 1 #define _MOVE_H 1 #define _CONCEPT_CHECK_H 1 #define __glibcxx_function_requires(__VA_ARGS__...) #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) #define _GLIBCXX_TYPE_TRAITS 1 #define _GLIBCXX_HAS_NESTED_TYPE(_NTYPE) template class __has_ ## _NTYPE ## _helper : __sfinae_types { template struct _Wrap_type { }; template static __one __test(_Wrap_type*); template static __two __test(...); public: static constexpr bool value = sizeof(__test<_Tp>(0)) == 1; }; template struct __has_ ## _NTYPE : integral_constant::type>::value> { }; #define _GLIBCXX_MOVE(__val) std::move(__val) #define _GLIBCXX_FORWARD(_Tp,__val) std::forward<_Tp>(__val) #define _INITIALIZER_LIST #define _STL_ALGOBASE_H 1 #define _FUNCTEXCEPT_H 1 #define _EXCEPTION_DEFINES_H 1 #define __try if (true) #define __catch(X) if (false) #define __throw_exception_again #define _CPP_TYPE_TRAITS_H 1 #define _EXT_TYPE_TRAITS 1 #define _EXT_NUMERIC_TRAITS 1 #define _STL_ITERATOR_BASE_TYPES_H 1 #define _STL_ITERATOR_BASE_FUNCS_H 1 #define _GLIBCXX_DEBUG_MACRO_SWITCH_H 1 #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) #define _STL_ITERATOR_H 1 #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_MOVE3(_Tp,_Up,_Vp) std::move(_Tp, _Up, _Vp) #define _GLIBCXX_MOVE_BACKWARD3(_Tp,_Up,_Vp) std::move_backward(_Tp, _Up, _Vp) #define _STL_ALGO_H 1 #define _GLIBCXX_CSTDLIB 1 #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 __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 _BITS_TYPES_H 1 #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 _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 #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)) #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))) #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) #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)) #define __ldiv_t_defined 1 #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 ()) #define _XLOCALE_H 1 #define _SYS_TYPES_H 1 #define __u_char_defined #define __ino_t_defined #define __ino64_t_defined #define __dev_t_defined #define __gid_t_defined #define __mode_t_defined #define __nlink_t_defined #define __uid_t_defined #define __off_t_defined #define __off64_t_defined #define __pid_t_defined #define __id_t_defined #define __ssize_t_defined #define __daddr_t_defined #define __key_t_defined #define __need_clockid_t #define __clock_t_defined 1 #define __time_t_defined 1 #define __clockid_t_defined 1 #define __timer_t_defined 1 #define __useconds_t_defined #define __suseconds_t_defined #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 #define __BIT_TYPES_DEFINED__ 1 #define _SYS_SELECT_H 1 #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 #define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int))) #define __sigset_t_defined #define __timespec_defined 1 #define _STRUCT_TIMEVAL 1 #define __NFDBITS (8 * (int) sizeof (__fd_mask)) #define __FD_ELT(d) ((d) / __NFDBITS) #define __FD_MASK(d) ((__fd_mask) 1 << ((d) % __NFDBITS)) #define __FDS_BITS(set) ((set)->fds_bits) #define FD_SETSIZE __FD_SETSIZE #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) #define _SYS_SYSMACROS_H 1 #define major(dev) gnu_dev_major (dev) #define minor(dev) gnu_dev_minor (dev) #define makedev(maj,min) gnu_dev_makedev (maj, min) #define __blksize_t_defined #define __blkcnt_t_defined #define __fsblkcnt_t_defined #define __fsfilcnt_t_defined #define _BITS_PTHREADTYPES_H 1 #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 #define __have_pthread_attr_t 1 #define __PTHREAD_MUTEX_HAVE_PREV 1 #define __PTHREAD_MUTEX_HAVE_ELISION 1 #define __PTHREAD_RWLOCK_INT_FLAGS_SHARED 1 #define __malloc_and_calloc_defined #define _ALLOCA_H 1 #define alloca(size) __builtin_alloca (size) #define __COMPAR_FN_T #define _GLIBCXX_ALGORITHMFWD_H 1 #define _STL_HEAP_H 1 #define _STL_TEMPBUF_H 1 #define _STL_CONSTRUCT_H 1 #define _NEW #define __EXCEPTION__ #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 #define _EXCEPTION_PTR_H #define _GLIBCXX_NESTED_EXCEPTION_H 1 #define _EXT_ALLOC_TRAITS_H 1 #define _ALLOC_TRAITS_H 1 #define _MEMORYFWD_H 1 #define _PTR_TRAITS_H 1 #define _GLIBCXX_RANDOM 1 #define _MATH_H 1 #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 #define FP_ILOGB0 (-2147483647 - 1) #define FP_ILOGBNAN (-2147483647 - 1) #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 _Mfloat_ float #define _Mlong_double_ long double #define __MATH_DECLARE_LDOUBLE 1 #define FP_NAN 0 #define FP_INFINITE 1 #define FP_ZERO 2 #define FP_SUBNORMAL 3 #define FP_NORMAL 4 #define issignaling(x) (sizeof (x) == sizeof (float) ? __issignalingf (x) : sizeof (x) == sizeof (double) ? __issignaling (x) : __issignalingl (x)) #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 __MATH_H_INCLUDED #define MATH_ERRNO 1 #define MATH_ERREXCEPT 2 #define math_errhandling (MATH_ERRNO | MATH_ERREXCEPT) #define __IMFLONGDOUBLE (__LONG_DOUBLE_SIZE__) #define _LIBIMF_CPP_EXCEPT_SPEC() throw() #define _LIBIMF_DBL_XDBL _LIBIMF_DOUBLE #define __IMFC99MACRO1ARG_ALL(__x__,__func__,__fprefix__,__fsuffix__,__dprefix__,__dsuffix__,__lprefix__,__lsuffix__) (( sizeof( __x__ ) > sizeof( double )) ? __lprefix__ ## __func__ ## __lsuffix__( (long double)(__x__) ) : (( sizeof( __x__ ) == sizeof( float )) ? __fprefix__ ## __func__ ## __fsuffix__( (float)(__x__) ) : __dprefix__ ## __func__ ## __dsuffix__( (double)(__x__) ) ) ) #define __IMFC99MACRO2ARG(__x__,__y__,__func__) ((( sizeof( __x__ ) > sizeof( double )) || ( sizeof( __y__ ) > sizeof( double ))) ? __func__ ## l( (long double)(__x__), (long double)(__y__) ) : ((( sizeof( __x__ ) + sizeof( __y__ )) == (2*sizeof( float ))) ? __func__ ## f( (float)(__x__), (float)(__y__) ) : __func__( (double)(__x__), (double)(__y__) ))) #define _DOMAIN 1 #define _SING 2 #define _OVERFLOW 3 #define _UNDERFLOW 4 #define __exception ____exception #define _LIB_VERSIONIMF_TYPE _LIB_VERSION_TYPE #define _GLIBCXX_CMATH 1 #define _STDIO_H 1 #define __FILE_defined 1 #define ____FILE_defined 1 #define _STDIO_USES_IOSTREAM #define _IO_STDIO_H #define _G_config_h 1 #define ____mbstate_t_defined 1 #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_wint_t wint_t #define __GNUC_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 #define _IO_file_flags _flags #define __HAVE_COLUMN #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_)) #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) #define _IO_PENDING_OUTPUT_COUNT(_fp) ((_fp)->_IO_write_ptr - (_fp)->_IO_write_base) #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) #define _VA_LIST_DEFINED #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 stdin stdin #define stdout stdout #define stderr stderr #define _GLIBCXX_CSTDIO 1 #define _GLIBCXX_STRING 1 #define _STRINGFWD_H 1 #define _CHAR_TRAITS_H 1 #define _GLIBCXX_POSTYPES_H 1 #define _WCHAR_H 1 #define __need___FILE #define __need_FILE #define _BITS_WCHAR_H 1 #define __WCHAR_MAX __WCHAR_MAX__ #define __WCHAR_MIN __WCHAR_MIN__ #define _WINT_T #define __CORRECT_ISO_CPP_WCHAR_H_PROTO #define __mbstate_t_defined 1 #define WCHAR_MIN __WCHAR_MIN #define WCHAR_MAX __WCHAR_MAX #define WEOF (0xffffffffu) #define _GLIBCXX_CWCHAR 1 #define _GLIBCXX_CSTDINT 1 #define __STDC_LIMIT_MACROS #define __STDC_CONSTANT_MACROS #define _STDINT_H 1 #define __uint32_t_defined #define __intptr_t_defined #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 #define _ALLOCATOR_H 1 #define _GLIBCXX_CXX_ALLOCATOR_H 1 #define _NEW_ALLOCATOR_H 1 #define _LOCALE_FWD_H 1 #define _GLIBCXX_CXX_LOCALE_H 1 #define _LOCALE_H 1 #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 #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 #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 ) #define LC_GLOBAL_LOCALE ((__locale_t) -1L) #define _GLIBCXX_CLOCALE 1 #define _GLIBCXX_C_LOCALE_GNU 1 #define _GLIBCXX_NUM_CATEGORIES 6 #define _GLIBCXX_IOSFWD 1 #define _CTYPE_H 1 #define _ISbit(bit) ((bit) < 8 ? ((1 << (bit)) << 8) : ((1 << (bit)) >> 8)) #define __isascii(c) (((c) & ~0x7f) == 0) #define __toascii(c) ((c) & 0x7f) #define __exctype(name) extern int name (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 #define _GLIBCXX_CCTYPE 1 #define _OSTREAM_INSERT_H 1 #define _CXXABI_FORCED_H 1 #define _STL_FUNCTION_H 1 #define _BACKWARD_BINDERS_H 1 #define _GLIBCXX_RANGE_ACCESS_H 1 #define _BASIC_STRING_H 1 #define _GLIBCXX_ATOMICITY_H 1 #define _GLIBCXX_GCC_GTHR_H #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 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 #define __defined_schedparam 1 #define __cpu_set_t_defined #define __CPU_SETSIZE 4096 #define __NCPUBITS (8 * sizeof (__cpu_mask)) #define __CPUELT(cpu) ((cpu) / __NCPUBITS) #define __CPUMASK(cpu) ((__cpu_mask) 1 << ((cpu) % __NCPUBITS)) #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) #define sched_priority __sched_priority #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) #define _TIME_H 1 #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 #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) #define TIME_UTC 1 #define __isleap(year) ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0)) #define _BITS_SETJMP_H 1 #define __WORDSIZE 64 #define __WORDSIZE_TIME64_COMPAT32 1 #define __SYSCALL_WORDSIZE 64 #define PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_JOINABLE #define PTHREAD_CREATE_DETACHED PTHREAD_CREATE_DETACHED #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_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 } } #define PTHREAD_INHERIT_SCHED PTHREAD_INHERIT_SCHED #define PTHREAD_EXPLICIT_SCHED PTHREAD_EXPLICIT_SCHED #define PTHREAD_SCOPE_SYSTEM PTHREAD_SCOPE_SYSTEM #define PTHREAD_SCOPE_PROCESS PTHREAD_SCOPE_PROCESS #define PTHREAD_PROCESS_PRIVATE PTHREAD_PROCESS_PRIVATE #define PTHREAD_PROCESS_SHARED PTHREAD_PROCESS_SHARED #define PTHREAD_COND_INITIALIZER { { 0, 0, 0, 0, 0, (void *) 0, 0, 0 } } #define PTHREAD_CANCEL_ENABLE PTHREAD_CANCEL_ENABLE #define PTHREAD_CANCEL_DISABLE PTHREAD_CANCEL_DISABLE #define PTHREAD_CANCEL_DEFERRED PTHREAD_CANCEL_DEFERRED #define PTHREAD_CANCEL_ASYNCHRONOUS PTHREAD_CANCEL_ASYNCHRONOUS #define PTHREAD_CANCELED ((void *) -1) #define PTHREAD_ONCE_INIT 0 #define PTHREAD_BARRIER_SERIAL_THREAD -1 #define __cleanup_fct_attribute #define pthread_cleanup_push(routine,arg) do { __pthread_unwind_buf_t __cancel_buf; void (*__cancel_routine) (void *) = (routine); void *__cancel_arg = (arg); int __not_first_call = __sigsetjmp ((struct __jmp_buf_tag *) (void *) __cancel_buf.__cancel_jmp_buf, 0); if (__glibc_unlikely (__not_first_call)) { __cancel_routine (__cancel_arg); __pthread_unwind_next (&__cancel_buf); } __pthread_register_cancel (&__cancel_buf); do { #define pthread_cleanup_pop(execute) do { } while (0); } while (0); __pthread_unregister_cancel (&__cancel_buf); if (execute) __cancel_routine (__cancel_arg); } while (0) #define pthread_cleanup_push_defer_np(routine,arg) do { __pthread_unwind_buf_t __cancel_buf; void (*__cancel_routine) (void *) = (routine); void *__cancel_arg = (arg); int __not_first_call = __sigsetjmp ((struct __jmp_buf_tag *) (void *) __cancel_buf.__cancel_jmp_buf, 0); if (__glibc_unlikely (__not_first_call)) { __cancel_routine (__cancel_arg); __pthread_unwind_next (&__cancel_buf); } __pthread_register_cancel_defer (&__cancel_buf); do { #define pthread_cleanup_pop_restore_np(execute) do { } while (0); } while (0); __pthread_unregister_cancel_restore (&__cancel_buf); if (execute) __cancel_routine (__cancel_arg); } while (0) #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) #define GTHR_ACTIVE_PROXY __gthrw_(__pthread_key_create) #define _GLIBCXX_ATOMIC_WORD_H 1 #define _GLIBCXX_READ_MEM_BARRIER __asm __volatile ("":::"memory") #define _GLIBCXX_WRITE_MEM_BARRIER __asm __volatile ("":::"memory") #define _STRING_CONVERSIONS_H 1 #define _ERRNO_H 1 #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 #define errno (*__errno_location ()) #define __error_t_defined 1 #define _GLIBCXX_CERRNO 1 #define _FUNCTIONAL_HASH_H 1 #define _HASH_BYTES_H 1 #define _BASIC_STRING_TCC 1 #define _GLIBCXX_NUMERIC_LIMITS 1 #define __glibcxx_integral_traps true #define _RANDOM_H 1 #define _GLIBCXX_VECTOR 1 #define _STL_UNINITIALIZED_H 1 #define _STL_VECTOR_H 1 #define _STL_BVECTOR_H 1 #define _VECTOR_TCC 1 #define _BITS_OPT_RANDOM_H 1 #define _X86INTRIN_H_INCLUDED #define _IA32INTRIN_H_INCLUDED #define _INCLUDED_IMM #define _INCLUDED_WMM #define _INCLUDED_NMM #define _INCLUDED_SMM #define _TMMINTRIN_H #define _INCLUDED_PMM #define _INCLUDED_EMM #define _MM_SHUFFLE2(x,y) (((x)<<1) | (y)) #define _MM_EMPTY() #define _INCLUDED_MM2 #define _MMINTRIN_H_INCLUDED #define __ICL_INTRINCC #define __ICL_CDECLCC #define __cdecl #define _MMINTRIN_TYPE(X) __declspec(align(X)) __declspec(intrin_type) #define _mm_cvtsi64_m64 _m_from_int64 #define _mm_cvtm64_si64 _m_to_int64 #define _mm_empty _m_empty #define _mm_cvtsi32_si64 _m_from_int #define _mm_cvtsi64_si32 _m_to_int #define _mm_packs_pi16 _m_packsswb #define _mm_packs_pi32 _m_packssdw #define _mm_packs_pu16 _m_packuswb #define _mm_unpackhi_pi8 _m_punpckhbw #define _mm_unpackhi_pi16 _m_punpckhwd #define _mm_unpackhi_pi32 _m_punpckhdq #define _mm_unpacklo_pi8 _m_punpcklbw #define _mm_unpacklo_pi16 _m_punpcklwd #define _mm_unpacklo_pi32 _m_punpckldq #define _mm_add_pi8 _m_paddb #define _mm_add_pi16 _m_paddw #define _mm_add_pi32 _m_paddd #define _mm_adds_pi8 _m_paddsb #define _mm_adds_pi16 _m_paddsw #define _mm_adds_pu8 _m_paddusb #define _mm_adds_pu16 _m_paddusw #define _mm_sub_pi8 _m_psubb #define _mm_sub_pi16 _m_psubw #define _mm_sub_pi32 _m_psubd #define _mm_subs_pi8 _m_psubsb #define _mm_subs_pi16 _m_psubsw #define _mm_subs_pu8 _m_psubusb #define _mm_subs_pu16 _m_psubusw #define _mm_madd_pi16 _m_pmaddwd #define _mm_mulhi_pi16 _m_pmulhw #define _mm_mullo_pi16 _m_pmullw #define _mm_sll_pi16 _m_psllw #define _mm_slli_pi16 _m_psllwi #define _mm_sll_pi32 _m_pslld #define _mm_slli_pi32 _m_pslldi #define _mm_sll_si64 _m_psllq #define _mm_slli_si64 _m_psllqi #define _mm_sra_pi16 _m_psraw #define _mm_srai_pi16 _m_psrawi #define _mm_sra_pi32 _m_psrad #define _mm_srai_pi32 _m_psradi #define _mm_srl_pi16 _m_psrlw #define _mm_srli_pi16 _m_psrlwi #define _mm_srl_pi32 _m_psrld #define _mm_srli_pi32 _m_psrldi #define _mm_srl_si64 _m_psrlq #define _mm_srli_si64 _m_psrlqi #define _mm_and_si64 _m_pand #define _mm_andnot_si64 _m_pandn #define _mm_or_si64 _m_por #define _mm_xor_si64 _m_pxor #define _mm_cmpeq_pi8 _m_pcmpeqb #define _mm_cmpeq_pi16 _m_pcmpeqw #define _mm_cmpeq_pi32 _m_pcmpeqd #define _mm_cmpgt_pi8 _m_pcmpgtb #define _mm_cmpgt_pi16 _m_pcmpgtw #define _mm_cmpgt_pi32 _m_pcmpgtd #define _MM_ALIGN16 __declspec(align(16)) #define _MM_SHUFFLE(fp3,fp2,fp1,fp0) (((fp3) << 6) | ((fp2) << 4) | ((fp1) << 2) | ((fp0))) #define _MM_TRANSPOSE4_PS(row0,row1,row2,row3) { __m128 tmp3, tmp2, tmp1, tmp0; tmp0 = _mm_unpacklo_ps((row0), (row1)); tmp2 = _mm_unpacklo_ps((row2), (row3)); tmp1 = _mm_unpackhi_ps((row0), (row1)); tmp3 = _mm_unpackhi_ps((row2), (row3)); (row0) = _mm_movelh_ps(tmp0, tmp2); (row1) = _mm_movehl_ps(tmp2, tmp0); (row2) = _mm_movelh_ps(tmp1, tmp3); (row3) = _mm_movehl_ps(tmp3, tmp1); } #define _MM_HINT_T0 1 #define _MM_HINT_T1 2 #define _MM_HINT_T2 3 #define _MM_HINT_NTA 0 #define _MM_HINT_ENTA 4 #define _MM_HINT_ET0 5 #define _MM_HINT_ET1 6 #define _MM_HINT_ET2 7 #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 #define _MM_SET_EXCEPTION_STATE(mask) _mm_setcsr((_mm_getcsr() & ~_MM_EXCEPT_MASK) | (mask)) #define _MM_GET_EXCEPTION_STATE() (_mm_getcsr() & _MM_EXCEPT_MASK) #define _MM_SET_EXCEPTION_MASK(mask) _mm_setcsr((_mm_getcsr() & ~_MM_MASK_MASK) | (mask)) #define _MM_GET_EXCEPTION_MASK() (_mm_getcsr() & _MM_MASK_MASK) #define _MM_SET_ROUNDING_MODE(mode) _mm_setcsr((_mm_getcsr() & ~_MM_ROUND_MASK) | (mode)) #define _MM_GET_ROUNDING_MODE() (_mm_getcsr() & _MM_ROUND_MASK) #define _MM_SET_FLUSH_ZERO_MODE(mode) _mm_setcsr((_mm_getcsr() & ~_MM_FLUSH_ZERO_MASK) | (mode)) #define _MM_GET_FLUSH_ZERO_MODE(mode) (_mm_getcsr() & _MM_FLUSH_ZERO_MASK) #define _mm_cvtss_si32 _mm_cvt_ss2si #define _mm_cvtps_pi32 _mm_cvt_ps2pi #define _mm_cvttss_si32 _mm_cvtt_ss2si #define _mm_cvttps_pi32 _mm_cvtt_ps2pi #define _mm_cvtsi32_ss _mm_cvt_si2ss #define _mm_cvtpi32_ps _mm_cvt_pi2ps #define _mm_extract_pi16 _m_pextrw #define _mm_insert_pi16 _m_pinsrw #define _mm_max_pi16 _m_pmaxsw #define _mm_max_pu8 _m_pmaxub #define _mm_min_pi16 _m_pminsw #define _mm_min_pu8 _m_pminub #define _mm_movemask_pi8 _m_pmovmskb #define _mm_mulhi_pu16 _m_pmulhuw #define _mm_shuffle_pi16 _m_pshufw #define _mm_maskmove_si64 _m_maskmovq #define _mm_avg_pu8 _m_pavgb #define _mm_avg_pu16 _m_pavgw #define _mm_sad_pu8 _m_psadbw #define _mm_set1_ps _mm_set_ps1 #define _mm_load1_ps _mm_load_ps1 #define _mm_store1_ps _mm_store_ps1 #define _mm_cvtpi16_ps(a) _mm_cvtpi32_ps( _mm_movelh_ps( _mm_setzero_ps(), _mm_cvtpi32_ps(_mm_setzero_ps(), _mm_unpackhi_pi16( (a), _mm_cmpgt_pi16(_mm_setzero_si64(), (a))))), _mm_unpacklo_pi16((a), _mm_cmpgt_pi16(_mm_setzero_si64(), (a)))) #define _mm_cvtpu16_ps(a) _mm_cvtpi32_ps( _mm_movelh_ps( _mm_setzero_ps(), _mm_cvtpi32_ps(_mm_setzero_ps(), _mm_unpackhi_pi16((a), _mm_setzero_si64()))), _mm_unpacklo_pi16((a), _mm_setzero_si64())) #define _mm_cvtps_pi16(a) _mm_packs_pi32(_mm_cvtps_pi32(a), _mm_cvtps_pi32(_mm_movehl_ps((a), (a)))) #define _mm_cvtpi8_ps(a) _mm_cvtpi16_ps( _mm_unpacklo_pi8((a), _mm_cmpgt_pi8(_mm_setzero_si64(), (a)))) #define _mm_cvtpu8_ps(a) _mm_cvtpu16_ps(_mm_unpacklo_pi8((a), _mm_setzero_si64())) #define _mm_cvtps_pi8(a) _mm_packs_pi16(_mm_cvtps_pi16(a), _mm_setzero_si64()) #define _mm_cvtpi32x2_ps(a,b) _mm_movelh_ps(_mm_cvt_pi2ps(_mm_setzero_ps(), (a)), _mm_cvt_pi2ps(_mm_setzero_ps(), (b))) #define _mm_load_pd1 _mm_load1_pd #define _mm_set_pd1 _mm_set1_pd #define _mm_store_pd1 _mm_store1_pd #define _mm_cvtsi64x_si128 _mm_cvtsi64_si128 #define _mm_cvtsi128_si64x _mm_cvtsi128_si64 #define _mm_cvtsd_si64x _mm_cvtsd_si64 #define _mm_cvttsd_si64x _mm_cvttsd_si64 #define _mm_cvtsi64x_sd _mm_cvtsi64_sd #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) #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) #define _mm_ceil_pd(val) _mm_round_pd((val), _MM_FROUND_CEIL) #define _mm_ceil_sd(dst,val) _mm_round_sd((dst), (val), _MM_FROUND_CEIL) #define _mm_floor_pd(val) _mm_round_pd((val), _MM_FROUND_FLOOR) #define _mm_floor_sd(dst,val) _mm_round_sd((dst), (val), _MM_FROUND_FLOOR) #define _mm_ceil_ps(val) _mm_round_ps((val), _MM_FROUND_CEIL) #define _mm_ceil_ss(dst,val) _mm_round_ss((dst), (val), _MM_FROUND_CEIL) #define _mm_floor_ps(val) _mm_round_ps((val), _MM_FROUND_FLOOR) #define _mm_floor_ss(dst,val) _mm_round_ss((dst), (val), _MM_FROUND_FLOOR) #define _mm_test_all_zeros(mask,val) _mm_testz_si128((mask), (val)) #define _mm_test_all_ones(val) _mm_testc_si128((val), _mm_cmpeq_epi32((val),(val))) #define _mm_test_mix_ones_zeros(mask,val) _mm_testnzc_si128((mask), (val)) #define _MM_MK_INSERTPS_NDX(srcField,dstField,zeroMask) (((srcField)<<6) | ((dstField)<<4) | (zeroMask)) #define _MM_EXTRACT_FLOAT(dest,src,ndx) *((int*)&(dest)) = _mm_extract_ps((src), (ndx)) #define _MM_PICK_OUT_PS(src,num) _mm_insert_ps(_mm_setzero_ps(), (src), _MM_MK_INSERTPS_NDX((num), 0, 0x0e)) #define _MM_ULE_MASK 0x20000 #define _MM_ULE_ON 0x20000 #define _MM_ULE_OFF 0x00000 #define _MM_SET_ULE_MODE(mode) _mm_setcsr((_mm_getcsr() & ~_MM_ULE_MASK) | (mode)) #define _MM_GET_ULE_MODE() (_mm_getcsr() & _MM_ULE_MASK) #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 _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 #define _FEATURE_GENERIC_IA32 0x00000001ULL #define _FEATURE_FPU 0x00000002ULL #define _FEATURE_CMOV 0x00000004ULL #define _FEATURE_MMX 0x00000008ULL #define _FEATURE_FXSAVE 0x00000010ULL #define _FEATURE_SSE 0x00000020ULL #define _FEATURE_SSE2 0x00000040ULL #define _FEATURE_SSE3 0x00000080ULL #define _FEATURE_SSSE3 0x00000100ULL #define _FEATURE_SSE4_1 0x00000200ULL #define _FEATURE_SSE4_2 0x00000400ULL #define _FEATURE_MOVBE 0x00000800ULL #define _FEATURE_POPCNT 0x00001000ULL #define _FEATURE_PCLMULQDQ 0x00002000ULL #define _FEATURE_AES 0x00004000ULL #define _FEATURE_F16C 0x00008000ULL #define _FEATURE_AVX 0x00010000ULL #define _FEATURE_RDRND 0x00020000ULL #define _FEATURE_FMA 0x00040000ULL #define _FEATURE_BMI 0x00080000ULL #define _FEATURE_LZCNT 0x00100000ULL #define _FEATURE_HLE 0x00200000ULL #define _FEATURE_RTM 0x00400000ULL #define _FEATURE_AVX2 0x00800000ULL #define _FEATURE_KNCNI 0x04000000ULL #define _FEATURE_AVX512F 0x08000000ULL #define _FEATURE_ADX 0x10000000ULL #define _FEATURE_RDSEED 0x20000000ULL #define _FEATURE_AVX512ER 0x100000000ULL #define _FEATURE_AVX512PF 0x200000000ULL #define _FEATURE_AVX512CD 0x400000000ULL #define _FEATURE_SHA 0x800000000ULL #define _FEATURE_MPX 0x1000000000ULL #define _mm_idiv_epi32(a,b) _mm_div_epi32((a), (b)) #define _mm256_idiv_epi32(a,b) _mm256_div_epi32((a), (b)) #define _mm_irem_epi32(a,b) _mm_rem_epi32((a), (b)) #define _mm256_irem_epi32(a,b) _mm256_rem_epi32((a), (b)) #define _mm_udiv_epi32(a,b) _mm_div_epu32((a), (b)) #define _mm256_udiv_epi32(a,b) _mm256_div_epu32((a), (b)) #define _mm_urem_epi32(a,b) _mm_rem_epu32((a), (b)) #define _mm256_urem_epi32(a,b) _mm256_rem_epu32((a), (b)) #define _mm256_loadu2_m128(hiaddr,loaddr) _mm256_set_m128(_mm_loadu_ps(hiaddr), _mm_loadu_ps(loaddr)) #define _mm256_loadu2_m128d(hiaddr,loaddr) _mm256_set_m128d(_mm_loadu_pd(hiaddr), _mm_loadu_pd(loaddr)) #define _mm256_loadu2_m128i(hiaddr,loaddr) _mm256_set_m128i(_mm_loadu_si128(hiaddr), _mm_loadu_si128(loaddr)) #define _mm256_storeu2_m128(hiaddr,loaddr,a) do { __m256 _a = (a); _mm_storeu_ps((loaddr), _mm256_castps256_ps128(_a)); _mm_storeu_ps((hiaddr), _mm256_extractf128_ps(_a, 0x1)); } while (0) #define _mm256_storeu2_m128d(hiaddr,loaddr,a) do { __m256d _a = (a); _mm_storeu_pd((loaddr), _mm256_castpd256_pd128(_a)); _mm_storeu_pd((hiaddr), _mm256_extractf128_pd(_a, 0x1)); } while (0) #define _mm256_storeu2_m128i(hiaddr,loaddr,a) do { __m256i _a = (a); _mm_storeu_si128((loaddr), _mm256_castsi256_si128(_a)); _mm_storeu_si128((hiaddr), _mm256_extractf128_si256(_a, 0x1)); } while (0) #define _mm256_ceil_pd(val) _mm256_round_pd((val), _MM_FROUND_CEIL) #define _mm256_floor_pd(val) _mm256_round_pd((val), _MM_FROUND_FLOOR) #define _mm256_ceil_ps(val) _mm256_round_ps((val), _MM_FROUND_CEIL) #define _mm256_floor_ps(val) _mm256_round_ps((val), _MM_FROUND_FLOOR) #define _mm256_set_m128(hi,lo) _mm256_insertf128_ps(_mm256_castps128_ps256(lo), (hi), 0x1) #define _mm256_set_m128d(hi,lo) _mm256_insertf128_pd(_mm256_castpd128_pd256(lo), (hi), 0x1) #define _mm256_set_m128i(hi,lo) _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 0x1) #define _mm256_setr_m128(lo,hi) _mm256_set_m128((hi), (lo)) #define _mm256_setr_m128d(lo,hi) _mm256_set_m128d((hi), (lo)) #define _mm256_setr_m128i(lo,hi) _mm256_set_m128i((hi), (lo)) #define _XCR_XFEATURE_ENABLED_MASK 0 #define _XCR0_X87 (1ULL << 0) #define _XCR0_SSE (1ULL << 1) #define _XCR0_AVX (1ULL << 2) #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) ((unsigned char)(((x) >> 24) & 0xFF)) #define _ZMMINTRIN_H_INCLUDED #define _MM512INTRIN_TYPE(X) _MMINTRIN_TYPE(X) #define _MM_K0_REG (0xffff) #define _MM_SWIZ_REG_DCBA _MM_SWIZ_REG_NONE #define _MM_BROADCAST_16X16 _MM_BROADCAST32_NONE #define _MM_BROADCAST_8X8 _MM_BROADCAST64_NONE #define _MM_HINT_NONE 0x0 #define _MM_HINT_NT 0x1 #define _MM_FIXUP(_NegInf,_Neg,_NegZero,_PosZero,_Pos,_PosInf,_Nan) ((int) (_NegInf) | ((int) (_Neg) << 3) | ((int) (_NegZero) << 6) | ((int) (_PosZero) << 9) | ((int) (_Pos) << 12) | ((int) (_PosInf) << 15) | ((int) (_Nan) << 18)) #define _mm512_mask_mov_epi32(v_old,k1,src) _mm512_mask_swizzle_epi32((v_old), (k1), (src), _MM_SWIZ_REG_NONE) #define _mm512_mask_mov_epi64(v_old,k1,src) _mm512_mask_swizzle_epi64((v_old), (k1), (src), _MM_SWIZ_REG_NONE) #define _mm512_load_si512 _mm512_load_epi32 #define _mm512_store_si512 _mm512_store_epi32 #define _mm512_and_si512 _mm512_and_epi32 #define _mm512_andnot_si512 _mm512_andnot_epi32 #define _mm512_or_si512 _mm512_or_epi32 #define _mm512_xor_si512 _mm512_xor_epi32 #define _MM_CMPINT_GE _MM_CMPINT_NLT #define _MM_CMPINT_GT _MM_CMPINT_NLE #define _mm512_cmpeq_epi32_mask(v1,v2) _mm512_cmp_epi32_mask((v1), (v2), _MM_CMPINT_EQ) #define _mm512_mask_cmpeq_epi32_mask(k1,v1,v2) _mm512_mask_cmp_epi32_mask((k1), (v1), (v2), _MM_CMPINT_EQ) #define _mm512_cmplt_epi32_mask(v1,v2) _mm512_cmp_epi32_mask((v1), (v2), _MM_CMPINT_LT) #define _mm512_mask_cmplt_epi32_mask(k1,v1,v2) _mm512_mask_cmp_epi32_mask((k1), (v1), (v2), _MM_CMPINT_LT) #define _mm512_cmple_epi32_mask(v1,v2) _mm512_cmp_epi32_mask((v1), (v2), _MM_CMPINT_LE) #define _mm512_mask_cmple_epi32_mask(k1,v1,v2) _mm512_mask_cmp_epi32_mask((k1), (v1), (v2), _MM_CMPINT_LE) #define _mm512_cmpneq_epi32_mask(v1,v2) _mm512_cmp_epi32_mask((v1), (v2), _MM_CMPINT_NE) #define _mm512_mask_cmpneq_epi32_mask(k1,v1,v2) _mm512_mask_cmp_epi32_mask((k1), (v1), (v2), _MM_CMPINT_NE) #define _mm512_cmpge_epi32_mask(v1,v2) _mm512_cmp_epi32_mask((v1), (v2), _MM_CMPINT_GE) #define _mm512_mask_cmpge_epi32_mask(k1,v1,v2) _mm512_mask_cmp_epi32_mask((k1), (v1), (v2), _MM_CMPINT_GE) #define _mm512_cmpgt_epi32_mask(v1,v2) _mm512_cmp_epi32_mask((v1), (v2), _MM_CMPINT_GT) #define _mm512_mask_cmpgt_epi32_mask(k1,v1,v2) _mm512_mask_cmp_epi32_mask((k1), (v1), (v2), _MM_CMPINT_GT) #define _mm512_cmpeq_epu32_mask(v1,v2) _mm512_cmp_epu32_mask((v1), (v2), _MM_CMPINT_EQ) #define _mm512_mask_cmpeq_epu32_mask(k1,v1,v2) _mm512_mask_cmp_epu32_mask((k1), (v1), (v2), _MM_CMPINT_EQ) #define _mm512_cmplt_epu32_mask(v1,v2) _mm512_cmp_epu32_mask((v1), (v2), _MM_CMPINT_LT) #define _mm512_mask_cmplt_epu32_mask(k1,v1,v2) _mm512_mask_cmp_epu32_mask((k1), (v1), (v2), _MM_CMPINT_LT) #define _mm512_cmple_epu32_mask(v1,v2) _mm512_cmp_epu32_mask((v1), (v2), _MM_CMPINT_LE) #define _mm512_mask_cmple_epu32_mask(k1,v1,v2) _mm512_mask_cmp_epu32_mask((k1), (v1), (v2), _MM_CMPINT_LE) #define _mm512_cmpneq_epu32_mask(v1,v2) _mm512_cmp_epu32_mask((v1), (v2), _MM_CMPINT_NE) #define _mm512_mask_cmpneq_epu32_mask(k1,v1,v2) _mm512_mask_cmp_epu32_mask((k1), (v1), (v2), _MM_CMPINT_NE) #define _mm512_cmpge_epu32_mask(v1,v2) _mm512_cmp_epu32_mask((v1), (v2), _MM_CMPINT_GE) #define _mm512_mask_cmpge_epu32_mask(k1,v1,v2) _mm512_mask_cmp_epu32_mask((k1), (v1), (v2), _MM_CMPINT_GE) #define _mm512_cmpgt_epu32_mask(v1,v2) _mm512_cmp_epu32_mask((v1), (v2), _MM_CMPINT_GT) #define _mm512_mask_cmpgt_epu32_mask(k1,v1,v2) _mm512_mask_cmp_epu32_mask((k1), (v1), (v2), _MM_CMPINT_GT) #define _mm512_cmpeq_pd_mask(v1,v2) _mm512_cmp_pd_mask((v1), (v2), _CMP_EQ_OQ) #define _mm512_mask_cmpeq_pd_mask(k1,v1,v2) _mm512_mask_cmp_pd_mask((k1), (v1), (v2), _CMP_EQ_OQ) #define _mm512_cmplt_pd_mask(v1,v2) _mm512_cmp_pd_mask((v1), (v2), _CMP_LT_OS) #define _mm512_mask_cmplt_pd_mask(k1,v1,v2) _mm512_mask_cmp_pd_mask((k1), (v1), (v2), _CMP_LT_OS) #define _mm512_cmple_pd_mask(v1,v2) _mm512_cmp_pd_mask((v1), (v2), _CMP_LE_OS) #define _mm512_mask_cmple_pd_mask(k1,v1,v2) _mm512_mask_cmp_pd_mask((k1), (v1), (v2), _CMP_LE_OS) #define _mm512_cmpunord_pd_mask(v1,v2) _mm512_cmp_pd_mask((v1), (v2), _CMP_UNORD_Q) #define _mm512_mask_cmpunord_pd_mask(k1,v1,v2) _mm512_mask_cmp_pd_mask((k1), (v1), (v2), _CMP_UNORD_Q) #define _mm512_cmpneq_pd_mask(v1,v2) _mm512_cmp_pd_mask((v1), (v2), _CMP_NEQ_UQ) #define _mm512_mask_cmpneq_pd_mask(k1,v1,v2) _mm512_mask_cmp_pd_mask((k1), (v1), (v2), _CMP_NEQ_UQ) #define _mm512_cmpnlt_pd_mask(v1,v2) _mm512_cmp_pd_mask((v1), (v2), _CMP_NLT_US) #define _mm512_mask_cmpnlt_pd_mask(k1,v1,v2) _mm512_mask_cmp_pd_mask((k1), (v1), (v2), _CMP_NLT_US) #define _mm512_cmpnle_pd_mask(v1,v2) _mm512_cmp_pd_mask((v1), (v2), _CMP_NLE_US) #define _mm512_mask_cmpnle_pd_mask(k1,v1,v2) _mm512_mask_cmp_pd_mask((k1), (v1), (v2), _CMP_NLE_US) #define _mm512_cmpord_pd_mask(v1,v2) _mm512_cmp_pd_mask((v1), (v2), _CMP_ORD_Q) #define _mm512_mask_cmpord_pd_mask(k1,v1,v2) _mm512_mask_cmp_pd_mask((k1), (v1), (v2), _CMP_ORD_Q) #define _mm512_cmpeq_ps_mask(v1,v2) _mm512_cmp_ps_mask((v1), (v2), _CMP_EQ_OQ) #define _mm512_mask_cmpeq_ps_mask(k1,v1,v2) _mm512_mask_cmp_ps_mask((k1), (v1), (v2), _CMP_EQ_OQ) #define _mm512_cmplt_ps_mask(v1,v2) _mm512_cmp_ps_mask((v1), (v2), _CMP_LT_OS) #define _mm512_mask_cmplt_ps_mask(k1,v1,v2) _mm512_mask_cmp_ps_mask((k1), (v1), (v2), _CMP_LT_OS) #define _mm512_cmple_ps_mask(v1,v2) _mm512_cmp_ps_mask((v1), (v2), _CMP_LE_OS) #define _mm512_mask_cmple_ps_mask(k1,v1,v2) _mm512_mask_cmp_ps_mask((k1), (v1), (v2), _CMP_LE_OS) #define _mm512_cmpunord_ps_mask(v1,v2) _mm512_cmp_ps_mask((v1), (v2), _CMP_UNORD_Q) #define _mm512_mask_cmpunord_ps_mask(k1,v1,v2) _mm512_mask_cmp_ps_mask((k1), (v1), (v2), _CMP_UNORD_Q) #define _mm512_cmpneq_ps_mask(v1,v2) _mm512_cmp_ps_mask((v1), (v2), _CMP_NEQ_UQ) #define _mm512_mask_cmpneq_ps_mask(k1,v1,v2) _mm512_mask_cmp_ps_mask((k1), (v1), (v2), _CMP_NEQ_UQ) #define _mm512_cmpnlt_ps_mask(v1,v2) _mm512_cmp_ps_mask((v1), (v2), _CMP_NLT_US) #define _mm512_mask_cmpnlt_ps_mask(k1,v1,v2) _mm512_mask_cmp_ps_mask((k1), (v1), (v2), _CMP_NLT_US) #define _mm512_cmpnle_ps_mask(v1,v2) _mm512_cmp_ps_mask((v1), (v2), _CMP_NLE_US) #define _mm512_mask_cmpnle_ps_mask(k1,v1,v2) _mm512_mask_cmp_ps_mask((k1), (v1), (v2), _CMP_NLE_US) #define _mm512_cmpord_ps_mask(v1,v2) _mm512_cmp_ps_mask((v1), (v2), _CMP_ORD_Q) #define _mm512_mask_cmpord_ps_mask(k1,v1,v2) _mm512_mask_cmp_ps_mask((k1), (v1), (v2), _CMP_ORD_Q) #define _mm512_cvtpd_pslo(v2) _mm512_cvt_roundpd_pslo((v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_cvtpd_pslo(v1_old,k1,v2) _mm512_mask_cvt_roundpd_pslo((v1_old), (k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_i32gather_epi32(index,addr,scale) _mm512_i32extgather_epi32((index), (addr), _MM_UPCONV_EPI32_NONE, (scale), _MM_HINT_NONE) #define _mm512_mask_i32gather_epi32(v1_old,k1,index,addr,scale) _mm512_mask_i32extgather_epi32((v1_old), (k1), (index), (addr), _MM_UPCONV_EPI32_NONE, (scale), _MM_HINT_NONE) #define _mm512_i32logather_epi64(index,addr,scale) _mm512_i32loextgather_epi64((index), (addr), _MM_UPCONV_EPI64_NONE, (scale), _MM_HINT_NONE) #define _mm512_mask_i32logather_epi64(v1_old,k1,index,addr,scale) _mm512_mask_i32loextgather_epi64((v1_old), (k1), (index), (addr), _MM_UPCONV_EPI64_NONE, (scale), _MM_HINT_NONE) #define _mm512_i32gather_ps(index,addr,scale) _mm512_i32extgather_ps((index), (addr), _MM_UPCONV_PS_NONE, (scale), _MM_HINT_NONE) #define _mm512_mask_i32gather_ps(v1_old,k1,index,addr,scale) _mm512_mask_i32extgather_ps((v1_old), (k1), (index), (addr), _MM_UPCONV_PS_NONE, (scale), _MM_HINT_NONE) #define _mm512_i32logather_pd(index,addr,scale) _mm512_i32loextgather_pd((index), (addr), _MM_UPCONV_PD_NONE, (scale), _MM_HINT_NONE) #define _mm512_mask_i32logather_pd(v1_old,k1,index,addr,scale) _mm512_mask_i32loextgather_pd((v1_old), (k1), (index), (addr), _MM_UPCONV_PD_NONE, (scale), _MM_HINT_NONE) #define _mm512_i64gather_epi32lo(index,addr,scale) _mm512_i64extgather_epi32lo((index), (addr), _MM_UPCONV_EPI32_NONE, (scale), _MM_HINT_NONE) #define _mm512_mask_i64gather_epi32lo(v1_old,k1,index,addr,scale) _mm512_mask_i64extgather_epi32lo((v1_old), (k1), (index), (addr), _MM_UPCONV_EPI32_NONE, (scale), _MM_HINT_NONE) #define _mm512_i64gather_epi64(index,addr,scale) _mm512_i64extgather_epi64((index), (addr), _MM_UPCONV_EPI64_NONE, (scale), _MM_HINT_NONE) #define _mm512_mask_i64gather_epi64(v1_old,k1,index,addr,scale) _mm512_mask_i64extgather_epi64((v1_old), (k1), (index), (addr), _MM_UPCONV_EPI64_NONE, (scale), _MM_HINT_NONE) #define _mm512_i64gather_pslo(index,addr,scale) _mm512_i64extgather_pslo((index), (addr), _MM_UPCONV_PS_NONE, (scale), _MM_HINT_NONE) #define _mm512_mask_i64gather_pslo(v1_old,k1,index,addr,scale) _mm512_mask_i64extgather_pslo((v1_old), (k1), (index), (addr), _MM_UPCONV_PS_NONE, (scale), _MM_HINT_NONE) #define _mm512_i64gather_pd(index,addr,scale) _mm512_i64extgather_pd((index), (addr), _MM_UPCONV_PD_NONE, (scale), _MM_HINT_NONE) #define _mm512_mask_i64gather_pd(v1_old,k1,index,addr,scale) _mm512_mask_i64extgather_pd((v1_old), (k1), (index), (addr), _MM_UPCONV_PD_NONE, (scale), _MM_HINT_NONE) #define _mm512_prefetch_i32gather_ps(index,addr,scale,pf_hint) _mm512_prefetch_i32extgather_ps((index), (addr), _MM_UPCONV_PS_NONE, (scale), (pf_hint)) #define _mm512_mask_prefetch_i32gather_ps(index,k1,addr,scale,pf_hint) _mm512_mask_prefetch_i32extgather_ps((index), (k1), (addr), _MM_UPCONV_PS_NONE, (scale), (pf_hint)) #define _mm512_i32scatter_ps(addr,index,v1,scale) _mm512_i32extscatter_ps((addr), (index), (v1), _MM_DOWNCONV_PS_NONE, (scale), _MM_HINT_NONE) #define _mm512_mask_i32scatter_ps(addr,k1,index,v1,scale) _mm512_mask_i32extscatter_ps((addr), (k1), (index), (v1), _MM_DOWNCONV_PS_NONE, (scale), _MM_HINT_NONE) #define _mm512_i32loscatter_pd(addr,index,v1,scale) _mm512_i32loextscatter_pd((addr), (index), (v1), _MM_DOWNCONV_PD_NONE, (scale), _MM_HINT_NONE) #define _mm512_mask_i32loscatter_pd(addr,k1,index,v1,scale) _mm512_mask_i32loextscatter_pd((addr), (k1), (index), (v1), _MM_DOWNCONV_PD_NONE, (scale), _MM_HINT_NONE) #define _mm512_i32scatter_epi32(addr,index,v1,scale) _mm512_i32extscatter_epi32((addr), (index), (v1), _MM_DOWNCONV_EPI32_NONE, (scale), _MM_HINT_NONE) #define _mm512_mask_i32scatter_epi32(addr,k1,index,v1,scale) _mm512_mask_i32extscatter_epi32((addr), (k1), (index), (v1), _MM_DOWNCONV_EPI32_NONE, (scale), _MM_HINT_NONE) #define _mm512_i32loscatter_epi64(addr,index,v1,scale) _mm512_i32loextscatter_epi64((addr), (index), (v1), _MM_DOWNCONV_EPI64_NONE, (scale), _MM_HINT_NONE) #define _mm512_mask_i32loscatter_epi64(addr,k1,index,v1,scale) _mm512_mask_i32loextscatter_epi64((addr), (k1), (index), (v1), _MM_DOWNCONV_EPI64_NONE, (scale), _MM_HINT_NONE) #define _mm512_i64scatter_pslo(addr,index,v1,scale) _mm512_i64extscatter_pslo((addr), (index), (v1), _MM_DOWNCONV_PS_NONE, (scale), _MM_HINT_NONE) #define _mm512_mask_i64scatter_pslo(addr,k1,index,v1,scale) _mm512_mask_i64extscatter_pslo((addr), (k1), (index), (v1), _MM_DOWNCONV_PS_NONE, (scale), _MM_HINT_NONE) #define _mm512_i64scatter_pd(addr,index,v1,scale) _mm512_i64extscatter_pd((addr), (index), (v1), _MM_DOWNCONV_PD_NONE, (scale), _MM_HINT_NONE) #define _mm512_mask_i64scatter_pd(addr,k1,index,v1,scale) _mm512_mask_i64extscatter_pd((addr), (k1), (index), (v1), _MM_DOWNCONV_PD_NONE, (scale), _MM_HINT_NONE) #define _mm512_i64scatter_epi32lo(addr,index,v1,scale) _mm512_i64extscatter_epi32lo((addr), (index), (v1), _MM_DOWNCONV_EPI32_NONE, (scale), _MM_HINT_NONE) #define _mm512_mask_i64scatter_epi32lo(addr,k1,index,v1,scale) _mm512_mask_i64extscatter_epi32lo((addr), (k1), (index), (v1), _MM_DOWNCONV_EPI32_NONE, (scale), _MM_HINT_NONE) #define _mm512_i64scatter_epi64(addr,index,v1,scale) _mm512_i64extscatter_epi64((addr), (index), (v1), _MM_DOWNCONV_EPI64_NONE, (scale), _MM_HINT_NONE) #define _mm512_mask_i64scatter_epi64(addr,k1,index,v1,scale) _mm512_mask_i64extscatter_epi64((addr), (k1), (index), (v1), _MM_DOWNCONV_EPI64_NONE, (scale), _MM_HINT_NONE) #define _mm512_prefetch_i32scatter_ps(addr,index,scale,pf_hint) _mm512_prefetch_i32extscatter_ps((addr), (index), _MM_UPCONV_PS_NONE, (scale), (pf_hint)) #define _mm512_mask_prefetch_i32scatter_ps(addr,k1,index,scale,pf_hint) _mm512_mask_prefetch_i32extscatter_ps((addr), (k1), (index), _MM_UPCONV_PS_NONE, (scale), (pf_hint)) #define _mm512_loadunpackhi_epi32(v1_old,addr) _mm512_extloadunpackhi_epi32((v1_old), (addr), _MM_UPCONV_EPI32_NONE, _MM_HINT_NONE) #define _mm512_mask_loadunpackhi_epi32(v1_old,k1,addr) _mm512_mask_extloadunpackhi_epi32((v1_old), (k1), (addr), _MM_UPCONV_EPI32_NONE, _MM_HINT_NONE) #define _mm512_loadunpacklo_epi32(v1_old,addr) _mm512_extloadunpacklo_epi32((v1_old), (addr), _MM_UPCONV_EPI32_NONE, _MM_HINT_NONE) #define _mm512_mask_loadunpacklo_epi32(v1_old,k1,addr) _mm512_mask_extloadunpacklo_epi32((v1_old), (k1), (addr), _MM_UPCONV_EPI32_NONE, _MM_HINT_NONE) #define _mm512_loadunpackhi_epi64(v1_old,addr) _mm512_extloadunpackhi_epi64((v1_old), (addr), _MM_UPCONV_EPI64_NONE, _MM_HINT_NONE) #define _mm512_mask_loadunpackhi_epi64(v1_old,k1,addr) _mm512_mask_extloadunpackhi_epi64((v1_old), (k1), (addr), _MM_UPCONV_EPI64_NONE, _MM_HINT_NONE) #define _mm512_loadunpacklo_epi64(v1_old,addr) _mm512_extloadunpacklo_epi64((v1_old), (addr), _MM_UPCONV_EPI64_NONE, _MM_HINT_NONE) #define _mm512_mask_loadunpacklo_epi64(v1_old,k1,addr) _mm512_mask_extloadunpacklo_epi64((v1_old), (k1), (addr), _MM_UPCONV_EPI64_NONE, _MM_HINT_NONE) #define _mm512_loadunpackhi_ps(v1_old,addr) _mm512_extloadunpackhi_ps((v1_old), (addr), _MM_UPCONV_PS_NONE, _MM_HINT_NONE) #define _mm512_mask_loadunpackhi_ps(v1_old,k1,addr) _mm512_mask_extloadunpackhi_ps((v1_old), (k1), (addr), _MM_UPCONV_PS_NONE, _MM_HINT_NONE) #define _mm512_loadunpacklo_ps(v1_old,addr) _mm512_extloadunpacklo_ps((v1_old), (addr), _MM_UPCONV_PS_NONE, _MM_HINT_NONE) #define _mm512_mask_loadunpacklo_ps(v1_old,k1,addr) _mm512_mask_extloadunpacklo_ps((v1_old), (k1), (addr), _MM_UPCONV_PS_NONE, _MM_HINT_NONE) #define _mm512_loadunpackhi_pd(v1_old,addr) _mm512_extloadunpackhi_pd((v1_old), (addr), _MM_UPCONV_PD_NONE, _MM_HINT_NONE) #define _mm512_mask_loadunpackhi_pd(v1_old,k1,addr) _mm512_mask_extloadunpackhi_pd((v1_old), (k1), (addr), _MM_UPCONV_PD_NONE, _MM_HINT_NONE) #define _mm512_loadunpacklo_pd(v1_old,addr) _mm512_extloadunpacklo_pd((v1_old), (addr), _MM_UPCONV_PD_NONE, _MM_HINT_NONE) #define _mm512_mask_loadunpacklo_pd(v1_old,k1,addr) _mm512_mask_extloadunpacklo_pd((v1_old), (k1), (addr), _MM_UPCONV_PD_NONE, _MM_HINT_NONE) #define _mm512_packstorehi_epi32(addr,v1) _mm512_extpackstorehi_epi32((addr), (v1), _MM_DOWNCONV_EPI32_NONE, 0) #define _mm512_mask_packstorehi_epi32(addr,k1,v1) _mm512_mask_extpackstorehi_epi32((addr), (k1), (v1), _MM_DOWNCONV_EPI32_NONE, 0) #define _mm512_packstorelo_epi32(addr,v1) _mm512_extpackstorelo_epi32((addr), (v1), _MM_DOWNCONV_EPI32_NONE, 0) #define _mm512_mask_packstorelo_epi32(addr,k1,v1) _mm512_mask_extpackstorelo_epi32((addr), (k1), (v1), _MM_DOWNCONV_EPI32_NONE, 0) #define _mm512_packstorehi_epi64(addr,v1) _mm512_extpackstorehi_epi64((addr), (v1), _MM_DOWNCONV_EPI64_NONE, 0) #define _mm512_mask_packstorehi_epi64(addr,k1,v1) _mm512_mask_extpackstorehi_epi64((addr), (k1), (v1), _MM_DOWNCONV_EPI64_NONE, 0) #define _mm512_packstorelo_epi64(addr,v1) _mm512_extpackstorelo_epi64((addr), (v1), _MM_DOWNCONV_EPI64_NONE, 0) #define _mm512_mask_packstorelo_epi64(addr,k1,v1) _mm512_mask_extpackstorelo_epi64((addr), (k1), (v1), _MM_DOWNCONV_EPI64_NONE, 0) #define _mm512_packstorehi_ps(addr,v1) _mm512_extpackstorehi_ps((addr), (v1), _MM_DOWNCONV_PS_NONE, 0) #define _mm512_mask_packstorehi_ps(addr,k1,v1) _mm512_mask_extpackstorehi_ps((addr), (k1), (v1), _MM_DOWNCONV_PS_NONE, 0) #define _mm512_packstorelo_ps(addr,v1) _mm512_extpackstorelo_ps((addr), (v1), _MM_DOWNCONV_PS_NONE, 0) #define _mm512_mask_packstorelo_ps(addr,k1,v1) _mm512_mask_extpackstorelo_ps((addr), (k1), (v1), _MM_DOWNCONV_PS_NONE, 0) #define _mm512_packstorehi_pd(addr,v1) _mm512_extpackstorehi_pd((addr), (v1), _MM_DOWNCONV_PD_NONE, 0) #define _mm512_mask_packstorehi_pd(addr,k1,v1) _mm512_mask_extpackstorehi_pd((addr), (k1), (v1) ,_MM_DOWNCONV_PD_NONE, 0) #define _mm512_packstorelo_pd(addr,v1) _mm512_extpackstorelo_pd((addr), (v1), _MM_DOWNCONV_PD_NONE, 0) #define _mm512_mask_packstorelo_pd(addr,k1,v1) _mm512_mask_extpackstorelo_pd((addr), (k1), (v1), _MM_DOWNCONV_PD_NONE, 0) #define _mm512_fmadd_ps(v1,v2,v3) _mm512_fmadd_round_ps((v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_fmadd_ps(v1,k1,v2,v3) _mm512_mask_fmadd_round_ps((v1), (k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask3_fmadd_ps(v1,v2,v3,k3) _mm512_mask3_fmadd_round_ps((v1), (v2), (v3), (k3), _MM_FROUND_CUR_DIRECTION) #define _mm512_fmadd_pd(v1,v2,v3) _mm512_fmadd_round_pd((v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_fmadd_pd(v1,k1,v2,v3) _mm512_mask_fmadd_round_pd((v1), (k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask3_fmadd_pd(v1,v2,v3,k3) _mm512_mask3_fmadd_round_pd((v1), (v2), (v3), (k3), _MM_FROUND_CUR_DIRECTION) #define _mm512_fmsub_ps(v1,v2,v3) _mm512_fmsub_round_ps((v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_fmsub_ps(v1,k1,v2,v3) _mm512_mask_fmsub_round_ps((v1), (k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask3_fmsub_ps(v1,v2,v3,k3) _mm512_mask3_fmsub_round_ps((v1), (v2), (v3), (k3), _MM_FROUND_CUR_DIRECTION) #define _mm512_fmsub_pd(v1,v2,v3) _mm512_fmsub_round_pd((v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_fmsub_pd(v1,k1,v2,v3) _mm512_mask_fmsub_round_pd((v1), (k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask3_fmsub_pd(v1,v2,v3,k3) _mm512_mask3_fmsub_round_pd((v1), (v2), (v3), (k3), _MM_FROUND_CUR_DIRECTION) #define _mm512_fnmadd_ps(v1,v2,v3) _mm512_fnmadd_round_ps((v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_fnmadd_ps(v1,k1,v2,v3) _mm512_mask_fnmadd_round_ps((v1), (k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask3_fnmadd_ps(v1,v2,v3,k3) _mm512_mask3_fnmadd_round_ps((v1), (v2), (v3), (k3), _MM_FROUND_CUR_DIRECTION) #define _mm512_fnmadd_pd(v1,v2,v3) _mm512_fnmadd_round_pd((v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_fnmadd_pd(v1,k1,v2,v3) _mm512_mask_fnmadd_round_pd((v1), (k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask3_fnmadd_pd(v1,v2,v3,k3) _mm512_mask3_fnmadd_round_pd((v1), (v2), (v3), (k3), _MM_FROUND_CUR_DIRECTION) #define _mm512_fnmsub_ps(v1,v2,v3) _mm512_fnmsub_round_ps((v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_fnmsub_ps(v1,k1,v2,v3) _mm512_mask_fnmsub_round_ps((v1), (k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask3_fnmsub_ps(v1,v2,v3,k3) _mm512_mask3_fnmsub_round_ps((v1), (v2), (v3), (k3), _MM_FROUND_CUR_DIRECTION) #define _mm512_fnmsub_pd(v1,v2,v3) _mm512_fnmsub_round_pd((v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_fnmsub_pd(v1,k1,v2,v3) _mm512_mask_fnmsub_round_pd((v1), (k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask3_fnmsub_pd(v1,v2,v3,k3) _mm512_mask3_fnmsub_round_pd((v1), (v2), (v3), (k3), _MM_FROUND_CUR_DIRECTION) #define _mm512_fmadd233_ps(v2,v3) _mm512_fmadd233_round_ps((v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_fmadd233_ps(v1_old,k1,v2,v3) _mm512_mask_fmadd233_round_ps((v1_old), (k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_permutev_epi32 _mm512_permutevar_epi32 #define _mm512_mask_permutev_epi32 _mm512_mask_permutevar_epi32 #define _mm512_undefined_pd() _mm512_castps_pd(_mm512_undefined()) #define _mm512_undefined_ps() _mm512_undefined() #define _mm512_undefined_epi32() _mm512_castps_si512(_mm512_undefined()) #define _mm512_setzero_pd() _mm512_castps_pd(_mm512_setzero()) #define _mm512_setzero_ps() _mm512_setzero() #define _mm512_setzero_epi32() _mm512_castps_si512(_mm512_setzero()) #define _mm512_setzero_si512 _mm512_setzero_epi32 #define _mm512_set_1to8_pd(x) _mm512_set1_pd((x)) #define _mm512_set_1to8_pq(x) _mm512_set1_epi64((x)) #define _mm512_set_1to8_epi64(x) _mm512_set1_epi64((x)) #define _mm512_set_1to16_ps(x) _mm512_set1_ps((x)) #define _mm512_set_1to16_pi(x) _mm512_set1_epi32((x)) #define _mm512_set_1to16_epi32(x) _mm512_set1_epi32((x)) #define _mm512_setr4_pd(a,b,c,d) _mm512_set4_pd((d),(c),(b),(a)) #define _mm512_set_4to8_pd(a,b,c,d) _mm512_set4_pd((d),(c),(b),(a)) #define _mm512_setr4_epi64(a,b,c,d) _mm512_set4_epi64((d),(c),(b),(a)) #define _mm512_set_4to8_pq(a,b,c,d) _mm512_set4_epi64((d),(c),(b),(a)) #define _mm512_set_4to8_epi64(a,b,c,d) _mm512_set4_epi64((d),(c),(b),(a)) #define _mm512_setr4_ps(a,b,c,d) _mm512_set4_ps((d),(c),(b),(a)) #define _mm512_set_4to16_ps(a,b,c,d) _mm512_set4_ps((d),(c),(b),(a)) #define _mm512_setr4_epi32(a,b,c,d) _mm512_set4_epi32((d),(c),(b),(a)) #define _mm512_set_4to16_pi(a,b,c,d) _mm512_set4_epi32((d),(c),(b),(a)) #define _mm512_set_4to16_epi32(a,b,c,d) _mm512_set4_epi32((d),(c),(b),(a)) #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)) #define _mm512_set_16to16_ps(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15) _mm512_set_ps((e0),(e1),(e2),(e3),(e4),(e5),(e6),(e7), (e8),(e9),(e10),(e11),(e12),(e13),(e14),(e15)) #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_set_16to16_pi(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15) _mm512_set_epi32((e0),(e1),(e2),(e3),(e4),(e5),(e6),(e7), (e8),(e9),(e10),(e11),(e12),(e13),(e14),(e15)) #define _mm512_set_16to16_epi32(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15) _mm512_set_epi32((e0),(e1),(e2),(e3),(e4),(e5),(e6),(e7), (e8),(e9),(e10),(e11),(e12),(e13),(e14),(e15)) #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_set_8to8_pd(e0,e1,e2,e3,e4,e5,e6,e7) _mm512_set_pd((e0),(e1),(e2),(e3),(e4),(e5),(e6),(e7)) #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_set_8to8_pq(e0,e1,e2,e3,e4,e5,e6,e7) _mm512_set_epi64((e0),(e1),(e2),(e3),(e4),(e5),(e6),(e7)) #define _mm512_set_8to8_epi64(e0,e1,e2,e3,e4,e5,e6,e7) _mm512_set_epi64((e0),(e1),(e2),(e3),(e4),(e5),(e6),(e7)) #define _mm512_kmerge2l1h(k1,k2) _mm512_kswapb((k1), (k2)) #define _mm512_kmerge2l1l(k1,k2) _mm512_kmovlhb((k1), (k2)) #define _mm_cmp_sd_mask(v1,v2,c) _mm_cmp_round_sd_mask((v1), (v2), (c), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_cmp_sd_mask(k1,v1,v2,c) _mm_mask_cmp_round_sd_mask((k1), (v1), (v2), (c), _MM_FROUND_CUR_DIRECTION) #define _mm_cmp_ss_mask(v1,v2,c) _mm_cmp_round_ss_mask((v1), (v2), (c), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_cmp_ss_mask(k1,v1,v2,c) _mm_mask_cmp_round_ss_mask((k1), (v1), (v2), (c), _MM_FROUND_CUR_DIRECTION) #define _mm512_cmpeq_epi64_mask(v1,v2) _mm512_cmp_epi64_mask((v1), (v2), _MM_CMPINT_EQ) #define _mm512_mask_cmpeq_epi64_mask(k1,v1,v2) _mm512_mask_cmp_epi64_mask((k1), (v1), (v2), _MM_CMPINT_EQ) #define _mm512_cmplt_epi64_mask(v1,v2) _mm512_cmp_epi64_mask((v1), (v2), _MM_CMPINT_LT) #define _mm512_mask_cmplt_epi64_mask(k1,v1,v2) _mm512_mask_cmp_epi64_mask((k1), (v1), (v2), _MM_CMPINT_LT) #define _mm512_cmple_epi64_mask(v1,v2) _mm512_cmp_epi64_mask((v1), (v2), _MM_CMPINT_LE) #define _mm512_mask_cmple_epi64_mask(k1,v1,v2) _mm512_mask_cmp_epi64_mask((k1), (v1), (v2), _MM_CMPINT_LE) #define _mm512_cmpgt_epi64_mask(v1,v2) _mm512_cmp_epi64_mask((v1), (v2), _MM_CMPINT_GT) #define _mm512_mask_cmpgt_epi64_mask(k1,v1,v2) _mm512_mask_cmp_epi64_mask((k1), (v1), (v2), _MM_CMPINT_GT) #define _mm512_cmpge_epi64_mask(v1,v2) _mm512_cmp_epi64_mask((v1), (v2), _MM_CMPINT_GE) #define _mm512_mask_cmpge_epi64_mask(k1,v1,v2) _mm512_mask_cmp_epi64_mask((k1), (v1), (v2), _MM_CMPINT_GE) #define _mm512_cmpneq_epi64_mask(v1,v2) _mm512_cmp_epi64_mask((v1), (v2), _MM_CMPINT_NE) #define _mm512_mask_cmpneq_epi64_mask(k1,v1,v2) _mm512_mask_cmp_epi64_mask((k1), (v1), (v2), _MM_CMPINT_NE) #define _mm512_cmpeq_epu64_mask(v1,v2) _mm512_cmp_epu64_mask((v1), (v2), _MM_CMPINT_EQ) #define _mm512_mask_cmpeq_epu64_mask(k1,v1,v2) _mm512_mask_cmp_epu64_mask((k1), (v1), (v2), _MM_CMPINT_EQ) #define _mm512_cmplt_epu64_mask(v1,v2) _mm512_cmp_epu64_mask((v1), (v2), _MM_CMPINT_LT) #define _mm512_mask_cmplt_epu64_mask(k1,v1,v2) _mm512_mask_cmp_epu64_mask((k1), (v1), (v2), _MM_CMPINT_LT) #define _mm512_cmple_epu64_mask(v1,v2) _mm512_cmp_epu64_mask((v1), (v2), _MM_CMPINT_LE) #define _mm512_mask_cmple_epu64_mask(k1,v1,v2) _mm512_mask_cmp_epu64_mask((k1), (v1), (v2), _MM_CMPINT_LE) #define _mm512_cmpgt_epu64_mask(v1,v2) _mm512_cmp_epu64_mask((v1), (v2), _MM_CMPINT_GT) #define _mm512_mask_cmpgt_epu64_mask(k1,v1,v2) _mm512_mask_cmp_epu64_mask((k1), (v1), (v2), _MM_CMPINT_GT) #define _mm512_cmpge_epu64_mask(v1,v2) _mm512_cmp_epu64_mask((v1), (v2), _MM_CMPINT_GE) #define _mm512_mask_cmpge_epu64_mask(k1,v1,v2) _mm512_mask_cmp_epu64_mask((k1), (v1), (v2), _MM_CMPINT_GE) #define _mm512_cmpneq_epu64_mask(v1,v2) _mm512_cmp_epu64_mask((v1), (v2), _MM_CMPINT_NE) #define _mm512_mask_cmpneq_epu64_mask(k1,v1,v2) _mm512_mask_cmp_epu64_mask((k1), (v1), (v2), _MM_CMPINT_NE) #define _mm_getexp_sd(v1,v2) _mm_getexp_round_sd((v1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_getexp_sd(v1,k,v2,v3) _mm_mask_getexp_round_sd((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_getexp_sd(k,v1,v2) _mm_maskz_getexp_round_sd((k), (v1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm_getexp_ss(v1,v2) _mm_getexp_round_ss((v1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_getexp_ss(v1,k,v2,v3) _mm_mask_getexp_round_ss((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_getexp_ss(k,v1,v2) _mm_maskz_getexp_round_ss((k), (v1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_getexp_pd(k,v) _mm512_maskz_getexp_round_pd((k), (v), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_getexp_ps(k,v) _mm512_maskz_getexp_round_ps((k), (v), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_add_sd(v1,k,v2,v3) _mm_mask_add_round_sd((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_add_sd(k,v2,v3) _mm_maskz_add_round_sd((k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_add_ss(v1,k,v2,v3) _mm_mask_add_round_ss((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_add_ss(k,v2,v3) _mm_maskz_add_round_ss((k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_div_sd(v1,k,v2,v3) _mm_mask_div_round_sd((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_div_sd(k,v2,v3) _mm_maskz_div_round_sd((k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_div_ss(v1,k,v2,v3) _mm_mask_div_round_ss((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_div_ss(k,v2,v3) _mm_maskz_div_round_ss((k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_max_sd(v1,k,v2,v3) _mm_mask_max_round_sd((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_max_sd(k,v2,v3) _mm_maskz_max_round_sd((k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_max_ss(v1,k,v2,v3) _mm_mask_max_round_ss((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_max_ss(k,v2,v3) _mm_maskz_max_round_ss((k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_min_sd(v1,k,v2,v3) _mm_mask_min_round_sd((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_min_sd(k,v2,v3) _mm_maskz_min_round_sd((k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_min_ss(v1,k,v2,v3) _mm_mask_min_round_ss((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_min_ss(k,v2,v3) _mm_maskz_min_round_ss((k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_mul_sd(v1,k,v2,v3) _mm_mask_mul_round_sd((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_mul_sd(k,v2,v3) _mm_maskz_mul_round_sd((k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_mul_ss(v1,k,v2,v3) _mm_mask_mul_round_ss((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_mul_ss(k,v2,v3) _mm_maskz_mul_round_ss((k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_sub_sd(v1,k,v2,v3) _mm_mask_sub_round_sd((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_sub_sd(k,v2,v3) _mm_maskz_sub_round_sd((k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_sub_ss(v1,k,v2,v3) _mm_mask_sub_round_ss((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_sub_ss(k,v2,v3) _mm_maskz_sub_round_ss((k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_cvtepi32_ps(v) _mm512_cvt_roundepi32_ps((v), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_cvtepi32_ps(v1,k1,v2) _mm512_mask_cvt_roundepi32_ps((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_cvtepi32_ps(k1,v2) _mm512_maskz_cvt_roundepi32_ps((k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_cvtepu32_ps(v) _mm512_cvt_roundepu32_ps((v), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_cvtepu32_ps(v1,k1,v2) _mm512_mask_cvt_roundepu32_ps((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_cvtepu32_ps(k1,v2) _mm512_maskz_cvt_roundepu32_ps((k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_cvtps_pd(v) _mm512_cvt_roundps_pd((v), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_cvtps_pd(v1,k1,v2) _mm512_mask_cvt_roundps_pd((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_cvtps_pd(k1,v2) _mm512_maskz_cvt_roundps_pd((k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_cvtps_epi32(v) _mm512_cvt_roundps_epi32((v), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_cvtps_epi32(v1,k1,v2) _mm512_mask_cvt_roundps_epi32((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_cvtps_epi32(k1,v2) _mm512_maskz_cvt_roundps_epi32((k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_cvttps_epi32(v) _mm512_cvtt_roundps_epi32((v), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_cvttps_epi32(v1,k1,v2) _mm512_mask_cvtt_roundps_epi32((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_cvttps_epi32(k1,v2) _mm512_maskz_cvtt_roundps_epi32((k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_cvtps_epu32(v) _mm512_cvt_roundps_epu32((v), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_cvtps_epu32(v1,k1,v2) _mm512_mask_cvt_roundps_epu32((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_cvtps_epu32(k1,v2) _mm512_maskz_cvt_roundps_epu32((k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_cvttps_epu32(v) _mm512_cvtt_roundps_epu32((v), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_cvttps_epu32(v1,k1,v2) _mm512_mask_cvtt_roundps_epu32((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_cvttps_epu32(k1,v2) _mm512_maskz_cvtt_roundps_epu32((k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_cvtpd_ps(v2) _mm512_cvt_roundpd_ps((v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_cvtpd_ps(v1_old,k1,v2) _mm512_mask_cvt_roundpd_ps((v1_old), (k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_cvtpd_ps(k1,v2) _mm512_maskz_cvt_roundpd_ps((k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_cvtpd_epi32(v) _mm512_cvt_roundpd_epi32((v), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_cvtpd_epi32(v1,k1,v2) _mm512_mask_cvt_roundpd_epi32((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_cvtpd_epi32(k1,v2) _mm512_maskz_cvt_roundpd_epi32((k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_cvttpd_epi32(v) _mm512_cvtt_roundpd_epi32((v), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_cvttpd_epi32(v1,k1,v2) _mm512_mask_cvtt_roundpd_epi32((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_cvttpd_epi32(k1,v2) _mm512_maskz_cvtt_roundpd_epi32((k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_cvtpd_epu32(v) _mm512_cvt_roundpd_epu32((v), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_cvtpd_epu32(v1,k1,v2) _mm512_mask_cvt_roundpd_epu32((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_cvtpd_epu32(k1,v2) _mm512_maskz_cvt_roundpd_epu32((k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_cvttpd_epu32(v) _mm512_cvtt_roundpd_epu32((v), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_cvttpd_epu32(v1,k1,v2) _mm512_mask_cvtt_roundpd_epu32((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_cvttpd_epu32(k1,v2) _mm512_maskz_cvtt_roundpd_epu32((k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_cvtph_ps(v1) _mm512_cvt_roundph_ps((v1), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_cvtph_ps(v1,k,v2) _mm512_mask_cvt_roundph_ps((v1), (k), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_cvtph_ps(k,v1) _mm512_maskz_cvt_roundph_ps((k), (v1), _MM_FROUND_CUR_DIRECTION) #define _mm512_cvtps_ph(v1,a) _mm512_cvt_roundps_ph((v1), (a)) #define _mm512_mask_cvtps_ph(v1,k,v2,a) _mm512_mask_cvt_roundps_ph((v1), (k), (v2), (a)) #define _mm512_maskz_cvtps_ph(k,v2,a) _mm512_maskz_cvt_roundps_ph((k), (v2), (a)) #define _mm_cvtsd_i32 _mm_cvtsd_si32 #define _mm_cvtsd_i64 _mm_cvtsd_si64 #define _mm_cvt_roundsd_si32 _mm_cvt_roundsd_i32 #define _mm_cvt_roundsd_si64 _mm_cvt_roundsd_i64 #define _mm_cvtsd_u32(v) _mm_cvt_roundsd_u32((v), _MM_FROUND_CUR_DIRECTION) #define _mm_cvtsd_u64(v) _mm_cvt_roundsd_u64((v), _MM_FROUND_CUR_DIRECTION) #define _mm_cvttsd_i64(v) _mm_cvtt_roundsd_i64((v), _MM_FROUND_CUR_DIRECTION) #define _mm_cvttsd_i32(v) _mm_cvtt_roundsd_i32((v), _MM_FROUND_CUR_DIRECTION) #define _mm_cvtt_roundsd_si32 _mm_cvtt_roundsd_i32 #define _mm_cvtt_roundsd_si64 _mm_cvtt_roundsd_i64 #define _mm_cvttsd_u64(v) _mm_cvtt_roundsd_u64((v), _MM_FROUND_CUR_DIRECTION) #define _mm_cvttsd_u32(v) _mm_cvtt_roundsd_u32((v), _MM_FROUND_CUR_DIRECTION) #define _mm_cvti32_sd _mm_cvtsi32_sd #define _mm_cvti64_sd _mm_cvtsi64_sd #define _mm_cvt_roundsi64_sd _mm_cvt_roundi64_sd #define _mm_cvtu64_sd(v,a) _mm_cvt_roundu64_sd((v), (a), _MM_FROUND_CUR_DIRECTION) #define _mm_cvtss_i32 _mm_cvtss_si32 #define _mm_cvtss_i64 _mm_cvtss_si64 #define _mm_cvt_roundss_si32 _mm_cvt_roundss_i32 #define _mm_cvt_roundss_si64 _mm_cvt_roundss_i64 #define _mm_cvtss_u32(v) _mm_cvt_roundss_u32((v), _MM_FROUND_CUR_DIRECTION) #define _mm_cvtss_u64(v) _mm_cvt_roundss_u64((v), _MM_FROUND_CUR_DIRECTION) #define _mm_cvttss_i32(v) _mm_cvtt_roundss_i32(v, _MM_FROUND_CUR_DIRECTION) #define _mm_cvttss_i64(v) _mm_cvtt_roundss_i64(v, _MM_FROUND_CUR_DIRECTION) #define _mm_cvtt_roundss_si32 _mm_cvtt_roundss_i32 #define _mm_cvtt_roundss_si64 _mm_cvtt_roundss_i64 #define _mm_cvttss_u64(v) _mm_cvtt_roundss_u64(v, _MM_FROUND_CUR_DIRECTION) #define _mm_cvttss_u32(v) _mm_cvtt_roundss_u32(v, _MM_FROUND_CUR_DIRECTION) #define _mm_cvti32_ss _mm_cvtsi32_ss #define _mm_cvti64_ss _mm_cvtsi64_ss #define _mm_cvt_roundsi32_ss _mm_cvt_roundi32_ss #define _mm_cvt_roundsi64_ss _mm_cvt_roundi64_ss #define _mm_cvtu32_ss(v,a) _mm_cvt_roundu32_ss((v), (a), _MM_FROUND_CUR_DIRECTION) #define _mm_cvtu64_ss(v,a) _mm_cvt_roundu64_ss((v), (a), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_cvtss_sd(v1,k,v2,v3) _mm_mask_cvt_roundss_sd((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_cvtss_sd(k,v1,v2) _mm_maskz_cvt_roundss_sd((k), (v1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_cvtsd_ss(v1,k,v2,v3) _mm_mask_cvt_roundsd_ss((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_cvtsd_ss(k,v1,v2) _mm_maskz_cvt_roundsd_ss((k), (v1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm_roundscale_sd(v1,v2,imm) _mm_roundscale_round_sd((v1), (v2), (imm), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_roundscale_sd(v0,k,v1,v2,imm) _mm_mask_roundscale_round_sd((v0), (k), (v1), (v2), (imm), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_roundscale_sd(k,v1,v2,imm) _mm_maskz_roundscale_round_sd((k), (v1), (v2), (imm), _MM_FROUND_CUR_DIRECTION) #define _mm_roundscale_ss(v1,v2,imm) _mm_roundscale_round_ss((v1), (v2), (imm), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_roundscale_ss(v0,k,v1,v2,imm) _mm_mask_roundscale_round_ss((v0), (k), (v1), (v2), (imm), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_roundscale_ss(k,v1,v2,imm) _mm_maskz_roundscale_round_ss((k), (v1), (v2), (imm), _MM_FROUND_CUR_DIRECTION) #define _mm512_scalef_pd(v1,v2) _mm512_scalef_round_pd((v1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_scalef_pd(v0,k1,v1,v2) _mm512_mask_scalef_round_pd((v0), (k1), (v1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_scalef_pd(k1,v1,v2) _mm512_maskz_scalef_round_pd((k1), (v1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_scalef_ps(v1,v2) _mm512_scalef_round_ps((v1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_scalef_ps(v0,k1,v1,v2) _mm512_mask_scalef_round_ps((v0), (k1), (v1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_scalef_ps(k1,v1,v2) _mm512_maskz_scalef_round_ps((k1), (v1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm_fixupimm_sd(v1,v2,v3,i1) _mm_fixupimm_round_sd((v1), (v2), (v3), (i1), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_fixupimm_sd(v1,k1,v2,v3,i1) _mm_mask_fixupimm_round_sd((v1), (k1), (v2), (v3), (i1), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_fixupimm_sd(k1,v1,v2,v3,i1) _mm_maskz_fixupimm_round_sd((k1), (v1), (v2), (v3), (i1), _MM_FROUND_CUR_DIRECTION) #define _mm_fixupimm_ss(v1,v2,v3,i1) _mm_fixupimm_round_ss((v1), (v2), (v3), (i1), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_fixupimm_ss(v1,k1,v2,v3,i1) _mm_mask_fixupimm_round_ss((v1), (k1), (v2), (v3), (i1), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_fixupimm_ss(k1,v1,v2,v3,i1) _mm_maskz_fixupimm_round_ss((k1), (v1), (v2), (v3), (i1), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_getmant_pd(k1,v1,i1,i2) _mm512_maskz_getmant_round_pd((k1), (v1), (i1), (i2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_getmant_ps(k1,v1,i1,i2) _mm512_maskz_getmant_round_ps((k1), (v1), (i1), (i2), _MM_FROUND_CUR_DIRECTION) #define _mm_getmant_sd(v1,v2,i1,i2) _mm_getmant_round_sd((v1), (v2), (i1), (i2), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_getmant_sd(v1,k1,v2,v3,i1,i2) _mm_mask_getmant_round_sd((v1), (k1), (v2), (v3), (i1), (i2), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_getmant_sd(k1,v1,v2,i1,i2) _mm_maskz_getmant_round_sd((k1), (v1), (v2), (i1), (i2), _MM_FROUND_CUR_DIRECTION) #define _mm_getmant_ss(v1,v2,i1,i2) _mm_getmant_round_ss((v1), (v2), (i1), (i2), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_getmant_ss(v1,k1,v2,v3,i1,i2) _mm_mask_getmant_round_ss((v1), (k1), (v2), (v3), (i1), (i2), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_getmant_ss(k1,v1,v2,i1,i2) _mm_maskz_getmant_round_ss((k1), (v1), (v2), (i1), (i2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_fmadd_pd(k1,v1,v2,v3) _mm512_maskz_fmadd_round_pd((k1), (v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_fmadd_ps(k1,v1,v2,v3) _mm512_maskz_fmadd_round_ps((k1), (v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_fmaddsub_pd(v1,v2,v3) _mm512_fmaddsub_round_pd((v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_fmaddsub_pd(v1,k1,v2,v3) _mm512_mask_fmaddsub_round_pd((v1), (k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask3_fmaddsub_pd(v1,v2,v3,k3) _mm512_mask3_fmaddsub_round_pd((v1), (v2), (v3), (k3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_fmaddsub_pd(k1,v1,v2,v3) _mm512_maskz_fmaddsub_round_pd((k1), (v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_fmaddsub_ps(v1,v2,v3) _mm512_fmaddsub_round_ps((v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_fmaddsub_ps(v1,k1,v2,v3) _mm512_mask_fmaddsub_round_ps((v1), (k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask3_fmaddsub_ps(v1,v2,v3,k3) _mm512_mask3_fmaddsub_round_ps((v1), (v2), (v3), (k3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_fmaddsub_ps(k1,v1,v2,v3) _mm512_maskz_fmaddsub_round_ps((k1), (v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_fmsub_pd(k1,v1,v2,v3) _mm512_maskz_fmsub_round_pd((k1), (v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_fmsub_ps(k1,v1,v2,v3) _mm512_maskz_fmsub_round_ps((k1), (v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_fmsubadd_pd(v1,v2,v3) _mm512_fmsubadd_round_pd((v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_fmsubadd_pd(v1,k1,v2,v3) _mm512_mask_fmsubadd_round_pd((v1), (k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask3_fmsubadd_pd(v1,v2,v3,k3) _mm512_mask3_fmsubadd_round_pd((v1), (v2), (v3), (k3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_fmsubadd_pd(k1,v1,v2,v3) _mm512_maskz_fmsubadd_round_pd((k1), (v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_fmsubadd_ps(v1,v2,v3) _mm512_fmsubadd_round_ps((v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_fmsubadd_ps(v1,k1,v2,v3) _mm512_mask_fmsubadd_round_ps((v1), (k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask3_fmsubadd_ps(v1,v2,v3,k3) _mm512_mask3_fmsubadd_round_ps((v1), (v2), (v3), (k3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_fmsubadd_ps(k1,v1,v2,v3) _mm512_maskz_fmsubadd_round_ps((k1), (v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_fnmadd_pd(k1,v1,v2,v3) _mm512_maskz_fnmadd_round_pd((k1), (v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_fnmadd_ps(k1,v1,v2,v3) _mm512_maskz_fnmadd_round_ps((k1), (v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_fnmsub_pd(k1,v1,v2,v3) _mm512_maskz_fnmsub_round_pd((k1), (v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_fnmsub_ps(k1,v1,v2,v3) _mm512_maskz_fnmsub_round_ps((k1), (v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_fmadd_ss(v1,k,v2,v3) _mm_mask_fmadd_round_ss((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_fmadd_ss(k,v1,v2,v3) _mm_maskz_fmadd_round_ss((k), (v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_mask3_fmadd_ss(v1,v2,v3,k) _mm_mask3_fmadd_round_ss((v1), (v2), (v3), (k), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_fmadd_sd(v1,k,v2,v3) _mm_mask_fmadd_round_sd((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_fmadd_sd(k,v1,v2,v3) _mm_maskz_fmadd_round_sd((k), (v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_mask3_fmadd_sd(v1,v2,v3,k) _mm_mask3_fmadd_round_sd((v1), (v2), (v3), (k), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_fmsub_ss(v1,k,v2,v3) _mm_mask_fmsub_round_ss((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_fmsub_ss(k,v1,v2,v3) _mm_maskz_fmsub_round_ss((k), (v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_mask3_fmsub_ss(v1,v2,v3,k) _mm_mask3_fmsub_round_ss((v1), (v2), (v3), (k), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_fmsub_sd(v1,k,v2,v3) _mm_mask_fmsub_round_sd((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_fmsub_sd(k,v1,v2,v3) _mm_maskz_fmsub_round_sd((k), (v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_mask3_fmsub_sd(v1,v2,v3,k) _mm_mask3_fmsub_round_sd((v1), (v2), (v3), (k), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_fnmadd_ss(v1,k,v2,v3) _mm_mask_fnmadd_round_ss((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_fnmadd_ss(k,v1,v2,v3) _mm_maskz_fnmadd_round_ss((k), (v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_mask3_fnmadd_ss(v1,v2,v3,k) _mm_mask3_fnmadd_round_ss((v1), (v2), (v3), (k), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_fnmadd_sd(v1,k,v2,v3) _mm_mask_fnmadd_round_sd((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_fnmadd_sd(k,v1,v2,v3) _mm_maskz_fnmadd_round_sd((k), (v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_mask3_fnmadd_sd(v1,v2,v3,k) _mm_mask3_fnmadd_round_sd((v1), (v2), (v3), (k), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_fnmsub_ss(v1,k,v2,v3) _mm_mask_fnmsub_round_ss((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_fnmsub_ss(k,v1,v2,v3) _mm_maskz_fnmsub_round_ss((k), (v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_mask3_fnmsub_ss(v1,v2,v3,k) _mm_mask3_fnmsub_round_ss((v1), (v2), (v3), (k), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_fnmsub_sd(v1,k,v2,v3) _mm_mask_fnmsub_round_sd((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_fnmsub_sd(k,v1,v2,v3) _mm_maskz_fnmsub_round_sd((k), (v1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_mask3_fnmsub_sd(v1,v2,v3,k) _mm_mask3_fnmsub_round_sd((v1), (v2), (v3), (k), _MM_FROUND_CUR_DIRECTION) #define _mm512_i32gather_epi64(index,addr,scale) _mm512_i32logather_epi64(_mm512_castsi256_si512(index), (addr), (scale)) #define _mm512_mask_i32gather_epi64(v1_old,k1,index,addr,scale) _mm512_mask_i32logather_epi64((v1_old), (k1), _mm512_castsi256_si512(index), (addr), (scale)) #define _mm512_i32gather_pd(index,addr,scale) _mm512_i32logather_pd(_mm512_castsi256_si512(index), (addr), (scale)) #define _mm512_mask_i32gather_pd(v1_old,k1,index,addr,scale) _mm512_mask_i32logather_pd((v1_old), (k1), _mm512_castsi256_si512(index), (addr), (scale)) #define _mm512_i64gather_epi32(index,addr,scale) _mm512_castsi512_si256(_mm512_i64gather_epi32lo((index), (addr), (scale))) #define _mm512_mask_i64gather_epi32(v1_old,k1,index,addr,scale) _mm512_castsi512_si256(_mm512_mask_i64gather_epi32lo( _mm512_castsi256_si512(v1_old), (k1), (index), (addr), (scale))) #define _mm512_i64gather_ps(index,addr,scale) _mm512_castps512_ps256(_mm512_i64gather_pslo((index), (addr), (scale))) #define _mm512_mask_i64gather_ps(v1_old,k1,index,addr,scale) _mm512_castps512_ps256(_mm512_mask_i64gather_pslo( _mm512_castps256_ps512(v1_old), (k1), (index), (addr), (scale))) #define _mm512_i32scatter_epi64(addr,index,v1,scale) _mm512_i32loscatter_epi64((addr), _mm512_castsi256_si512(index), (v1), (scale)) #define _mm512_mask_i32scatter_epi64(addr,k1,index,v1,scale) _mm512_mask_i32loscatter_epi64((addr), (k1), _mm512_castsi256_si512(index), (v1), (scale)) #define _mm512_i32scatter_pd(addr,index,v1,scale) _mm512_i32loscatter_pd((addr), _mm512_castsi256_si512(index), (v1), (scale)) #define _mm512_mask_i32scatter_pd(addr,k1,index,v1,scale) _mm512_mask_i32loscatter_pd((addr), (k1), _mm512_castsi256_si512(index), (v1), (scale)) #define _mm512_i64scatter_epi32(addr,index,v1,scale) _mm512_i64scatter_epi32lo((addr), (index), _mm512_castsi256_si512(v1), (scale)) #define _mm512_mask_i64scatter_epi32(addr,k1,index,v1,scale) _mm512_mask_i64scatter_epi32lo((addr), (k1), (index), _mm512_castsi256_si512(v1), (scale)) #define _mm512_i64scatter_ps(addr,index,v1,scale) _mm512_i64scatter_pslo((addr), (index), _mm512_castps256_ps512(v1), (scale)) #define _mm512_mask_i64scatter_ps(addr,k1,index,v1,scale) _mm512_mask_i64scatter_pslo((addr), (k1), (index), _mm512_castps256_ps512(v1), (scale)) #define _mm512_maskz_max_pd(k1,v2,v3) _mm512_maskz_max_round_pd((k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_min_pd(k1,v2,v3) _mm512_maskz_min_round_pd((k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_max_ps(k1,v2,v3) _mm512_maskz_max_round_ps((k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_min_ps(k1,v2,v3) _mm512_maskz_min_round_ps((k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_add_pd(k1,v2,v3) _mm512_maskz_add_round_pd((k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_add_ps(k1,v2,v3) _mm512_maskz_add_round_ps((k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_div_pd(k1,v2,v3) _mm512_maskz_div_round_pd((k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_div_ps(k1,v2,v3) _mm512_maskz_div_round_ps((k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_mul_pd(k1,v2,v3) _mm512_maskz_mul_round_pd((k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_mul_ps(k1,v2,v3) _mm512_maskz_mul_round_ps((k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_sub_pd(k1,v2,v3) _mm512_maskz_sub_round_pd((k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_sub_ps(k1,v2,v3) _mm512_maskz_sub_round_ps((k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_scalef_sd(v1,v2) _mm_scalef_round_sd((v1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_scalef_sd(v1,k,v2,v3) _mm_mask_scalef_round_sd((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_scalef_sd(k,v2,v3) _mm_maskz_scalef_round_sd((k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_scalef_ss(v1,v2) _mm_scalef_round_ss((v1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_scalef_ss(v1,k,v2,v3) _mm_mask_scalef_round_ss((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_scalef_ss(k,v2,v3) _mm_maskz_scalef_round_ss((k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_sqrt_pd(k1,v1) _mm512_maskz_sqrt_round_pd((k1), (v1), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_sqrt_ps(k1,v1) _mm512_maskz_sqrt_round_ps((k1), (v1), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_sqrt_sd(v1,k,v2,v3) _mm_mask_sqrt_round_sd((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_sqrt_sd(k,v2,v3) _mm_maskz_sqrt_round_sd((k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_sqrt_ss(v1,k,v2,v3) _mm_mask_sqrt_round_ss((v1), (k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_sqrt_ss(k,v2,v3) _mm_maskz_sqrt_round_ss((k), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm512_exp2a23_ps(v1) _mm512_exp2a23_round_ps((v1), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_exp2a23_ps(v1,k1,v2) _mm512_mask_exp2a23_round_ps((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_exp2a23_ps(k1,v1) _mm512_maskz_exp2a23_round_ps((k1), (v1), _MM_FROUND_CUR_DIRECTION) #define _mm512_exp2a23_pd(v1) _mm512_exp2a23_round_pd((v1), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_exp2a23_pd(v1,k1,v2) _mm512_mask_exp2a23_round_pd((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_exp2a23_pd(k1,v1) _mm512_maskz_exp2a23_round_pd((k1), (v1), _MM_FROUND_CUR_DIRECTION) #define _mm_rcp28_sd(v1,v2) _mm_rcp28_round_sd((v1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_rcp28_sd(v1,k1,v2,v3) _mm_mask_rcp28_round_sd((v1), (k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_rcp28_sd(k1,v1,v2) _mm_maskz_rcp28_round_sd((k1), (v1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm_rcp28_ss(v1,v2) _mm_rcp28_round_ss((v1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_rcp28_ss(v1,k1,v2,v3) _mm_mask_rcp28_round_ss((v1), (k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_rcp28_ss(k1,v1,v2) _mm_maskz_rcp28_round_ss((k1), (v1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_rcp28_ps(v1) _mm512_rcp28_round_ps((v1), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_rcp28_ps(v1,k1,v2) _mm512_mask_rcp28_round_ps((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_rcp28_ps(k1,v1) _mm512_maskz_rcp28_round_ps((k1), (v1), _MM_FROUND_CUR_DIRECTION) #define _mm512_rcp28_pd(v1) _mm512_rcp28_round_pd((v1), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_rcp28_pd(v1,k1,v2) _mm512_mask_rcp28_round_pd((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_rcp28_pd(k1,v1) _mm512_maskz_rcp28_round_pd((k1), (v1), _MM_FROUND_CUR_DIRECTION) #define _mm_rsqrt28_sd(v1,v2) _mm_rsqrt28_round_sd((v1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_rsqrt28_sd(v1,k1,v2,v3) _mm_mask_rsqrt28_round_sd((v1), (k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_rsqrt28_sd(k1,v1,v2) _mm_maskz_rsqrt28_round_sd((k1), (v1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm_rsqrt28_ss(v1,v2) _mm_rsqrt28_round_ss((v1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm_mask_rsqrt28_ss(v1,k1,v2,v3) _mm_mask_rsqrt28_round_ss((v1), (k1), (v2), (v3), _MM_FROUND_CUR_DIRECTION) #define _mm_maskz_rsqrt28_ss(k1,v1,v2) _mm_maskz_rsqrt28_round_ss((k1), (v1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_rsqrt28_ps(v1) _mm512_rsqrt28_round_ps((v1), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_rsqrt28_ps(v1,k1,v2) _mm512_mask_rsqrt28_round_ps((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_rsqrt28_ps(k1,v1) _mm512_maskz_rsqrt28_round_ps((k1), (v1), _MM_FROUND_CUR_DIRECTION) #define _mm512_rsqrt28_pd(v1) _mm512_rsqrt28_round_pd((v1), _MM_FROUND_CUR_DIRECTION) #define _mm512_mask_rsqrt28_pd(v1,k1,v2) _mm512_mask_rsqrt28_round_pd((v1), (k1), (v2), _MM_FROUND_CUR_DIRECTION) #define _mm512_maskz_rsqrt28_pd(k1,v1) _mm512_maskz_rsqrt28_round_pd((k1), (v1), _MM_FROUND_CUR_DIRECTION) #define _ADXINTRIN_H_INCLUDED #define _RANDOM_TCC 1 #define _GLIBCXX_NUMERIC 1 #define _STL_NUMERIC_H 1 #define _GLIBCXX_FUNCTIONAL 1 #define _TYPEINFO #define __GXX_MERGED_TYPEINFO_NAMES 0 #define __GXX_TYPEINFO_EQUALITY_INLINE 1 #define _GLIBCXX_TUPLE 1 #define _GLIBCXX_ARRAY 1 #define _GLIBCXX_STDEXCEPT 1 #define _USES_ALLOCATOR_H 1 #define QT_PREPEND_NAMESPACE(name) ::name #define QT_USE_NAMESPACE #define QT_BEGIN_NAMESPACE #define QT_END_NAMESPACE #define QT_BEGIN_INCLUDE_NAMESPACE #define QT_END_INCLUDE_NAMESPACE #define QT_BEGIN_MOC_NAMESPACE #define QT_END_MOC_NAMESPACE #define QT_FORWARD_DECLARE_CLASS(name) class name; #define QT_FORWARD_DECLARE_STRUCT(name) struct name; #define QT_MANGLE_NAMESPACE(name) name #define QT_BEGIN_HEADER #define QT_END_HEADER #define Q_INT64_C(c) static_cast(c ## LL) #define Q_UINT64_C(c) static_cast(c ## ULL) #define QT_DEPRECATED Q_DECL_DEPRECATED #define QT_DEPRECATED_VARIABLE Q_DECL_VARIABLE_DEPRECATED #define QT_DEPRECATED_CONSTRUCTOR explicit Q_DECL_CONSTRUCTOR_DEPRECATED #define QT_DEPRECATED_SINCE(major,minor) (QT_VERSION_CHECK(major, minor, 0) > QT_DISABLE_DEPRECATED_BEFORE) #define QT_SHARED #define Q_CORE_EXPORT Q_DECL_IMPORT #define Q_GUI_EXPORT Q_DECL_IMPORT #define Q_WIDGETS_EXPORT Q_DECL_IMPORT #define Q_NETWORK_EXPORT Q_DECL_IMPORT #define Q_AUTOTEST_EXPORT #define Q_INIT_RESOURCE(name) do { extern int QT_MANGLE_NAMESPACE(qInitResources_ ## name) (); QT_MANGLE_NAMESPACE(qInitResources_ ## name) (); } while (0) #define Q_CLEANUP_RESOURCE(name) do { extern int QT_MANGLE_NAMESPACE(qCleanupResources_ ## name) (); QT_MANGLE_NAMESPACE(qCleanupResources_ ## name) (); } while (0) #define Q_CONSTRUCTOR_FUNCTION0(AFUNC) namespace { static const struct AFUNC ## _ctor_class_ { inline AFUNC ## _ctor_class_() { AFUNC(); } } AFUNC ## _ctor_instance_; } #define Q_CONSTRUCTOR_FUNCTION(AFUNC) Q_CONSTRUCTOR_FUNCTION0(AFUNC) #define Q_DESTRUCTOR_FUNCTION0(AFUNC) namespace { static const struct AFUNC ## _dtor_class_ { inline AFUNC ## _dtor_class_() { } inline ~ AFUNC ## _dtor_class_() { AFUNC(); } } AFUNC ## _dtor_instance_; } #define Q_DESTRUCTOR_FUNCTION(AFUNC) Q_DESTRUCTOR_FUNCTION0(AFUNC) #define QT_EMULATED_ALIGNOF(T) (size_t(QT_PREPEND_NAMESPACE(QtPrivate)::AlignOf::Value)) #define QT_MOC_COMPAT #define QT_ASCII_CAST_WARN Q_DECL_DEPRECATED #define QT_FASTCALL #define QT_TRY if (true) #define QT_CATCH(A) else #define QT_THROW(A) qt_noop() #define QT_RETHROW qt_noop() #define QT_TERMINATE_ON_EXCEPTION(expr) do { expr; } while (0) #define Q_OUTOFLINE_TEMPLATE #define Q_INLINE_TEMPLATE inline #define Q_UNUSED(x) (void)x; #define QT_DEBUG #define qPrintable(string) QString(string).toLocal8Bit().constData() #define Q_ASSERT(cond) ((!(cond)) ? qt_assert(#cond,__FILE__,__LINE__) : qt_noop()) #define Q_ASSERT_X(cond,where,what) ((!(cond)) ? qt_assert_x(where, what,__FILE__,__LINE__) : qt_noop()) #define Q_STATIC_ASSERT(Condition) static_assert(bool(Condition), #Condition) #define Q_STATIC_ASSERT_X(Condition,Message) static_assert(bool(Condition), Message) #define Q_CHECK_PTR(p) do {if(!(p))qt_check_pointer(__FILE__,__LINE__);} while (0) #define Q_UNIMPLEMENTED() qWarning("%s:%d: %s: Unimplemented code.", __FILE__, __LINE__, Q_FUNC_INFO) #define Q_DUMMY_COMPARISON_OPERATOR(C) #define QT_NO_WARNINGS #define Q_FOREACH(variable,container) for (const QForeachContainerBase &_container_ = qForeachContainerNew(container); qForeachContainer(&_container_, true ? 0 : qForeachPointer(container))->condition(); ++qForeachContainer(&_container_, true ? 0 : qForeachPointer(container))->i) for (variable = *qForeachContainer(&_container_, true ? 0 : qForeachPointer(container))->i; qForeachContainer(&_container_, true ? 0 : qForeachPointer(container))->brk; --qForeachContainer(&_container_, true ? 0 : qForeachPointer(container))->brk) #define Q_FOREVER for(;;) #define foreach Q_FOREACH #define forever Q_FOREVER #define Q_DECLARE_PRIVATE(Class) inline Class ## Private* d_func() { return reinterpret_cast(qGetPtrHelper(d_ptr)); } inline const Class ## Private* d_func() const { return reinterpret_cast(qGetPtrHelper(d_ptr)); } friend class Class ## Private; #define Q_DECLARE_PRIVATE_D(Dptr,Class) inline Class ## Private* d_func() { return reinterpret_cast(Dptr); } inline const Class ## Private* d_func() const { return reinterpret_cast(Dptr); } friend class Class ## Private; #define Q_DECLARE_PUBLIC(Class) inline Class* q_func() { return static_cast(q_ptr); } inline const Class* q_func() const { return static_cast(q_ptr); } friend class Class; #define Q_D(Class) Class ## Private * const d = d_func() #define Q_Q(Class) Class * const q = q_func() #define QT_TR_NOOP(x) x #define QT_TR_NOOP_UTF8(x) x #define QT_TRANSLATE_NOOP(scope,x) x #define QT_TRANSLATE_NOOP_UTF8(scope,x) x #define QT_TRANSLATE_NOOP3(scope,x,comment) {x, comment} #define QT_TRANSLATE_NOOP3_UTF8(scope,x,comment) {x, comment} #define QT_TRID_NOOP(id) id #define QDOC_PROPERTY(text) #define Q_DISABLE_COPY(Class) Class(const Class &) Q_DECL_EQ_DELETE; Class &operator=(const Class &) Q_DECL_EQ_DELETE; #define QT_MODULE(x) #define Q_FORWARD_DECLARE_OBJC_CLASS(classname) typedef struct objc_object classname #define Q_FORWARD_DECLARE_CF_TYPE(type) typedef const struct __ ## type * type ## Ref #define Q_FORWARD_DECLARE_MUTABLE_CF_TYPE(type) typedef struct __ ## type * type ## Ref #define QGLOBALSTATIC_H #define QATOMIC_H #define QBASICATOMIC_H #define QATOMIC_X86_H #define QGENERICATOMIC_H #define Q_ATOMIC_INT_REFERENCE_COUNTING_IS_ALWAYS_NATIVE #define Q_ATOMIC_INT_REFERENCE_COUNTING_IS_WAIT_FREE #define Q_ATOMIC_INT_TEST_AND_SET_IS_ALWAYS_NATIVE #define Q_ATOMIC_INT_TEST_AND_SET_IS_WAIT_FREE #define Q_ATOMIC_INT_FETCH_AND_STORE_IS_ALWAYS_NATIVE #define Q_ATOMIC_INT_FETCH_AND_STORE_IS_WAIT_FREE #define Q_ATOMIC_INT_FETCH_AND_ADD_IS_ALWAYS_NATIVE #define Q_ATOMIC_INT_FETCH_AND_ADD_IS_WAIT_FREE #define Q_ATOMIC_INT32_IS_SUPPORTED #define Q_ATOMIC_INT32_REFERENCE_COUNTING_IS_ALWAYS_NATIVE #define Q_ATOMIC_INT32_REFERENCE_COUNTING_IS_WAIT_FREE #define Q_ATOMIC_INT32_TEST_AND_SET_IS_ALWAYS_NATIVE #define Q_ATOMIC_INT32_TEST_AND_SET_IS_WAIT_FREE #define Q_ATOMIC_INT32_FETCH_AND_STORE_IS_ALWAYS_NATIVE #define Q_ATOMIC_INT32_FETCH_AND_STORE_IS_WAIT_FREE #define Q_ATOMIC_INT32_FETCH_AND_ADD_IS_ALWAYS_NATIVE #define Q_ATOMIC_INT32_FETCH_AND_ADD_IS_WAIT_FREE #define Q_ATOMIC_POINTER_TEST_AND_SET_IS_ALWAYS_NATIVE #define Q_ATOMIC_POINTER_TEST_AND_SET_IS_WAIT_FREE #define Q_ATOMIC_POINTER_FETCH_AND_STORE_IS_ALWAYS_NATIVE #define Q_ATOMIC_POINTER_FETCH_AND_STORE_IS_WAIT_FREE #define Q_ATOMIC_POINTER_FETCH_AND_ADD_IS_ALWAYS_NATIVE #define Q_ATOMIC_POINTER_FETCH_AND_ADD_IS_WAIT_FREE #define Q_ATOMIC_INT8_IS_SUPPORTED #define Q_ATOMIC_INT8_REFERENCE_COUNTING_IS_ALWAYS_NATIVE #define Q_ATOMIC_INT8_REFERENCE_COUNTING_IS_WAIT_FREE #define Q_ATOMIC_INT8_TEST_AND_SET_IS_ALWAYS_NATIVE #define Q_ATOMIC_INT8_TEST_AND_SET_IS_WAIT_FREE #define Q_ATOMIC_INT8_FETCH_AND_STORE_IS_ALWAYS_NATIVE #define Q_ATOMIC_INT8_FETCH_AND_STORE_IS_WAIT_FREE #define Q_ATOMIC_INT8_FETCH_AND_ADD_IS_ALWAYS_NATIVE #define Q_ATOMIC_INT8_FETCH_AND_ADD_IS_WAIT_FREE #define Q_ATOMIC_INT16_IS_SUPPORTED #define Q_ATOMIC_INT16_REFERENCE_COUNTING_IS_ALWAYS_NATIVE #define Q_ATOMIC_INT16_REFERENCE_COUNTING_IS_WAIT_FREE #define Q_ATOMIC_INT16_TEST_AND_SET_IS_ALWAYS_NATIVE #define Q_ATOMIC_INT16_TEST_AND_SET_IS_WAIT_FREE #define Q_ATOMIC_INT16_FETCH_AND_STORE_IS_ALWAYS_NATIVE #define Q_ATOMIC_INT16_FETCH_AND_STORE_IS_WAIT_FREE #define Q_ATOMIC_INT16_FETCH_AND_ADD_IS_ALWAYS_NATIVE #define Q_ATOMIC_INT16_FETCH_AND_ADD_IS_WAIT_FREE #define Q_ATOMIC_INT64_IS_SUPPORTED #define Q_ATOMIC_INT64_REFERENCE_COUNTING_IS_ALWAYS_NATIVE #define Q_ATOMIC_INT64_REFERENCE_COUNTING_IS_WAIT_FREE #define Q_ATOMIC_INT64_TEST_AND_SET_IS_ALWAYS_NATIVE #define Q_ATOMIC_INT64_TEST_AND_SET_IS_WAIT_FREE #define Q_ATOMIC_INT64_FETCH_AND_STORE_IS_ALWAYS_NATIVE #define Q_ATOMIC_INT64_FETCH_AND_STORE_IS_WAIT_FREE #define Q_ATOMIC_INT64_FETCH_AND_ADD_IS_ALWAYS_NATIVE #define Q_ATOMIC_INT64_FETCH_AND_ADD_IS_WAIT_FREE #define Q_BASIC_ATOMIC_INITIALIZER(a) { (a) } #define Q_GLOBAL_STATIC_INTERNAL(ARGS) Q_DECL_HIDDEN inline Type *innerFunction() { struct HolderBase { ~HolderBase() Q_DECL_NOTHROW { if (guard.load() == QtGlobalStatic::Initialized) guard.store(QtGlobalStatic::Destroyed); } }; static struct Holder : public HolderBase { Type value; Holder() Q_DECL_NOEXCEPT_EXPR(noexcept(Type ARGS)) : value ARGS { guard.store(QtGlobalStatic::Initialized); } } holder; return &holder.value; } #define Q_GLOBAL_STATIC_WITH_ARGS(TYPE,NAME,ARGS) namespace { namespace Q_QGS_ ## NAME { typedef TYPE Type; QBasicAtomicInt guard = Q_BASIC_ATOMIC_INITIALIZER(QtGlobalStatic::Uninitialized); Q_GLOBAL_STATIC_INTERNAL(ARGS) } } static QGlobalStatic NAME; #define Q_GLOBAL_STATIC(TYPE,NAME) Q_GLOBAL_STATIC_WITH_ARGS(TYPE, NAME, ()) #define QLOGGING_H #define qDebug QMessageLogger(__FILE__, __LINE__, Q_FUNC_INFO).debug #define qWarning QMessageLogger(__FILE__, __LINE__, Q_FUNC_INFO).warning #define qCritical QMessageLogger(__FILE__, __LINE__, Q_FUNC_INFO).critical #define qFatal QMessageLogger(__FILE__, __LINE__, Q_FUNC_INFO).fatal #define QT_NO_QDEBUG_MACRO while (false) QMessageLogger().noDebug #define QT_NO_QWARNING_MACRO while (false) QMessageLogger().noDebug #define QFLAGS_H #define QTYPEINFO_H #define Q_DECLARE_TYPEINFO_BODY(TYPE,FLAGS) class QTypeInfo { public: enum { isComplex = (((FLAGS) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((FLAGS) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(TYPE)>sizeof(void*)), isPointer = false, isDummy = (((FLAGS) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(TYPE) }; static inline const char *name() { return #TYPE; } } #define Q_DECLARE_TYPEINFO(TYPE,FLAGS) template<> Q_DECLARE_TYPEINFO_BODY(TYPE, FLAGS) #define Q_DECLARE_SHARED_STL(TYPE) QT_END_NAMESPACE namespace std { template<> inline void swap(QT_PREPEND_NAMESPACE(TYPE) &value1, QT_PREPEND_NAMESPACE(TYPE) &value2) { value1.swap(value2); } } QT_BEGIN_NAMESPACE #define Q_DECLARE_SHARED(TYPE) Q_DECLARE_TYPEINFO(TYPE, Q_MOVABLE_TYPE); template <> inline void qSwap(TYPE &value1, TYPE &value2) { value1.swap(value2); } Q_DECLARE_SHARED_STL(TYPE) #define QTYPETRAITS_H #define Q_DECLARE_FLAGS(Flags,Enum) typedef QFlags Flags; #define Q_DECLARE_INCOMPATIBLE_FLAGS(Flags) Q_DECL_CONSTEXPR inline QIncompatibleFlag operator|(Flags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } #define Q_DECLARE_OPERATORS_FOR_FLAGS(Flags) Q_DECL_CONSTEXPR inline QFlags operator|(Flags::enum_type f1, Flags::enum_type f2) { return QFlags(f1) | f2; } Q_DECL_CONSTEXPR inline QFlags operator|(Flags::enum_type f1, QFlags f2) { return f2 | f1; } Q_DECLARE_INCOMPATIBLE_FLAGS(Flags) #define QSYSINFO_H #define Q_QML_EXPORT Q_DECL_EXPORT #define QVARIANT_H #define QBYTEARRAY_H #define QREFCOUNT_H #define Q_REFCOUNT_INITIALIZE_STATIC { Q_BASIC_ATOMIC_INITIALIZER(-1) } #define QNAMESPACE_H #define QARRAYDATA_H #define _STRING_H 1 #define NULL __null #define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER) #define __CORRECT_ISO_CPP_STRING_H_PROTO #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); })) #define Q_STATIC_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(size,offset) { Q_REFCOUNT_INITIALIZE_STATIC, size, 0, 0, offset } #define Q_STATIC_ARRAY_DATA_HEADER_INITIALIZER(type,size) Q_STATIC_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(size, ((sizeof(QArrayData) + (Q_ALIGNOF(type) - 1)) & ~(Q_ALIGNOF(type) - 1) )) #define Q_ARRAY_LITERAL(Type,__VA_ARGS__...) ([]() -> QArrayDataPointerRef { struct StaticWrapper { static QArrayDataPointerRef get() { Q_ARRAY_LITERAL_IMPL(Type, __VA_ARGS__) return ref; } }; return StaticWrapper::get(); }()) #define Q_ARRAY_LITERAL_IMPL(Type,__VA_ARGS__...) union { Type type_must_be_POD; } dummy; Q_UNUSED(dummy) Type data[] = { __VA_ARGS__ }; Q_UNUSED(data) enum { Size = sizeof(data) / sizeof(data[0]) }; static const QStaticArrayData literal = { Q_STATIC_ARRAY_DATA_HEADER_INITIALIZER(Type, Size), { __VA_ARGS__ } }; QArrayDataPointerRef ref = { static_cast *>( const_cast(&literal.header)) }; #define _STDARG_H #define _ANSI_STDARG_H_ #define va_start(v,l) __builtin_va_start(v,l) #define va_end(v) __builtin_va_end(v) #define va_arg(v,l) __builtin_va_arg(v,l) #define va_copy(d,s) __builtin_va_copy(d,s) #define __va_copy(d,s) __builtin_va_copy(d,s) #define _VA_LIST_ #define _VA_LIST #define _VA_LIST_T_H #define __va_list__ #define Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(size,offset) Q_STATIC_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(size, offset) #define Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER(size) Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(size, sizeof(QByteArrayData)) #define QByteArrayLiteral(str) ([]() -> QByteArray { enum { Size = sizeof(str) - 1 }; static const QStaticByteArrayData qbytearray_literal = { Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER(Size), str }; QByteArrayDataPtr holder = { qbytearray_literal.data_ptr() }; const QByteArray ba(holder); return ba; }()) #define QSTRING_H #define QCHAR_H #define QT_UNICODE_LITERAL_II(str) u"" str #define QT_UNICODE_LITERAL(str) QT_UNICODE_LITERAL_II(str) #define QStringLiteral(str) ([]() -> QString { enum { Size = sizeof(QT_UNICODE_LITERAL(str))/2 - 1 }; static const QStaticStringData qstring_literal = { Q_STATIC_STRING_DATA_HEADER_INITIALIZER(Size), QT_UNICODE_LITERAL(str) }; QStringDataPtr holder = { qstring_literal.data_ptr() }; const QString s(holder); return s; }()) #define Q_STATIC_STRING_DATA_HEADER_INITIALIZER_WITH_OFFSET(size,offset) { Q_REFCOUNT_INITIALIZE_STATIC, size, 0, 0, offset } #define Q_STATIC_STRING_DATA_HEADER_INITIALIZER(size) Q_STATIC_STRING_DATA_HEADER_INITIALIZER_WITH_OFFSET(size, sizeof(QStringData)) #define QSTRINGBUILDER_H #define QLIST_H #define QALGORITHMS_H #define QITERATOR_H #define Q_DECLARE_SEQUENTIAL_ITERATOR(C) template class Q ## C ## Iterator { typedef typename Q ## C::const_iterator const_iterator; Q ## C c; const_iterator i; public: inline Q ## C ## Iterator(const Q ## C &container) : c(container), i(c.constBegin()) {} inline Q ## C ## Iterator &operator=(const Q ## C &container) { c = container; i = c.constBegin(); return *this; } inline void toFront() { i = c.constBegin(); } inline void toBack() { i = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline const T &next() { return *i++; } inline const T &peekNext() const { return *i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline const T &previous() { return *--i; } inline const T &peekPrevious() const { const_iterator p = i; return *--p; } inline bool findNext(const T &t) { while (i != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(--i) == t) return true; return false; } }; #define Q_DECLARE_MUTABLE_SEQUENTIAL_ITERATOR(C) template class QMutable ## C ## Iterator { typedef typename Q ## C::iterator iterator; typedef typename Q ## C::const_iterator const_iterator; Q ## C *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutable ## C ## Iterator(Q ## C &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutable ## C ## Iterator() { c->setSharable(true); } inline QMutable ## C ## Iterator &operator=(Q ## C &container) { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = i; } inline bool hasNext() const { return c->constEnd() != const_iterator(i); } inline T &next() { n = i++; return *n; } inline T &peekNext() const { return *i; } inline bool hasPrevious() const { return c->constBegin() != const_iterator(i); } inline T &previous() { n = --i; return *n; } inline T &peekPrevious() const { iterator p = i; return *--p; } inline void remove() { if (c->constEnd() != const_iterator(n)) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) const { if (c->constEnd() != const_iterator(n)) *n = t; } inline T &value() { Q_ASSERT(item_exists()); return *n; } inline const T &value() const { Q_ASSERT(item_exists()); return *n; } inline void insert(const T &t) { n = i = c->insert(i, t); ++i; } inline bool findNext(const T &t) { while (c->constEnd() != const_iterator(n = i)) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (c->constBegin() != const_iterator(i)) if (*(n = --i) == t) return true; n = c->end(); return false; } }; #define Q_DECLARE_ASSOCIATIVE_ITERATOR(C) template class Q ## C ## Iterator { typedef typename Q ## C::const_iterator const_iterator; typedef const_iterator Item; Q ## C c; const_iterator i, n; inline bool item_exists() const { return n != c.constEnd(); } public: inline Q ## C ## Iterator(const Q ## C &container) : c(container), i(c.constBegin()), n(c.constEnd()) {} inline Q ## C ## Iterator &operator=(const Q ## C &container) { c = container; i = c.constBegin(); n = c.constEnd(); return *this; } inline void toFront() { i = c.constBegin(); n = c.constEnd(); } inline void toBack() { i = c.constEnd(); n = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { const_iterator p = i; return --p; } inline const T &value() const { Q_ASSERT(item_exists()); return *n; } inline const Key &key() const { Q_ASSERT(item_exists()); return n.key(); } inline bool findNext(const T &t) { while ((n = i) != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(n = --i) == t) return true; n = c.constEnd(); return false; } }; #define Q_DECLARE_MUTABLE_ASSOCIATIVE_ITERATOR(C) template class QMutable ## C ## Iterator { typedef typename Q ## C::iterator iterator; typedef typename Q ## C::const_iterator const_iterator; typedef iterator Item; Q ## C *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutable ## C ## Iterator(Q ## C &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutable ## C ## Iterator() { c->setSharable(true); } inline QMutable ## C ## Iterator &operator=(Q ## C &container) { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = c->end(); } inline bool hasNext() const { return const_iterator(i) != c->constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return const_iterator(i) != c->constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { iterator p = i; return --p; } inline void remove() { if (const_iterator(n) != c->constEnd()) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) { if (const_iterator(n) != c->constEnd()) *n = t; } inline T &value() { Q_ASSERT(item_exists()); return *n; } inline const T &value() const { Q_ASSERT(item_exists()); return *n; } inline const Key &key() const { Q_ASSERT(item_exists()); return n.key(); } inline bool findNext(const T &t) { while (const_iterator(n = i) != c->constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (const_iterator(i) != c->constBegin()) if (*(n = --i) == t) return true; n = c->end(); return false; } }; #define _GLIBCXX_ITERATOR 1 #define _GLIBCXX_OSTREAM 1 #define _GLIBCXX_IOS 1 #define _IOS_BASE_H 1 #define _LOCALE_CLASSES_H 1 #define _LOCALE_CLASSES_TCC 1 #define _GLIBXX_STREAMBUF 1 #define _STREAMBUF_TCC 1 #define _BASIC_IOS_H 1 #define _LOCALE_FACETS_H 1 #define _WCTYPE_H 1 #define __iswxxx_defined 1 #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)))) #define _GLIBCXX_CWCTYPE 1 #define _STREAMBUF_ITERATOR_H 1 #define _GLIBCXX_NUM_FACETS 28 #define _LOCALE_FACETS_TCC 1 #define _BASIC_IOS_TCC 1 #define _OSTREAM_TCC 1 #define _GLIBCXX_ISTREAM 1 #define _ISTREAM_TCC 1 #define _STREAM_ITERATOR_H 1 #define _GLIBCXX_LIST 1 #define _STL_LIST_H 1 #define _LIST_TCC 1 #define _GCC_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 _LINUX_LIMITS_H #define NGROUPS_MAX 65536 #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 #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 #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 #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 #define _LIMITS_H___ #define CHAR_BIT __CHAR_BIT__ #define SCHAR_MIN (-SCHAR_MAX - 1) #define SCHAR_MAX __SCHAR_MAX__ #define UCHAR_MAX (SCHAR_MAX * 2 + 1) #define CHAR_MIN SCHAR_MIN #define CHAR_MAX SCHAR_MAX #define SHRT_MIN (-SHRT_MAX - 1) #define SHRT_MAX __SHRT_MAX__ #define USHRT_MAX (SHRT_MAX * 2 + 1) #define INT_MIN (-INT_MAX - 1) #define INT_MAX __INT_MAX__ #define UINT_MAX (INT_MAX * 2U + 1U) #define LONG_MIN (-LONG_MAX - 1L) #define LONG_MAX __LONG_MAX__ #define ULONG_MAX (LONG_MAX * 2UL + 1UL) #define LONG_LONG_MIN (-LONG_LONG_MAX - 1LL) #define LONG_LONG_MAX __LONG_LONG_MAX__ #define ULONG_LONG_MAX (LONG_LONG_MAX * 2ULL + 1ULL) #define QMETATYPE_H #define QVARLENGTHARRAY_H #define QCONTAINERFWD_H #define QISENUM_H #define Q_IS_ENUM(x) __is_enum(x) #define QOBJECTDEFS_H #define Q_MOC_OUTPUT_REVISION 67 #define slots #define signals public #define Q_SLOTS #define Q_SIGNALS public #define Q_PRIVATE_SLOT(d,signature) #define Q_EMIT #define emit #define Q_CLASSINFO(name,value) #define Q_PLUGIN_METADATA(x) #define Q_INTERFACES(x) #define Q_PROPERTY(text) #define Q_PRIVATE_PROPERTY(d,text) #define Q_REVISION(v) #define Q_OVERRIDE(text) #define Q_ENUMS(x) #define Q_FLAGS(x) #define Q_SCRIPTABLE #define Q_INVOKABLE #define Q_SIGNAL #define Q_SLOT #define QT_TR_FUNCTIONS static inline QString tr(const char *s, const char *c = 0, int n = -1) { return staticMetaObject.tr(s, c, n); } QT_DEPRECATED static inline QString trUtf8(const char *s, const char *c = 0, int n = -1) { return staticMetaObject.tr(s, c, n); } #define Q_OBJECT_CHECK template inline void qt_check_for_QOBJECT_macro(const ThisObject &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i + 1; } #define Q_DECL_HIDDEN_STATIC_METACALL #define Q_OBJECT public: Q_OBJECT_CHECK static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); QT_TR_FUNCTIONS virtual int qt_metacall(QMetaObject::Call, int, void **); private: Q_DECL_HIDDEN_STATIC_METACALL static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); struct QPrivateSignal {}; #define Q_OBJECT_FAKE Q_OBJECT #define Q_GADGET public: static const QMetaObject staticMetaObject; private: #define QLOCATION "\0" __FILE__ ":" QT_STRINGIFY(__LINE__) #define METHOD(a) qFlagLocation("0"#a QLOCATION) #define SLOT(a) qFlagLocation("1"#a QLOCATION) #define SIGNAL(a) qFlagLocation("2"#a QLOCATION) #define QMETHOD_CODE 0 #define QSLOT_CODE 1 #define QSIGNAL_CODE 2 #define Q_ARG(type,data) QArgument(#type, data) #define Q_RETURN_ARG(type,data) QReturnArgument(#type, data) #define _GLIBCXX_MAP 1 #define _STL_TREE_H 1 #define _STL_MAP_H 1 #define _STL_MULTIMAP_H 1 #define QT_FOR_EACH_STATIC_PRIMITIVE_TYPE(F) F(Void, 43, void) F(Bool, 1, bool) F(Int, 2, int) F(UInt, 3, uint) F(LongLong, 4, qlonglong) F(ULongLong, 5, qulonglong) F(Double, 6, double) F(Long, 32, long) F(Short, 33, short) F(Char, 34, char) F(ULong, 35, ulong) F(UShort, 36, ushort) F(UChar, 37, uchar) F(Float, 38, float) F(SChar, 40, signed char) #define QT_FOR_EACH_STATIC_PRIMITIVE_POINTER(F) F(VoidStar, 31, void*) #define QT_FOR_EACH_STATIC_CORE_CLASS(F) F(QChar, 7, QChar) F(QString, 10, QString) F(QStringList, 11, QStringList) F(QByteArray, 12, QByteArray) F(QBitArray, 13, QBitArray) F(QDate, 14, QDate) F(QTime, 15, QTime) F(QDateTime, 16, QDateTime) F(QUrl, 17, QUrl) F(QLocale, 18, QLocale) F(QRect, 19, QRect) F(QRectF, 20, QRectF) F(QSize, 21, QSize) F(QSizeF, 22, QSizeF) F(QLine, 23, QLine) F(QLineF, 24, QLineF) F(QPoint, 25, QPoint) F(QPointF, 26, QPointF) F(QRegExp, 27, QRegExp) F(QEasingCurve, 29, QEasingCurve) F(QUuid, 30, QUuid) F(QVariant, 41, QVariant) F(QModelIndex, 42, QModelIndex) F(QRegularExpression, 44, QRegularExpression) F(QJsonValue, 45, QJsonValue) F(QJsonObject, 46, QJsonObject) F(QJsonArray, 47, QJsonArray) F(QJsonDocument, 48, QJsonDocument) #define QT_FOR_EACH_STATIC_CORE_POINTER(F) F(QObjectStar, 39, QObject*) #define QT_FOR_EACH_STATIC_CORE_TEMPLATE(F) F(QVariantMap, 8, QVariantMap) F(QVariantList, 9, QVariantList) F(QVariantHash, 28, QVariantHash) #define QT_FOR_EACH_STATIC_GUI_CLASS(F) F(QFont, 64, QFont) F(QPixmap, 65, QPixmap) F(QBrush, 66, QBrush) F(QColor, 67, QColor) F(QPalette, 68, QPalette) F(QIcon, 69, QIcon) F(QImage, 70, QImage) F(QPolygon, 71, QPolygon) F(QRegion, 72, QRegion) F(QBitmap, 73, QBitmap) F(QCursor, 74, QCursor) F(QKeySequence, 75, QKeySequence) F(QPen, 76, QPen) F(QTextLength, 77, QTextLength) F(QTextFormat, 78, QTextFormat) F(QMatrix, 79, QMatrix) F(QTransform, 80, QTransform) F(QMatrix4x4, 81, QMatrix4x4) F(QVector2D, 82, QVector2D) F(QVector3D, 83, QVector3D) F(QVector4D, 84, QVector4D) F(QQuaternion, 85, QQuaternion) F(QPolygonF, 86, QPolygonF) #define QT_FOR_EACH_STATIC_WIDGETS_CLASS(F) F(QSizePolicy, 121, QSizePolicy) #define QT_FOR_EACH_STATIC_HACKS_TYPE(F) F(QMetaTypeId2::MetaType, -1, qreal) #define QT_FOR_EACH_STATIC_ALIAS_TYPE(F) F(ULong, -1, ulong, "unsigned long") F(UInt, -1, uint, "unsigned int") F(UShort, -1, ushort, "unsigned short") F(UChar, -1, uchar, "unsigned char") F(LongLong, -1, qlonglong, "long long") F(ULongLong, -1, qulonglong, "unsigned long long") F(SChar, -1, signed char, "qint8") F(UChar, -1, uchar, "quint8") F(Short, -1, short, "qint16") F(UShort, -1, ushort, "quint16") F(Int, -1, int, "qint32") F(UInt, -1, uint, "quint32") F(LongLong, -1, qlonglong, "qint64") F(ULongLong, -1, qulonglong, "quint64") F(QVariantList, -1, QVariantList, "QList") F(QVariantMap, -1, QVariantMap, "QMap") F(QVariantHash, -1, QVariantHash, "QHash") #define QT_FOR_EACH_STATIC_TYPE(F) QT_FOR_EACH_STATIC_PRIMITIVE_TYPE(F) QT_FOR_EACH_STATIC_PRIMITIVE_POINTER(F) QT_FOR_EACH_STATIC_CORE_CLASS(F) QT_FOR_EACH_STATIC_CORE_POINTER(F) QT_FOR_EACH_STATIC_CORE_TEMPLATE(F) QT_FOR_EACH_STATIC_GUI_CLASS(F) QT_FOR_EACH_STATIC_WIDGETS_CLASS(F) #define QT_FOR_EACH_AUTOMATIC_TEMPLATE_1ARG(F) F(QList) F(QVector) F(QQueue) F(QStack) F(QSet) F(QLinkedList) #define QT_FOR_EACH_AUTOMATIC_TEMPLATE_2ARG(F) F(QHash, class) F(QMap, class) F(QPair, struct) #define QT_FOR_EACH_AUTOMATIC_TEMPLATE_SMART_POINTER(F) F(QSharedPointer) F(QWeakPointer) F(QPointer) #define QT_FORWARD_DECLARE_SHARED_POINTER_TYPES_ITER(Name) template class Name; #define Q_DECLARE_OPAQUE_POINTER(POINTER) QT_BEGIN_NAMESPACE namespace QtPrivate { template <> struct IsPointerToTypeDerivedFromQObject { enum { Value = false }; }; } QT_END_NAMESPACE #define Q_DECLARE_METATYPE(TYPE) QT_BEGIN_NAMESPACE template <> struct QMetaTypeId< TYPE > { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = Q_BASIC_ATOMIC_INITIALIZER(0); if (const int id = metatype_id.loadAcquire()) return id; const int newId = qRegisterMetaType< TYPE >(#TYPE, reinterpret_cast< TYPE *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; QT_END_NAMESPACE #define Q_DECLARE_BUILTIN_METATYPE(TYPE,METATYPEID,NAME) QT_BEGIN_NAMESPACE template<> struct QMetaTypeId2 { enum { Defined = 1, IsBuiltIn = true, MetaType = METATYPEID }; static inline Q_DECL_CONSTEXPR int qt_metatype_id() { return METATYPEID; } }; QT_END_NAMESPACE #define Q_DECLARE_METATYPE_TEMPLATE_1ARG(SINGLE_ARG_TEMPLATE) QT_BEGIN_NAMESPACE template struct QMetaTypeId< SINGLE_ARG_TEMPLATE > { enum { Defined = QMetaTypeId2::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = Q_BASIC_ATOMIC_INITIALIZER(0); if (const int id = metatype_id.load()) return id; const char *tName = QMetaType::typeName(qMetaTypeId()); Q_ASSERT(tName); const int tNameLen = qstrlen(tName); QByteArray typeName; typeName.reserve(int(sizeof(#SINGLE_ARG_TEMPLATE)) + 1 + tNameLen + 1 + 1); typeName.append(#SINGLE_ARG_TEMPLATE, int(sizeof(#SINGLE_ARG_TEMPLATE)) - 1) .append('<').append(tName, tNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< SINGLE_ARG_TEMPLATE >( typeName, reinterpret_cast< SINGLE_ARG_TEMPLATE *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; namespace QtPrivate { template struct IsSequentialContainer > { enum { Value = true }; }; } QT_END_NAMESPACE #define Q_DECLARE_METATYPE_TEMPLATE_2ARG(DOUBLE_ARG_TEMPLATE) QT_BEGIN_NAMESPACE template struct QMetaTypeId< DOUBLE_ARG_TEMPLATE > { enum { Defined = QMetaTypeId2::Defined && QMetaTypeId2::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = Q_BASIC_ATOMIC_INITIALIZER(0); if (const int id = metatype_id.loadAcquire()) return id; const char *tName = QMetaType::typeName(qMetaTypeId()); const char *uName = QMetaType::typeName(qMetaTypeId()); Q_ASSERT(tName); Q_ASSERT(uName); const int tNameLen = qstrlen(tName); const int uNameLen = qstrlen(uName); QByteArray typeName; typeName.reserve(int(sizeof(#DOUBLE_ARG_TEMPLATE)) + 1 + tNameLen + 1 + uNameLen + 1 + 1); typeName.append(#DOUBLE_ARG_TEMPLATE, int(sizeof(#DOUBLE_ARG_TEMPLATE)) - 1) .append('<').append(tName, tNameLen).append(',').append(uName, uNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< DOUBLE_ARG_TEMPLATE >( typeName, reinterpret_cast< DOUBLE_ARG_TEMPLATE *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; QT_END_NAMESPACE #define Q_DECLARE_SMART_POINTER_METATYPE(SMART_POINTER) QT_BEGIN_NAMESPACE namespace QtPrivate { template struct SharedPointerMetaTypeIdHelper, true> { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = Q_BASIC_ATOMIC_INITIALIZER(0); if (const int id = metatype_id.loadAcquire()) return id; const char * const cName = T::staticMetaObject.className(); QByteArray typeName; typeName.reserve(int(sizeof(#SMART_POINTER) + 1 + strlen(cName) + 1)); typeName.append(#SMART_POINTER, int(sizeof(#SMART_POINTER)) - 1) .append('<').append(cName).append('>'); const int newId = qRegisterNormalizedMetaType< SMART_POINTER >( typeName, reinterpret_cast< SMART_POINTER *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; template struct MetaTypeSmartPointerHelper , typename QEnableIf::Value >::Type> { static bool registerConverter(int id) { const int toId = QMetaType::QObjectStar; if (!QMetaType::hasRegisteredConverterFunction(id, toId)) { QtPrivate::QSmartPointerConvertFunctor > o; static const QtPrivate::ConverterFunctor, QObject*, QSmartPointerConvertFunctor > > f(o); return QMetaType::registerConverterFunction(&f, id, toId); } return true; } }; } template struct QMetaTypeId< SMART_POINTER > : QtPrivate::SharedPointerMetaTypeIdHelper< SMART_POINTER, QtPrivate::IsPointerToTypeDerivedFromQObject::Value> { };QT_END_NAMESPACE #define Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE Q_DECLARE_METATYPE_TEMPLATE_1ARG #define Q_FORWARD_DECLARE_METATYPE_TEMPLATE_2ARG_ITER(TEMPLATENAME,CPPTYPE) QT_BEGIN_NAMESPACE template CPPTYPE TEMPLATENAME; QT_END_NAMESPACE #define Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE(TEMPLATENAME) QT_BEGIN_NAMESPACE namespace QtPrivate { template struct IsAssociativeContainer > { enum { Value = true }; }; } QT_END_NAMESPACE Q_DECLARE_METATYPE_TEMPLATE_2ARG(TEMPLATENAME) #define QMAP_H #define QPAIR_H #define QHASH_H #define QSTRINGLIST_H #define QDATASTREAM_H #define QSCOPEDPOINTER_H #define QIODEVICE_H #define QOBJECT_H #define Q_DECLARE_INTERFACE(IFace,IId) template <> inline const char *qobject_interface_iid() { return IId; } template <> inline IFace *qobject_cast(QObject *object) { return reinterpret_cast((object ? object->qt_metacast(IId) : 0)); } template <> inline IFace *qobject_cast(const QObject *object) { return reinterpret_cast((object ? const_cast(object)->qt_metacast(IId) : 0)); } #define Q_SET_OBJECT_NAME(obj) QT_PREPEND_NAMESPACE(QtPrivate)::deref_for_methodcall(obj).setObjectName(QLatin1String(#obj)) #define QREGEXP_H #define QSTRINGMATCHER_H #define QURL_H #define QQMLPARSERSTATUS_H #define QQmlParserStatus_iid "org.qt-project.Qt.QQmlParserStatus" #define QQMLPROPERTYVALUESOURCE_H #define QQmlPropertyValueSource_iid "org.qt-project.Qt.QQmlPropertyValueSource" #define QQMLLIST_H #define QQMLLISTPROPERTY #define QMETAOBJECT_H #define Q_METAMETHOD_INVOKE_MAX_ARGS 10 #define QML_VERSION 0x020000 #define QML_VERSION_STR "2.0" #define QML_DECLARE_TYPE(TYPE) Q_DECLARE_METATYPE(TYPE *) Q_DECLARE_METATYPE(QQmlListProperty) #define QML_DECLARE_TYPE_HASMETATYPE(TYPE) Q_DECLARE_METATYPE(QQmlListProperty) #define QML_DECLARE_INTERFACE(INTERFACE) QML_DECLARE_TYPE(INTERFACE) #define QML_DECLARE_INTERFACE_HASMETATYPE(INTERFACE) QML_DECLARE_TYPE_HASMETATYPE(INTERFACE) #define QML_DECLARE_TYPEINFO(TYPE,FLAGS) QT_BEGIN_NAMESPACE template <> class QQmlTypeInfo { public: enum { hasAttachedProperties = (((FLAGS) & QML_HAS_ATTACHED_PROPERTIES) == QML_HAS_ATTACHED_PROPERTIES) }; }; QT_END_NAMESPACE #define QML_GETTYPENAMES const char *className = T::staticMetaObject.className(); const int nameLen = int(strlen(className)); QVarLengthArray pointerName(nameLen+2); memcpy(pointerName.data(), className, nameLen); pointerName[nameLen] = '*'; pointerName[nameLen+1] = '\0'; const int listLen = int(strlen("QQmlListProperty<")); QVarLengthArray listName(listLen + nameLen + 2); memcpy(listName.data(), "QQmlListProperty<", listLen); memcpy(listName.data()+listLen, className, nameLen); listName[listLen+nameLen] = '>'; listName[listLen+nameLen+1] = '\0'; #define QLOCALE_H #define QSHAREDDATA_H #define QQMLV8ENGINE_P_H #define QSET_H #define QMUTEX_H #define QT_MUTEX_LOCK_NOEXCEPT Q_DECL_NOTHROW #define QSTACK_H #define QVECTOR_H #define QELAPSEDTIMER_H #define QTHREADSTORAGE_H #define QJSENGINE_H #define QSHAREDPOINTER_H #define QSHAREDPOINTER_VERIFY_AUTO_CAST(T,X) qt_sharedpointer_cast_check(static_cast(0)) #define QJSVALUE_H #define QINTRUSIVELIST_P_H #define QQMLPROPERTYCACHE_P_H #define QQMLREFCOUNT_P_H #define QFLAGPOINTER_P_H #define QQMLCLEANUP_P_H #define QTQMLGLOBAL_P_H #define Q_QML_PRIVATE_EXPORT Q_QML_EXPORT #define QQMLNOTIFIER_P_H #define QQMLDATA_P_H #define QOBJECT_P_H #define QPOINTER_H #define QCOREEVENT_H #define QREADWRITELOCK_H #define QMLJS_VALUE_H #define QNUMERIC_H #define Q_INFINITY (QT_PREPEND_NAMESPACE(qInf)()) #define Q_SNAN (QT_PREPEND_NAMESPACE(qSNaN)()) #define Q_QNAN (QT_PREPEND_NAMESPACE(qQNaN)()) #define QV4GLOBAL_H #define qOffsetOf(s,m) ((size_t)((((char *)&(((s *)64)->m)) - 64))) #define V4_ENABLE_JIT #define ENABLE_YARR_JIT 1 #define ENABLE_JIT 1 #define ENABLE_ASSEMBLER 1 #define QV4STRING_H #define QMLJS_MANAGED_H #define QDEBUG_H #define QTEXTSTREAM_H #define QCONTIGUOUSCACHE_H #define QV4VALUE_DEF_P_H #define Q_MANAGED_CHECK template inline void qt_check_for_QMANAGED_macro(const T &_q_argument) const { int i = qYouForgotTheQ_MANAGED_Macro(this, &_q_argument); i = i + 1; } #define Q_MANAGED public: Q_MANAGED_CHECK static const QV4::ManagedVTable static_vtbl; template QV4::Returned *asReturned() { return QV4::Returned::create(this); } #define DEFINE_MANAGED_VTABLE(classname) const QV4::ManagedVTable classname::static_vtbl = { call, construct, markObjects, destroy, 0, hasInstance, get, getIndexed, put, putIndexed, query, queryIndexed, deleteProperty, deleteIndexedProperty, getLookup, setLookup, isEqualTo, advanceIterator, #classname } #define DEFINE_MANAGED_VTABLE_WITH_DELETABLES(classname) const QV4::ManagedVTable classname::static_vtbl = { call, construct, markObjects, destroy, collectDeletables, hasInstance, get, getIndexed, put, putIndexed, query, queryIndexed, deleteProperty, deleteIndexedProperty, getLookup, setLookup, isEqualTo, advanceIterator, #classname } #define QV4ENGINE_H #define QV4ISEL_P_H #define QV4JSIR_P_H #define QQMLJSMEMORYPOOL_P_H #define QQMLJSGLOBAL_P_H #define QT_QML_BEGIN_NAMESPACE QT_BEGIN_NAMESPACE #define QT_QML_END_NAMESPACE QT_END_NAMESPACE #define QML_PARSER_EXPORT Q_AUTOTEST_EXPORT #define _GLIBCXX_CSTRING 1 #define QQMLJSAST_FWD_P_H #define QBITARRAY_H #define QV4COMPILEDDATA_P_H #define QV4EXECUTABLEALLOCATOR_H #define QV4COMPILER_P_H #define QV4UTIL_H #define QMLJS_ENVIRONMENT_H #define requiredMemoryForExecutionContect(f,argc) sizeof(CallContext) + sizeof(Value) * (f->varCount + qMax((uint)argc, f->formalParameterCount)) + sizeof(CallData) #define QV4PROPERTYDESCRIPTOR_H #define QV4INTERNALCLASS_H #define CHECK_STACK_LIMITS(v4) if ((v4->jsStackTop <= v4->jsStackLimit) && (reinterpret_cast(&v4) >= v4->cStackLimit || v4->recheckCStackLimits())) {} else return v4->current->throwRangeError(QStringLiteral("Maximum call stack size exceeded.")) #define QMETAOBJECT_P_H #define QHASHEDSTRING_P_H #define QV4SCOPEDVALUE_P_H #define SAVE_JS_STACK(ctx) Value *__jsStack = ctx->engine->jsStackTop #define CHECK_JS_STACK(ctx) Q_ASSERT(__jsStack == ctx->engine->jsStackTop) #define QV4QOBJECTWRAPPER_P_H #define QV4FUNCTIONOBJECT_H #define QMLJS_RUNTIME_H #define QMLJS_MATH_H #define TRACE0() #define TRACE1(x) #define TRACE2(x,y) #define QMLJS_OBJECTS_H #define QV4ARRAY_H #define QV4OBJECTITERATOR_H #define _ASSERT_H 1 #define __ASSERT_VOID_CAST static_cast #define assert(expr) ((expr) ? __ASSERT_VOID_CAST (0) : __assert_fail (__STRING(expr), __FILE__, __LINE__, __ASSERT_FUNCTION)) #define assert_perror(errnum) (!(errnum) ? __ASSERT_VOID_CAST (0) : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION)) #define __ASSERT_FUNCTION __PRETTY_FUNCTION__ #define QV4IDENTIFIER_H #define V4THROW_ERROR(string) return ctx->throwError(QString::fromUtf8(string)); #define V4THROW_TYPE(string) return ctx->throwTypeError(QStringLiteral(string)); #define V8_DEFINE_EXTENSION(dataclass,datafunction) static inline dataclass *datafunction(QV8Engine *engine) { static int extensionId = -1; if (extensionId == -1) { QV8Engine::registrationMutex()->lock(); if (extensionId == -1) extensionId = QV8Engine::registerExtension(); QV8Engine::registrationMutex()->unlock(); } dataclass *rv = (dataclass *)engine->extensionData(extensionId); if (!rv) { rv = new dataclass(engine); engine->setExtensionData(extensionId, rv); } return rv; }