diff --git "a/CMakeFiles/3.31.6/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp4.ii" "b/CMakeFiles/3.31.6/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp4.ii" new file mode 100644--- /dev/null +++ "b/CMakeFiles/3.31.6/CompilerIdCUDA/tmp/CMakeCUDACompilerId.cpp4.ii" @@ -0,0 +1,32666 @@ +# 0 "CMakeCUDACompilerId.cu" +# 0 "" +# 0 "" +# 1 "/usr/include/stdc-predef.h" 1 3 4 +# 0 "" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 1 +# 61 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +#pragma GCC diagnostic push + + +#pragma GCC diagnostic ignored "-Wunused-function" +# 82 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/host_config.h" 1 +# 218 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/host_config.h" +# 1 "/usr/include/features.h" 1 3 4 +# 392 "/usr/include/features.h" 3 4 +# 1 "/usr/include/features-time64.h" 1 3 4 +# 20 "/usr/include/features-time64.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 21 "/usr/include/features-time64.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 1 3 4 +# 19 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 2 3 4 +# 22 "/usr/include/features-time64.h" 2 3 4 +# 393 "/usr/include/features.h" 2 3 4 +# 486 "/usr/include/features.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 1 3 4 +# 559 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 560 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4 +# 561 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4 +# 487 "/usr/include/features.h" 2 3 4 +# 510 "/usr/include/features.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 1 3 4 +# 10 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs-64.h" 1 3 4 +# 11 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 2 3 4 +# 511 "/usr/include/features.h" 2 3 4 +# 219 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/host_config.h" 2 +# 83 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + + + + + + + +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 56 "/usr/local/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/device_types.h" 1 +# 59 "/usr/local/cuda/bin/../targets/x86_64-linux/include/device_types.h" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 64 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" +# 1 "/usr/include/ctype.h" 1 3 4 +# 26 "/usr/include/ctype.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/types.h" 1 3 4 +# 27 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 1 3 4 +# 19 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 2 3 4 +# 29 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4 + + + +# 31 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4 +typedef unsigned char __u_char; +typedef unsigned short int __u_short; +typedef unsigned int __u_int; +typedef unsigned long int __u_long; + + +typedef signed char __int8_t; +typedef unsigned char __uint8_t; +typedef signed short int __int16_t; +typedef unsigned short int __uint16_t; +typedef signed int __int32_t; +typedef unsigned int __uint32_t; + +typedef signed long int __int64_t; +typedef unsigned long int __uint64_t; + + + + + + +typedef __int8_t __int_least8_t; +typedef __uint8_t __uint_least8_t; +typedef __int16_t __int_least16_t; +typedef __uint16_t __uint_least16_t; +typedef __int32_t __int_least32_t; +typedef __uint32_t __uint_least32_t; +typedef __int64_t __int_least64_t; +typedef __uint64_t __uint_least64_t; + + + +typedef long int __quad_t; +typedef unsigned long int __u_quad_t; + + + + + + + +typedef long int __intmax_t; +typedef unsigned long int __uintmax_t; +# 141 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/typesizes.h" 1 3 4 +# 142 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/time64.h" 1 3 4 +# 143 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4 + + +typedef unsigned long int __dev_t; +typedef unsigned int __uid_t; +typedef unsigned int __gid_t; +typedef unsigned long int __ino_t; +typedef unsigned long int __ino64_t; +typedef unsigned int __mode_t; +typedef unsigned long int __nlink_t; +typedef long int __off_t; +typedef long int __off64_t; +typedef int __pid_t; +typedef struct { int __val[2]; } __fsid_t; +typedef long int __clock_t; +typedef unsigned long int __rlim_t; +typedef unsigned long int __rlim64_t; +typedef unsigned int __id_t; +typedef long int __time_t; +typedef unsigned int __useconds_t; +typedef long int __suseconds_t; +typedef long int __suseconds64_t; + +typedef int __daddr_t; +typedef int __key_t; + + +typedef int __clockid_t; + + +typedef void * __timer_t; + + +typedef long int __blksize_t; + + + + +typedef long int __blkcnt_t; +typedef long int __blkcnt64_t; + + +typedef unsigned long int __fsblkcnt_t; +typedef unsigned long int __fsblkcnt64_t; + + +typedef unsigned long int __fsfilcnt_t; +typedef unsigned long int __fsfilcnt64_t; + + +typedef long int __fsword_t; + +typedef long int __ssize_t; + + +typedef long int __syscall_slong_t; + +typedef unsigned long int __syscall_ulong_t; + + + +typedef __off64_t __loff_t; +typedef char *__caddr_t; + + +typedef long int __intptr_t; + + +typedef unsigned int __socklen_t; + + + + +typedef int __sig_atomic_t; +# 27 "/usr/include/ctype.h" 2 3 4 + +extern "C" { +# 39 "/usr/include/ctype.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/endian.h" 1 3 4 +# 35 "/usr/include/x86_64-linux-gnu/bits/endian.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/endianness.h" 1 3 4 +# 36 "/usr/include/x86_64-linux-gnu/bits/endian.h" 2 3 4 +# 40 "/usr/include/ctype.h" 2 3 4 + + + + + + +enum +{ + _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)), + _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)), + _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)), + _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)), + _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)), + _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)), + _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)), + _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)), + _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)), + _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)), + _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)), + _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8)) +}; +# 79 "/usr/include/ctype.h" 3 4 +extern const unsigned short int **__ctype_b_loc (void) + noexcept (true) __attribute__ ((__const__)); +extern const __int32_t **__ctype_tolower_loc (void) + noexcept (true) __attribute__ ((__const__)); +extern const __int32_t **__ctype_toupper_loc (void) + noexcept (true) __attribute__ ((__const__)); +# 108 "/usr/include/ctype.h" 3 4 +extern int isalnum (int) noexcept (true); +extern int isalpha (int) noexcept (true); +extern int iscntrl (int) noexcept (true); +extern int isdigit (int) noexcept (true); +extern int islower (int) noexcept (true); +extern int isgraph (int) noexcept (true); +extern int isprint (int) noexcept (true); +extern int ispunct (int) noexcept (true); +extern int isspace (int) noexcept (true); +extern int isupper (int) noexcept (true); +extern int isxdigit (int) noexcept (true); + + + +extern int tolower (int __c) noexcept (true); + + +extern int toupper (int __c) noexcept (true); + + + + +extern int isblank (int) noexcept (true); + + + + +extern int isctype (int __c, int __mask) noexcept (true); + + + + + + +extern int isascii (int __c) noexcept (true); + + + +extern int toascii (int __c) noexcept (true); + + + +extern int _toupper (int) noexcept (true); +extern int _tolower (int) noexcept (true); +# 237 "/usr/include/ctype.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 1 3 4 +# 22 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h" 1 3 4 +# 27 "/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h" 3 4 +struct __locale_struct +{ + + struct __locale_data *__locales[13]; + + + const unsigned short int *__ctype_b; + const int *__ctype_tolower; + const int *__ctype_toupper; + + + const char *__names[13]; +}; + +typedef struct __locale_struct *__locale_t; +# 23 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 2 3 4 + +typedef __locale_t locale_t; +# 238 "/usr/include/ctype.h" 2 3 4 +# 251 "/usr/include/ctype.h" 3 4 +extern int isalnum_l (int, locale_t) noexcept (true); +extern int isalpha_l (int, locale_t) noexcept (true); +extern int iscntrl_l (int, locale_t) noexcept (true); +extern int isdigit_l (int, locale_t) noexcept (true); +extern int islower_l (int, locale_t) noexcept (true); +extern int isgraph_l (int, locale_t) noexcept (true); +extern int isprint_l (int, locale_t) noexcept (true); +extern int ispunct_l (int, locale_t) noexcept (true); +extern int isspace_l (int, locale_t) noexcept (true); +extern int isupper_l (int, locale_t) noexcept (true); +extern int isxdigit_l (int, locale_t) noexcept (true); + +extern int isblank_l (int, locale_t) noexcept (true); + + + +extern int __tolower_l (int __c, locale_t __l) noexcept (true); +extern int tolower_l (int __c, locale_t __l) noexcept (true); + + +extern int __toupper_l (int __c, locale_t __l) noexcept (true); +extern int toupper_l (int __c, locale_t __l) noexcept (true); +# 327 "/usr/include/ctype.h" 3 4 +} +# 65 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 2 +# 60 "/usr/local/cuda/bin/../targets/x86_64-linux/include/device_types.h" 2 +# 68 "/usr/local/cuda/bin/../targets/x86_64-linux/include/device_types.h" + +# 68 "/usr/local/cuda/bin/../targets/x86_64-linux/include/device_types.h" +enum __attribute__((device_builtin)) cudaRoundMode +{ + cudaRoundNearest, + cudaRoundZero, + cudaRoundPosInf, + cudaRoundMinInf +}; +# 57 "/usr/local/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 2 + + +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 1 +# 59 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 60 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 2 + +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/vector_types.h" 1 +# 65 "/usr/local/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 66 "/usr/local/cuda/bin/../targets/x86_64-linux/include/vector_types.h" 2 +# 104 "/usr/local/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +struct __attribute__((device_builtin)) char1 +{ + signed char x; +}; + +struct __attribute__((device_builtin)) uchar1 +{ + unsigned char x; +}; + + +struct __attribute__((device_builtin)) __attribute__((aligned(2))) char2 +{ + signed char x, y; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(2))) uchar2 +{ + unsigned char x, y; +}; + +struct __attribute__((device_builtin)) char3 +{ + signed char x, y, z; +}; + +struct __attribute__((device_builtin)) uchar3 +{ + unsigned char x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(4))) char4 +{ + signed char x, y, z, w; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(4))) uchar4 +{ + unsigned char x, y, z, w; +}; + +struct __attribute__((device_builtin)) short1 +{ + short x; +}; + +struct __attribute__((device_builtin)) ushort1 +{ + unsigned short x; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(4))) short2 +{ + short x, y; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(4))) ushort2 +{ + unsigned short x, y; +}; + +struct __attribute__((device_builtin)) short3 +{ + short x, y, z; +}; + +struct __attribute__((device_builtin)) ushort3 +{ + unsigned short x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(8))) short4 { short x; short y; short z; short w; }; +struct __attribute__((device_builtin)) __attribute__((aligned(8))) ushort4 { unsigned short x; unsigned short y; unsigned short z; unsigned short w; }; + +struct __attribute__((device_builtin)) int1 +{ + int x; +}; + +struct __attribute__((device_builtin)) uint1 +{ + unsigned int x; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(8))) int2 { int x; int y; }; +struct __attribute__((device_builtin)) __attribute__((aligned(8))) uint2 { unsigned int x; unsigned int y; }; + +struct __attribute__((device_builtin)) int3 +{ + int x, y, z; +}; + +struct __attribute__((device_builtin)) uint3 +{ + unsigned int x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) int4 +{ + int x, y, z, w; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) uint4 +{ + unsigned int x, y, z, w; +}; + +struct __attribute__((device_builtin)) long1 +{ + long int x; +}; + +struct __attribute__((device_builtin)) ulong1 +{ + unsigned long x; +}; + + + + + + +struct __attribute__((device_builtin)) __attribute__((aligned(2*sizeof(long int)))) long2 +{ + long int x, y; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(2*sizeof(unsigned long int)))) ulong2 +{ + unsigned long int x, y; +}; + + + +struct __attribute__((device_builtin)) long3 +{ + long int x, y, z; +}; + +struct __attribute__((device_builtin)) ulong3 +{ + unsigned long int x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) long4 +{ + long int x, y, z, w; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) ulong4 +{ + unsigned long int x, y, z, w; +}; + +struct __attribute__((device_builtin)) float1 +{ + float x; +}; +# 280 "/usr/local/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +struct __attribute__((device_builtin)) __attribute__((aligned(8))) float2 { float x; float y; }; + + + + +struct __attribute__((device_builtin)) float3 +{ + float x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) float4 +{ + float x, y, z, w; +}; + +struct __attribute__((device_builtin)) longlong1 +{ + long long int x; +}; + +struct __attribute__((device_builtin)) ulonglong1 +{ + unsigned long long int x; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) longlong2 +{ + long long int x, y; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) ulonglong2 +{ + unsigned long long int x, y; +}; + +struct __attribute__((device_builtin)) longlong3 +{ + long long int x, y, z; +}; + +struct __attribute__((device_builtin)) ulonglong3 +{ + unsigned long long int x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) longlong4 +{ + long long int x, y, z ,w; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) ulonglong4 +{ + unsigned long long int x, y, z, w; +}; + +struct __attribute__((device_builtin)) double1 +{ + double x; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) double2 +{ + double x, y; +}; + +struct __attribute__((device_builtin)) double3 +{ + double x, y, z; +}; + +struct __attribute__((device_builtin)) __attribute__((aligned(16))) double4 +{ + double x, y, z, w; +}; +# 367 "/usr/local/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +typedef __attribute__((device_builtin)) struct char1 char1; +typedef __attribute__((device_builtin)) struct uchar1 uchar1; +typedef __attribute__((device_builtin)) struct char2 char2; +typedef __attribute__((device_builtin)) struct uchar2 uchar2; +typedef __attribute__((device_builtin)) struct char3 char3; +typedef __attribute__((device_builtin)) struct uchar3 uchar3; +typedef __attribute__((device_builtin)) struct char4 char4; +typedef __attribute__((device_builtin)) struct uchar4 uchar4; +typedef __attribute__((device_builtin)) struct short1 short1; +typedef __attribute__((device_builtin)) struct ushort1 ushort1; +typedef __attribute__((device_builtin)) struct short2 short2; +typedef __attribute__((device_builtin)) struct ushort2 ushort2; +typedef __attribute__((device_builtin)) struct short3 short3; +typedef __attribute__((device_builtin)) struct ushort3 ushort3; +typedef __attribute__((device_builtin)) struct short4 short4; +typedef __attribute__((device_builtin)) struct ushort4 ushort4; +typedef __attribute__((device_builtin)) struct int1 int1; +typedef __attribute__((device_builtin)) struct uint1 uint1; +typedef __attribute__((device_builtin)) struct int2 int2; +typedef __attribute__((device_builtin)) struct uint2 uint2; +typedef __attribute__((device_builtin)) struct int3 int3; +typedef __attribute__((device_builtin)) struct uint3 uint3; +typedef __attribute__((device_builtin)) struct int4 int4; +typedef __attribute__((device_builtin)) struct uint4 uint4; +typedef __attribute__((device_builtin)) struct long1 long1; +typedef __attribute__((device_builtin)) struct ulong1 ulong1; +typedef __attribute__((device_builtin)) struct long2 long2; +typedef __attribute__((device_builtin)) struct ulong2 ulong2; +typedef __attribute__((device_builtin)) struct long3 long3; +typedef __attribute__((device_builtin)) struct ulong3 ulong3; +typedef __attribute__((device_builtin)) struct long4 long4; +typedef __attribute__((device_builtin)) struct ulong4 ulong4; +typedef __attribute__((device_builtin)) struct float1 float1; +typedef __attribute__((device_builtin)) struct float2 float2; +typedef __attribute__((device_builtin)) struct float3 float3; +typedef __attribute__((device_builtin)) struct float4 float4; +typedef __attribute__((device_builtin)) struct longlong1 longlong1; +typedef __attribute__((device_builtin)) struct ulonglong1 ulonglong1; +typedef __attribute__((device_builtin)) struct longlong2 longlong2; +typedef __attribute__((device_builtin)) struct ulonglong2 ulonglong2; +typedef __attribute__((device_builtin)) struct longlong3 longlong3; +typedef __attribute__((device_builtin)) struct ulonglong3 ulonglong3; +typedef __attribute__((device_builtin)) struct longlong4 longlong4; +typedef __attribute__((device_builtin)) struct ulonglong4 ulonglong4; +typedef __attribute__((device_builtin)) struct double1 double1; +typedef __attribute__((device_builtin)) struct double2 double2; +typedef __attribute__((device_builtin)) struct double3 double3; +typedef __attribute__((device_builtin)) struct double4 double4; +# 426 "/usr/local/cuda/bin/../targets/x86_64-linux/include/vector_types.h" +struct __attribute__((device_builtin)) dim3 +{ + unsigned int x, y, z; + + + __attribute__((host)) __attribute__((device)) constexpr dim3(unsigned int vx = 1, unsigned int vy = 1, unsigned int vz = 1) : x(vx), y(vy), z(vz) {} + __attribute__((host)) __attribute__((device)) constexpr dim3(uint3 v) : x(v.x), y(v.y), z(v.z) {} + __attribute__((host)) __attribute__((device)) constexpr operator uint3(void) const { return uint3{x, y, z}; } + + + + + + +}; + +typedef __attribute__((device_builtin)) struct dim3 dim3; +# 62 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 2 +# 83 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/limits.h" 1 3 4 +# 34 "/usr/lib/gcc/x86_64-linux-gnu/11/include/limits.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/syslimits.h" 1 3 4 + + + + + + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/limits.h" 1 3 4 +# 203 "/usr/lib/gcc/x86_64-linux-gnu/11/include/limits.h" 3 4 +# 1 "/usr/include/limits.h" 1 3 4 +# 26 "/usr/include/limits.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/limits.h" 2 3 4 +# 195 "/usr/include/limits.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 1 3 4 +# 27 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 2 3 4 +# 161 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 1 3 4 +# 38 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 3 4 +# 1 "/usr/include/linux/limits.h" 1 3 4 +# 39 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 2 3 4 +# 81 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h" 1 3 4 +# 23 "/usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h" 3 4 + +# 23 "/usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h" 3 4 +extern "C" { +extern long int __sysconf (int __name) noexcept (true); +} +# 82 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 2 3 4 +# 162 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 2 3 4 +# 196 "/usr/include/limits.h" 2 3 4 + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/posix2_lim.h" 1 3 4 +# 200 "/usr/include/limits.h" 2 3 4 + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 1 3 4 +# 64 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/uio_lim.h" 1 3 4 +# 65 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 2 3 4 +# 204 "/usr/include/limits.h" 2 3 4 +# 204 "/usr/lib/gcc/x86_64-linux-gnu/11/include/limits.h" 2 3 4 +# 8 "/usr/lib/gcc/x86_64-linux-gnu/11/include/syslimits.h" 2 3 4 +# 35 "/usr/lib/gcc/x86_64-linux-gnu/11/include/limits.h" 2 3 4 +# 84 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 2 +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4 +# 143 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 3 4 +typedef long int ptrdiff_t; +# 209 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 3 4 +typedef long unsigned int size_t; +# 415 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 3 4 +typedef struct { + long long __max_align_ll __attribute__((__aligned__(__alignof__(long long)))); + long double __max_align_ld __attribute__((__aligned__(__alignof__(long double)))); +# 426 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 3 4 +} max_align_t; + + + + + + + typedef decltype(nullptr) nullptr_t; +# 85 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" 2 +# 205 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + +# 205 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +enum __attribute__((device_builtin)) cudaError +{ + + + + + + cudaSuccess = 0, + + + + + + cudaErrorInvalidValue = 1, + + + + + + cudaErrorMemoryAllocation = 2, + + + + + + cudaErrorInitializationError = 3, + + + + + + + cudaErrorCudartUnloading = 4, + + + + + + + cudaErrorProfilerDisabled = 5, + + + + + + + + cudaErrorProfilerNotInitialized = 6, + + + + + + + cudaErrorProfilerAlreadyStarted = 7, + + + + + + + cudaErrorProfilerAlreadyStopped = 8, + + + + + + + + cudaErrorInvalidConfiguration = 9, + + + + + + cudaErrorInvalidPitchValue = 12, + + + + + + cudaErrorInvalidSymbol = 13, + + + + + + + + cudaErrorInvalidHostPointer = 16, + + + + + + + + cudaErrorInvalidDevicePointer = 17, + + + + + cudaErrorInvalidTexture = 18, + + + + + + cudaErrorInvalidTextureBinding = 19, + + + + + + + cudaErrorInvalidChannelDescriptor = 20, + + + + + + cudaErrorInvalidMemcpyDirection = 21, +# 336 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorAddressOfConstant = 22, +# 345 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorTextureFetchFailed = 23, +# 354 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorTextureNotBound = 24, +# 363 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSynchronizationError = 25, + + + + + cudaErrorInvalidFilterSetting = 26, + + + + + + cudaErrorInvalidNormSetting = 27, + + + + + + + + cudaErrorMixedDeviceExecution = 28, + + + + + + + + cudaErrorNotYetImplemented = 31, +# 399 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorMemoryValueTooLarge = 32, + + + + + + cudaErrorStubLibrary = 34, + + + + + + + cudaErrorInsufficientDriver = 35, + + + + + + + cudaErrorCallRequiresNewerDriver = 36, + + + + + + cudaErrorInvalidSurface = 37, + + + + + + cudaErrorDuplicateVariableName = 43, + + + + + + cudaErrorDuplicateTextureName = 44, + + + + + + cudaErrorDuplicateSurfaceName = 45, +# 453 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorDevicesUnavailable = 46, +# 466 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorIncompatibleDriverContext = 49, + + + + + + cudaErrorMissingConfiguration = 52, +# 481 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorPriorLaunchFailure = 53, + + + + + + cudaErrorLaunchMaxDepthExceeded = 65, + + + + + + + + cudaErrorLaunchFileScopedTex = 66, + + + + + + + + cudaErrorLaunchFileScopedSurf = 67, +# 519 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSyncDepthExceeded = 68, +# 531 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorLaunchPendingCountExceeded = 69, + + + + + + cudaErrorInvalidDeviceFunction = 98, + + + + + + cudaErrorNoDevice = 100, + + + + + + + cudaErrorInvalidDevice = 101, + + + + + cudaErrorDeviceNotLicensed = 102, +# 564 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSoftwareValidityNotEstablished = 103, + + + + + cudaErrorStartupFailure = 127, + + + + + cudaErrorInvalidKernelImage = 200, +# 584 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorDeviceUninitialized = 201, + + + + + cudaErrorMapBufferObjectFailed = 205, + + + + + cudaErrorUnmapBufferObjectFailed = 206, + + + + + + cudaErrorArrayIsMapped = 207, + + + + + cudaErrorAlreadyMapped = 208, + + + + + + + + cudaErrorNoKernelImageForDevice = 209, + + + + + cudaErrorAlreadyAcquired = 210, + + + + + cudaErrorNotMapped = 211, + + + + + + cudaErrorNotMappedAsArray = 212, + + + + + + cudaErrorNotMappedAsPointer = 213, + + + + + + cudaErrorECCUncorrectable = 214, + + + + + + cudaErrorUnsupportedLimit = 215, + + + + + + cudaErrorDeviceAlreadyInUse = 216, + + + + + + cudaErrorPeerAccessUnsupported = 217, + + + + + + cudaErrorInvalidPtx = 218, + + + + + cudaErrorInvalidGraphicsContext = 219, + + + + + + cudaErrorNvlinkUncorrectable = 220, + + + + + + + cudaErrorJitCompilerNotFound = 221, + + + + + + + cudaErrorUnsupportedPtxVersion = 222, + + + + + + + cudaErrorJitCompilationDisabled = 223, + + + + + cudaErrorUnsupportedExecAffinity = 224, + + + + + + cudaErrorUnsupportedDevSideSync = 225, + + + + + cudaErrorInvalidSource = 300, + + + + + cudaErrorFileNotFound = 301, + + + + + cudaErrorSharedObjectSymbolNotFound = 302, + + + + + cudaErrorSharedObjectInitFailed = 303, + + + + + cudaErrorOperatingSystem = 304, + + + + + + + cudaErrorInvalidResourceHandle = 400, + + + + + + cudaErrorIllegalState = 401, + + + + + + + + cudaErrorLossyQuery = 402, + + + + + + + cudaErrorSymbolNotFound = 500, + + + + + + + + cudaErrorNotReady = 600, + + + + + + + + cudaErrorIllegalAddress = 700, +# 786 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorLaunchOutOfResources = 701, +# 797 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorLaunchTimeout = 702, + + + + + + cudaErrorLaunchIncompatibleTexturing = 703, + + + + + + + cudaErrorPeerAccessAlreadyEnabled = 704, + + + + + + + cudaErrorPeerAccessNotEnabled = 705, +# 830 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSetOnActiveProcess = 708, + + + + + + + cudaErrorContextIsDestroyed = 709, + + + + + + + cudaErrorAssert = 710, + + + + + + + cudaErrorTooManyPeers = 711, + + + + + + cudaErrorHostMemoryAlreadyRegistered = 712, + + + + + + cudaErrorHostMemoryNotRegistered = 713, +# 872 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorHardwareStackError = 714, + + + + + + + + cudaErrorIllegalInstruction = 715, +# 889 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorMisalignedAddress = 716, +# 900 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorInvalidAddressSpace = 717, + + + + + + + + cudaErrorInvalidPc = 718, +# 919 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorLaunchFailure = 719, +# 928 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorCooperativeLaunchTooLarge = 720, + + + + + cudaErrorNotPermitted = 800, + + + + + + cudaErrorNotSupported = 801, +# 948 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorSystemNotReady = 802, + + + + + + + cudaErrorSystemDriverMismatch = 803, +# 964 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorCompatNotSupportedOnDevice = 804, + + + + + cudaErrorMpsConnectionFailed = 805, + + + + + cudaErrorMpsRpcFailure = 806, + + + + + + cudaErrorMpsServerNotReady = 807, + + + + + cudaErrorMpsMaxClientsReached = 808, + + + + + cudaErrorMpsMaxConnectionsReached = 809, + + + + + cudaErrorMpsClientTerminated = 810, + + + + + cudaErrorCdpNotSupported = 811, + + + + + cudaErrorCdpVersionMismatch = 812, + + + + + cudaErrorStreamCaptureUnsupported = 900, + + + + + + cudaErrorStreamCaptureInvalidated = 901, + + + + + + cudaErrorStreamCaptureMerge = 902, + + + + + cudaErrorStreamCaptureUnmatched = 903, + + + + + + cudaErrorStreamCaptureUnjoined = 904, + + + + + + + cudaErrorStreamCaptureIsolation = 905, + + + + + + cudaErrorStreamCaptureImplicit = 906, + + + + + + cudaErrorCapturedEvent = 907, + + + + + + + cudaErrorStreamCaptureWrongThread = 908, + + + + + cudaErrorTimeout = 909, + + + + + + cudaErrorGraphExecUpdateFailure = 910, +# 1080 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaErrorExternalDevice = 911, + + + + + + cudaErrorInvalidClusterSize = 912, + + + + + cudaErrorUnknown = 999 + + + + + + + + , cudaErrorApiFailureBase = 10000 +}; + + + + +enum __attribute__((device_builtin)) cudaChannelFormatKind +{ + cudaChannelFormatKindSigned = 0, + cudaChannelFormatKindUnsigned = 1, + cudaChannelFormatKindFloat = 2, + cudaChannelFormatKindNone = 3, + cudaChannelFormatKindNV12 = 4, + cudaChannelFormatKindUnsignedNormalized8X1 = 5, + cudaChannelFormatKindUnsignedNormalized8X2 = 6, + cudaChannelFormatKindUnsignedNormalized8X4 = 7, + cudaChannelFormatKindUnsignedNormalized16X1 = 8, + cudaChannelFormatKindUnsignedNormalized16X2 = 9, + cudaChannelFormatKindUnsignedNormalized16X4 = 10, + cudaChannelFormatKindSignedNormalized8X1 = 11, + cudaChannelFormatKindSignedNormalized8X2 = 12, + cudaChannelFormatKindSignedNormalized8X4 = 13, + cudaChannelFormatKindSignedNormalized16X1 = 14, + cudaChannelFormatKindSignedNormalized16X2 = 15, + cudaChannelFormatKindSignedNormalized16X4 = 16, + cudaChannelFormatKindUnsignedBlockCompressed1 = 17, + cudaChannelFormatKindUnsignedBlockCompressed1SRGB = 18, + cudaChannelFormatKindUnsignedBlockCompressed2 = 19, + cudaChannelFormatKindUnsignedBlockCompressed2SRGB = 20, + cudaChannelFormatKindUnsignedBlockCompressed3 = 21, + cudaChannelFormatKindUnsignedBlockCompressed3SRGB = 22, + cudaChannelFormatKindUnsignedBlockCompressed4 = 23, + cudaChannelFormatKindSignedBlockCompressed4 = 24, + cudaChannelFormatKindUnsignedBlockCompressed5 = 25, + cudaChannelFormatKindSignedBlockCompressed5 = 26, + cudaChannelFormatKindUnsignedBlockCompressed6H = 27, + cudaChannelFormatKindSignedBlockCompressed6H = 28, + cudaChannelFormatKindUnsignedBlockCompressed7 = 29, + cudaChannelFormatKindUnsignedBlockCompressed7SRGB = 30 +}; + + + + +struct __attribute__((device_builtin)) cudaChannelFormatDesc +{ + int x; + int y; + int z; + int w; + enum cudaChannelFormatKind f; +}; + + + + +typedef struct cudaArray *cudaArray_t; + + + + +typedef const struct cudaArray *cudaArray_const_t; + +struct cudaArray; + + + + +typedef struct cudaMipmappedArray *cudaMipmappedArray_t; + + + + +typedef const struct cudaMipmappedArray *cudaMipmappedArray_const_t; + +struct cudaMipmappedArray; +# 1184 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct __attribute__((device_builtin)) cudaArraySparseProperties { + struct { + unsigned int width; + unsigned int height; + unsigned int depth; + } tileExtent; + unsigned int miptailFirstLevel; + unsigned long long miptailSize; + unsigned int flags; + unsigned int reserved[4]; +}; + + + + +struct __attribute__((device_builtin)) cudaArrayMemoryRequirements { + size_t size; + size_t alignment; + unsigned int reserved[4]; +}; + + + + +enum __attribute__((device_builtin)) cudaMemoryType +{ + cudaMemoryTypeUnregistered = 0, + cudaMemoryTypeHost = 1, + cudaMemoryTypeDevice = 2, + cudaMemoryTypeManaged = 3 +}; + + + + +enum __attribute__((device_builtin)) cudaMemcpyKind +{ + cudaMemcpyHostToHost = 0, + cudaMemcpyHostToDevice = 1, + cudaMemcpyDeviceToHost = 2, + cudaMemcpyDeviceToDevice = 3, + cudaMemcpyDefault = 4 +}; + + + + + + +struct __attribute__((device_builtin)) cudaPitchedPtr +{ + void *ptr; + size_t pitch; + size_t xsize; + size_t ysize; +}; + + + + + + +struct __attribute__((device_builtin)) cudaExtent +{ + size_t width; + size_t height; + size_t depth; +}; + + + + + + +struct __attribute__((device_builtin)) cudaPos +{ + size_t x; + size_t y; + size_t z; +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpy3DParms +{ + cudaArray_t srcArray; + struct cudaPos srcPos; + struct cudaPitchedPtr srcPtr; + + cudaArray_t dstArray; + struct cudaPos dstPos; + struct cudaPitchedPtr dstPtr; + + struct cudaExtent extent; + enum cudaMemcpyKind kind; +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpyNodeParams { + int flags; + int reserved[3]; + struct cudaMemcpy3DParms copyParams; +}; + + + + +struct __attribute__((device_builtin)) cudaMemcpy3DPeerParms +{ + cudaArray_t srcArray; + struct cudaPos srcPos; + struct cudaPitchedPtr srcPtr; + int srcDevice; + + cudaArray_t dstArray; + struct cudaPos dstPos; + struct cudaPitchedPtr dstPtr; + int dstDevice; + + struct cudaExtent extent; +}; + + + + +struct __attribute__((device_builtin)) cudaMemsetParams { + void *dst; + size_t pitch; + unsigned int value; + unsigned int elementSize; + size_t width; + size_t height; +}; + + + + +struct __attribute__((device_builtin)) cudaMemsetParamsV2 { + void *dst; + size_t pitch; + unsigned int value; + unsigned int elementSize; + size_t width; + size_t height; +}; + + + + +enum __attribute__((device_builtin)) cudaAccessProperty { + cudaAccessPropertyNormal = 0, + cudaAccessPropertyStreaming = 1, + cudaAccessPropertyPersisting = 2 +}; +# 1353 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct __attribute__((device_builtin)) cudaAccessPolicyWindow { + void *base_ptr; + size_t num_bytes; + float hitRatio; + enum cudaAccessProperty hitProp; + enum cudaAccessProperty missProp; +}; +# 1371 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef void ( *cudaHostFn_t)(void *userData); + + + + +struct __attribute__((device_builtin)) cudaHostNodeParams { + cudaHostFn_t fn; + void* userData; +}; + + + + +struct __attribute__((device_builtin)) cudaHostNodeParamsV2 { + cudaHostFn_t fn; + void* userData; +}; + + + + +enum __attribute__((device_builtin)) cudaStreamCaptureStatus { + cudaStreamCaptureStatusNone = 0, + cudaStreamCaptureStatusActive = 1, + cudaStreamCaptureStatusInvalidated = 2 + +}; + + + + + +enum __attribute__((device_builtin)) cudaStreamCaptureMode { + cudaStreamCaptureModeGlobal = 0, + cudaStreamCaptureModeThreadLocal = 1, + cudaStreamCaptureModeRelaxed = 2 +}; + +enum __attribute__((device_builtin)) cudaSynchronizationPolicy { + cudaSyncPolicyAuto = 1, + cudaSyncPolicySpin = 2, + cudaSyncPolicyYield = 3, + cudaSyncPolicyBlockingSync = 4 +}; + + + + +enum __attribute__((device_builtin)) cudaClusterSchedulingPolicy { + cudaClusterSchedulingPolicyDefault = 0, + cudaClusterSchedulingPolicySpread = 1, + cudaClusterSchedulingPolicyLoadBalancing = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaStreamUpdateCaptureDependenciesFlags { + cudaStreamAddCaptureDependencies = 0x0, + cudaStreamSetCaptureDependencies = 0x1 +}; + + + + +enum __attribute__((device_builtin)) cudaUserObjectFlags { + cudaUserObjectNoDestructorSync = 0x1 +}; + + + + +enum __attribute__((device_builtin)) cudaUserObjectRetainFlags { + cudaGraphUserObjectMove = 0x1 +}; + + + + +struct cudaGraphicsResource; + + + + +enum __attribute__((device_builtin)) cudaGraphicsRegisterFlags +{ + cudaGraphicsRegisterFlagsNone = 0, + cudaGraphicsRegisterFlagsReadOnly = 1, + cudaGraphicsRegisterFlagsWriteDiscard = 2, + cudaGraphicsRegisterFlagsSurfaceLoadStore = 4, + cudaGraphicsRegisterFlagsTextureGather = 8 +}; + + + + +enum __attribute__((device_builtin)) cudaGraphicsMapFlags +{ + cudaGraphicsMapFlagsNone = 0, + cudaGraphicsMapFlagsReadOnly = 1, + cudaGraphicsMapFlagsWriteDiscard = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaGraphicsCubeFace +{ + cudaGraphicsCubeFacePositiveX = 0x00, + cudaGraphicsCubeFaceNegativeX = 0x01, + cudaGraphicsCubeFacePositiveY = 0x02, + cudaGraphicsCubeFaceNegativeY = 0x03, + cudaGraphicsCubeFacePositiveZ = 0x04, + cudaGraphicsCubeFaceNegativeZ = 0x05 +}; + + + + +enum __attribute__((device_builtin)) cudaResourceType +{ + cudaResourceTypeArray = 0x00, + cudaResourceTypeMipmappedArray = 0x01, + cudaResourceTypeLinear = 0x02, + cudaResourceTypePitch2D = 0x03 +}; + + + + +enum __attribute__((device_builtin)) cudaResourceViewFormat +{ + cudaResViewFormatNone = 0x00, + cudaResViewFormatUnsignedChar1 = 0x01, + cudaResViewFormatUnsignedChar2 = 0x02, + cudaResViewFormatUnsignedChar4 = 0x03, + cudaResViewFormatSignedChar1 = 0x04, + cudaResViewFormatSignedChar2 = 0x05, + cudaResViewFormatSignedChar4 = 0x06, + cudaResViewFormatUnsignedShort1 = 0x07, + cudaResViewFormatUnsignedShort2 = 0x08, + cudaResViewFormatUnsignedShort4 = 0x09, + cudaResViewFormatSignedShort1 = 0x0a, + cudaResViewFormatSignedShort2 = 0x0b, + cudaResViewFormatSignedShort4 = 0x0c, + cudaResViewFormatUnsignedInt1 = 0x0d, + cudaResViewFormatUnsignedInt2 = 0x0e, + cudaResViewFormatUnsignedInt4 = 0x0f, + cudaResViewFormatSignedInt1 = 0x10, + cudaResViewFormatSignedInt2 = 0x11, + cudaResViewFormatSignedInt4 = 0x12, + cudaResViewFormatHalf1 = 0x13, + cudaResViewFormatHalf2 = 0x14, + cudaResViewFormatHalf4 = 0x15, + cudaResViewFormatFloat1 = 0x16, + cudaResViewFormatFloat2 = 0x17, + cudaResViewFormatFloat4 = 0x18, + cudaResViewFormatUnsignedBlockCompressed1 = 0x19, + cudaResViewFormatUnsignedBlockCompressed2 = 0x1a, + cudaResViewFormatUnsignedBlockCompressed3 = 0x1b, + cudaResViewFormatUnsignedBlockCompressed4 = 0x1c, + cudaResViewFormatSignedBlockCompressed4 = 0x1d, + cudaResViewFormatUnsignedBlockCompressed5 = 0x1e, + cudaResViewFormatSignedBlockCompressed5 = 0x1f, + cudaResViewFormatUnsignedBlockCompressed6H = 0x20, + cudaResViewFormatSignedBlockCompressed6H = 0x21, + cudaResViewFormatUnsignedBlockCompressed7 = 0x22 +}; + + + + +struct __attribute__((device_builtin)) cudaResourceDesc { + enum cudaResourceType resType; + + union { + struct { + cudaArray_t array; + } array; + struct { + cudaMipmappedArray_t mipmap; + } mipmap; + struct { + void *devPtr; + struct cudaChannelFormatDesc desc; + size_t sizeInBytes; + } linear; + struct { + void *devPtr; + struct cudaChannelFormatDesc desc; + size_t width; + size_t height; + size_t pitchInBytes; + } pitch2D; + } res; +}; + + + + +struct __attribute__((device_builtin)) cudaResourceViewDesc +{ + enum cudaResourceViewFormat format; + size_t width; + size_t height; + size_t depth; + unsigned int firstMipmapLevel; + unsigned int lastMipmapLevel; + unsigned int firstLayer; + unsigned int lastLayer; +}; + + + + +struct __attribute__((device_builtin)) cudaPointerAttributes +{ + + + + + enum cudaMemoryType type; +# 1603 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + int device; + + + + + + void *devicePointer; +# 1618 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + void *hostPointer; +}; + + + + +struct __attribute__((device_builtin)) cudaFuncAttributes +{ + + + + + + size_t sharedSizeBytes; + + + + + + size_t constSizeBytes; + + + + + size_t localSizeBytes; + + + + + + + int maxThreadsPerBlock; + + + + + int numRegs; + + + + + + + int ptxVersion; + + + + + + + int binaryVersion; + + + + + + int cacheModeCA; + + + + + + + int maxDynamicSharedSizeBytes; +# 1690 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + int preferredShmemCarveout; + + + + + + int clusterDimMustBeSet; +# 1707 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + int requiredClusterWidth; + int requiredClusterHeight; + int requiredClusterDepth; + + + + + + int clusterSchedulingPolicyPreference; +# 1737 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + int nonPortableClusterSizeAllowed; + + + + + int reserved[16]; +}; + + + + +enum __attribute__((device_builtin)) cudaFuncAttribute +{ + cudaFuncAttributeMaxDynamicSharedMemorySize = 8, + cudaFuncAttributePreferredSharedMemoryCarveout = 9, + cudaFuncAttributeClusterDimMustBeSet = 10, + cudaFuncAttributeRequiredClusterWidth = 11, + cudaFuncAttributeRequiredClusterHeight = 12, + cudaFuncAttributeRequiredClusterDepth = 13, + cudaFuncAttributeNonPortableClusterSizeAllowed = 14, + cudaFuncAttributeClusterSchedulingPolicyPreference = 15, + cudaFuncAttributeMax +}; + + + + +enum __attribute__((device_builtin)) cudaFuncCache +{ + cudaFuncCachePreferNone = 0, + cudaFuncCachePreferShared = 1, + cudaFuncCachePreferL1 = 2, + cudaFuncCachePreferEqual = 3 +}; + + + + + +enum __attribute__((device_builtin)) cudaSharedMemConfig +{ + cudaSharedMemBankSizeDefault = 0, + cudaSharedMemBankSizeFourByte = 1, + cudaSharedMemBankSizeEightByte = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaSharedCarveout { + cudaSharedmemCarveoutDefault = -1, + cudaSharedmemCarveoutMaxShared = 100, + cudaSharedmemCarveoutMaxL1 = 0 +}; + + + + +enum __attribute__((device_builtin)) cudaComputeMode +{ + cudaComputeModeDefault = 0, + cudaComputeModeExclusive = 1, + cudaComputeModeProhibited = 2, + cudaComputeModeExclusiveProcess = 3 +}; + + + + +enum __attribute__((device_builtin)) cudaLimit +{ + cudaLimitStackSize = 0x00, + cudaLimitPrintfFifoSize = 0x01, + cudaLimitMallocHeapSize = 0x02, + cudaLimitDevRuntimeSyncDepth = 0x03, + cudaLimitDevRuntimePendingLaunchCount = 0x04, + cudaLimitMaxL2FetchGranularity = 0x05, + cudaLimitPersistingL2CacheSize = 0x06 +}; + + + + +enum __attribute__((device_builtin)) cudaMemoryAdvise +{ + cudaMemAdviseSetReadMostly = 1, + cudaMemAdviseUnsetReadMostly = 2, + cudaMemAdviseSetPreferredLocation = 3, + cudaMemAdviseUnsetPreferredLocation = 4, + cudaMemAdviseSetAccessedBy = 5, + cudaMemAdviseUnsetAccessedBy = 6 +}; + + + + +enum __attribute__((device_builtin)) cudaMemRangeAttribute +{ + cudaMemRangeAttributeReadMostly = 1, + cudaMemRangeAttributePreferredLocation = 2, + cudaMemRangeAttributeAccessedBy = 3, + cudaMemRangeAttributeLastPrefetchLocation = 4 + , cudaMemRangeAttributePreferredLocationType = 5 + , cudaMemRangeAttributePreferredLocationId = 6 + , cudaMemRangeAttributeLastPrefetchLocationType = 7 + , cudaMemRangeAttributeLastPrefetchLocationId = 8 +}; + + + + +enum __attribute__((device_builtin)) cudaFlushGPUDirectRDMAWritesOptions { + cudaFlushGPUDirectRDMAWritesOptionHost = 1<<0, + cudaFlushGPUDirectRDMAWritesOptionMemOps = 1<<1 +}; + + + + +enum __attribute__((device_builtin)) cudaGPUDirectRDMAWritesOrdering { + cudaGPUDirectRDMAWritesOrderingNone = 0, + cudaGPUDirectRDMAWritesOrderingOwner = 100, + cudaGPUDirectRDMAWritesOrderingAllDevices = 200 +}; + + + + +enum __attribute__((device_builtin)) cudaFlushGPUDirectRDMAWritesScope { + cudaFlushGPUDirectRDMAWritesToOwner = 100, + cudaFlushGPUDirectRDMAWritesToAllDevices = 200 +}; + + + + +enum __attribute__((device_builtin)) cudaFlushGPUDirectRDMAWritesTarget { + cudaFlushGPUDirectRDMAWritesTargetCurrentDevice +}; + + + + + +enum __attribute__((device_builtin)) cudaDeviceAttr +{ + cudaDevAttrMaxThreadsPerBlock = 1, + cudaDevAttrMaxBlockDimX = 2, + cudaDevAttrMaxBlockDimY = 3, + cudaDevAttrMaxBlockDimZ = 4, + cudaDevAttrMaxGridDimX = 5, + cudaDevAttrMaxGridDimY = 6, + cudaDevAttrMaxGridDimZ = 7, + cudaDevAttrMaxSharedMemoryPerBlock = 8, + cudaDevAttrTotalConstantMemory = 9, + cudaDevAttrWarpSize = 10, + cudaDevAttrMaxPitch = 11, + cudaDevAttrMaxRegistersPerBlock = 12, + cudaDevAttrClockRate = 13, + cudaDevAttrTextureAlignment = 14, + cudaDevAttrGpuOverlap = 15, + cudaDevAttrMultiProcessorCount = 16, + cudaDevAttrKernelExecTimeout = 17, + cudaDevAttrIntegrated = 18, + cudaDevAttrCanMapHostMemory = 19, + cudaDevAttrComputeMode = 20, + cudaDevAttrMaxTexture1DWidth = 21, + cudaDevAttrMaxTexture2DWidth = 22, + cudaDevAttrMaxTexture2DHeight = 23, + cudaDevAttrMaxTexture3DWidth = 24, + cudaDevAttrMaxTexture3DHeight = 25, + cudaDevAttrMaxTexture3DDepth = 26, + cudaDevAttrMaxTexture2DLayeredWidth = 27, + cudaDevAttrMaxTexture2DLayeredHeight = 28, + cudaDevAttrMaxTexture2DLayeredLayers = 29, + cudaDevAttrSurfaceAlignment = 30, + cudaDevAttrConcurrentKernels = 31, + cudaDevAttrEccEnabled = 32, + cudaDevAttrPciBusId = 33, + cudaDevAttrPciDeviceId = 34, + cudaDevAttrTccDriver = 35, + cudaDevAttrMemoryClockRate = 36, + cudaDevAttrGlobalMemoryBusWidth = 37, + cudaDevAttrL2CacheSize = 38, + cudaDevAttrMaxThreadsPerMultiProcessor = 39, + cudaDevAttrAsyncEngineCount = 40, + cudaDevAttrUnifiedAddressing = 41, + cudaDevAttrMaxTexture1DLayeredWidth = 42, + cudaDevAttrMaxTexture1DLayeredLayers = 43, + cudaDevAttrMaxTexture2DGatherWidth = 45, + cudaDevAttrMaxTexture2DGatherHeight = 46, + cudaDevAttrMaxTexture3DWidthAlt = 47, + cudaDevAttrMaxTexture3DHeightAlt = 48, + cudaDevAttrMaxTexture3DDepthAlt = 49, + cudaDevAttrPciDomainId = 50, + cudaDevAttrTexturePitchAlignment = 51, + cudaDevAttrMaxTextureCubemapWidth = 52, + cudaDevAttrMaxTextureCubemapLayeredWidth = 53, + cudaDevAttrMaxTextureCubemapLayeredLayers = 54, + cudaDevAttrMaxSurface1DWidth = 55, + cudaDevAttrMaxSurface2DWidth = 56, + cudaDevAttrMaxSurface2DHeight = 57, + cudaDevAttrMaxSurface3DWidth = 58, + cudaDevAttrMaxSurface3DHeight = 59, + cudaDevAttrMaxSurface3DDepth = 60, + cudaDevAttrMaxSurface1DLayeredWidth = 61, + cudaDevAttrMaxSurface1DLayeredLayers = 62, + cudaDevAttrMaxSurface2DLayeredWidth = 63, + cudaDevAttrMaxSurface2DLayeredHeight = 64, + cudaDevAttrMaxSurface2DLayeredLayers = 65, + cudaDevAttrMaxSurfaceCubemapWidth = 66, + cudaDevAttrMaxSurfaceCubemapLayeredWidth = 67, + cudaDevAttrMaxSurfaceCubemapLayeredLayers = 68, + cudaDevAttrMaxTexture1DLinearWidth = 69, + cudaDevAttrMaxTexture2DLinearWidth = 70, + cudaDevAttrMaxTexture2DLinearHeight = 71, + cudaDevAttrMaxTexture2DLinearPitch = 72, + cudaDevAttrMaxTexture2DMipmappedWidth = 73, + cudaDevAttrMaxTexture2DMipmappedHeight = 74, + cudaDevAttrComputeCapabilityMajor = 75, + cudaDevAttrComputeCapabilityMinor = 76, + cudaDevAttrMaxTexture1DMipmappedWidth = 77, + cudaDevAttrStreamPrioritiesSupported = 78, + cudaDevAttrGlobalL1CacheSupported = 79, + cudaDevAttrLocalL1CacheSupported = 80, + cudaDevAttrMaxSharedMemoryPerMultiprocessor = 81, + cudaDevAttrMaxRegistersPerMultiprocessor = 82, + cudaDevAttrManagedMemory = 83, + cudaDevAttrIsMultiGpuBoard = 84, + cudaDevAttrMultiGpuBoardGroupID = 85, + cudaDevAttrHostNativeAtomicSupported = 86, + cudaDevAttrSingleToDoublePrecisionPerfRatio = 87, + cudaDevAttrPageableMemoryAccess = 88, + cudaDevAttrConcurrentManagedAccess = 89, + cudaDevAttrComputePreemptionSupported = 90, + cudaDevAttrCanUseHostPointerForRegisteredMem = 91, + cudaDevAttrReserved92 = 92, + cudaDevAttrReserved93 = 93, + cudaDevAttrReserved94 = 94, + cudaDevAttrCooperativeLaunch = 95, + cudaDevAttrCooperativeMultiDeviceLaunch = 96, + cudaDevAttrMaxSharedMemoryPerBlockOptin = 97, + cudaDevAttrCanFlushRemoteWrites = 98, + cudaDevAttrHostRegisterSupported = 99, + cudaDevAttrPageableMemoryAccessUsesHostPageTables = 100, + cudaDevAttrDirectManagedMemAccessFromHost = 101, + cudaDevAttrMaxBlocksPerMultiprocessor = 106, + cudaDevAttrMaxPersistingL2CacheSize = 108, + cudaDevAttrMaxAccessPolicyWindowSize = 109, + cudaDevAttrReservedSharedMemoryPerBlock = 111, + cudaDevAttrSparseCudaArraySupported = 112, + cudaDevAttrHostRegisterReadOnlySupported = 113, + cudaDevAttrTimelineSemaphoreInteropSupported = 114, + cudaDevAttrMaxTimelineSemaphoreInteropSupported = 114, + cudaDevAttrMemoryPoolsSupported = 115, + cudaDevAttrGPUDirectRDMASupported = 116, + cudaDevAttrGPUDirectRDMAFlushWritesOptions = 117, + cudaDevAttrGPUDirectRDMAWritesOrdering = 118, + cudaDevAttrMemoryPoolSupportedHandleTypes = 119, + cudaDevAttrClusterLaunch = 120, + cudaDevAttrDeferredMappingCudaArraySupported = 121, + cudaDevAttrReserved122 = 122, + cudaDevAttrReserved123 = 123, + cudaDevAttrReserved124 = 124, + cudaDevAttrIpcEventSupport = 125, + cudaDevAttrMemSyncDomainCount = 126, + cudaDevAttrReserved127 = 127, + cudaDevAttrReserved128 = 128, + cudaDevAttrReserved129 = 129, + cudaDevAttrNumaConfig = 130, + cudaDevAttrNumaId = 131, + cudaDevAttrReserved132 = 132, + cudaDevAttrMpsEnabled = 133, + cudaDevAttrHostNumaId = 134, + cudaDevAttrD3D12CigSupported = 135, + cudaDevAttrMax +}; + + + + +enum __attribute__((device_builtin)) cudaMemPoolAttr +{ +# 2028 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaMemPoolReuseFollowEventDependencies = 0x1, + + + + + + + cudaMemPoolReuseAllowOpportunistic = 0x2, + + + + + + + + cudaMemPoolReuseAllowInternalDependencies = 0x3, +# 2054 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaMemPoolAttrReleaseThreshold = 0x4, + + + + + + cudaMemPoolAttrReservedMemCurrent = 0x5, + + + + + + + cudaMemPoolAttrReservedMemHigh = 0x6, + + + + + + cudaMemPoolAttrUsedMemCurrent = 0x7, + + + + + + + cudaMemPoolAttrUsedMemHigh = 0x8 +}; + + + + +enum __attribute__((device_builtin)) cudaMemLocationType { + cudaMemLocationTypeInvalid = 0, + cudaMemLocationTypeDevice = 1 + , cudaMemLocationTypeHost = 2 + , cudaMemLocationTypeHostNuma = 3 + , cudaMemLocationTypeHostNumaCurrent = 4 +}; + + + + + + + +struct __attribute__((device_builtin)) cudaMemLocation { + enum cudaMemLocationType type; + int id; +}; + + + + +enum __attribute__((device_builtin)) cudaMemAccessFlags { + cudaMemAccessFlagsProtNone = 0, + cudaMemAccessFlagsProtRead = 1, + cudaMemAccessFlagsProtReadWrite = 3 +}; + + + + +struct __attribute__((device_builtin)) cudaMemAccessDesc { + struct cudaMemLocation location; + enum cudaMemAccessFlags flags; +}; + + + + +enum __attribute__((device_builtin)) cudaMemAllocationType { + cudaMemAllocationTypeInvalid = 0x0, + + + + cudaMemAllocationTypePinned = 0x1, + cudaMemAllocationTypeMax = 0x7FFFFFFF +}; + + + + +enum __attribute__((device_builtin)) cudaMemAllocationHandleType { + cudaMemHandleTypeNone = 0x0, + cudaMemHandleTypePosixFileDescriptor = 0x1, + cudaMemHandleTypeWin32 = 0x2, + cudaMemHandleTypeWin32Kmt = 0x4, + cudaMemHandleTypeFabric = 0x8 +}; + + + + +struct __attribute__((device_builtin)) cudaMemPoolProps { + enum cudaMemAllocationType allocType; + enum cudaMemAllocationHandleType handleTypes; + struct cudaMemLocation location; + + + + + + + void *win32SecurityAttributes; + size_t maxSize; + unsigned char reserved[56]; +}; + + + + +struct __attribute__((device_builtin)) cudaMemPoolPtrExportData { + unsigned char reserved[64]; +}; + + + + +struct __attribute__((device_builtin)) cudaMemAllocNodeParams { + + + + + struct cudaMemPoolProps poolProps; + const struct cudaMemAccessDesc *accessDescs; + size_t accessDescCount; + size_t bytesize; + void *dptr; +}; + + + + +struct __attribute__((device_builtin)) cudaMemAllocNodeParamsV2 { + + + + + struct cudaMemPoolProps poolProps; + const struct cudaMemAccessDesc *accessDescs; + size_t accessDescCount; + size_t bytesize; + void *dptr; +}; + + + + +struct __attribute__((device_builtin)) cudaMemFreeNodeParams { + void *dptr; +}; + + + + +enum __attribute__((device_builtin)) cudaGraphMemAttributeType { + + + + + cudaGraphMemAttrUsedMemCurrent = 0x0, + + + + + + + cudaGraphMemAttrUsedMemHigh = 0x1, + + + + + + + cudaGraphMemAttrReservedMemCurrent = 0x2, + + + + + + + cudaGraphMemAttrReservedMemHigh = 0x3 +}; + + + + + +enum __attribute__((device_builtin)) cudaDeviceP2PAttr { + cudaDevP2PAttrPerformanceRank = 1, + cudaDevP2PAttrAccessSupported = 2, + cudaDevP2PAttrNativeAtomicSupported = 3, + cudaDevP2PAttrCudaArrayAccessSupported = 4 +}; + + + + + + +struct __attribute__((device_builtin)) CUuuid_st { + char bytes[16]; +}; +typedef __attribute__((device_builtin)) struct CUuuid_st CUuuid; + +typedef __attribute__((device_builtin)) struct CUuuid_st cudaUUID_t; + + + + +struct __attribute__((device_builtin)) cudaDeviceProp +{ + char name[256]; + cudaUUID_t uuid; + char luid[8]; + unsigned int luidDeviceNodeMask; + size_t totalGlobalMem; + size_t sharedMemPerBlock; + int regsPerBlock; + int warpSize; + size_t memPitch; + int maxThreadsPerBlock; + int maxThreadsDim[3]; + int maxGridSize[3]; + int clockRate; + size_t totalConstMem; + int major; + int minor; + size_t textureAlignment; + size_t texturePitchAlignment; + int deviceOverlap; + int multiProcessorCount; + int kernelExecTimeoutEnabled; + int integrated; + int canMapHostMemory; + int computeMode; + int maxTexture1D; + int maxTexture1DMipmap; + int maxTexture1DLinear; + int maxTexture2D[2]; + int maxTexture2DMipmap[2]; + int maxTexture2DLinear[3]; + int maxTexture2DGather[2]; + int maxTexture3D[3]; + int maxTexture3DAlt[3]; + int maxTextureCubemap; + int maxTexture1DLayered[2]; + int maxTexture2DLayered[3]; + int maxTextureCubemapLayered[2]; + int maxSurface1D; + int maxSurface2D[2]; + int maxSurface3D[3]; + int maxSurface1DLayered[2]; + int maxSurface2DLayered[3]; + int maxSurfaceCubemap; + int maxSurfaceCubemapLayered[2]; + size_t surfaceAlignment; + int concurrentKernels; + int ECCEnabled; + int pciBusID; + int pciDeviceID; + int pciDomainID; + int tccDriver; + int asyncEngineCount; + int unifiedAddressing; + int memoryClockRate; + int memoryBusWidth; + int l2CacheSize; + int persistingL2CacheMaxSize; + int maxThreadsPerMultiProcessor; + int streamPrioritiesSupported; + int globalL1CacheSupported; + int localL1CacheSupported; + size_t sharedMemPerMultiprocessor; + int regsPerMultiprocessor; + int managedMemory; + int isMultiGpuBoard; + int multiGpuBoardGroupID; + int hostNativeAtomicSupported; + int singleToDoublePrecisionPerfRatio; + int pageableMemoryAccess; + int concurrentManagedAccess; + int computePreemptionSupported; + int canUseHostPointerForRegisteredMem; + int cooperativeLaunch; + int cooperativeMultiDeviceLaunch; + size_t sharedMemPerBlockOptin; + int pageableMemoryAccessUsesHostPageTables; + int directManagedMemAccessFromHost; + int maxBlocksPerMultiProcessor; + int accessPolicyMaxWindowSize; + size_t reservedSharedMemPerBlock; + int hostRegisterSupported; + int sparseCudaArraySupported; + int hostRegisterReadOnlySupported; + int timelineSemaphoreInteropSupported; + int memoryPoolsSupported; + int gpuDirectRDMASupported; + unsigned int gpuDirectRDMAFlushWritesOptions; + int gpuDirectRDMAWritesOrdering; + unsigned int memoryPoolSupportedHandleTypes; + int deferredMappingCudaArraySupported; + int ipcEventSupported; + int clusterLaunch; + int unifiedFunctionPointers; + int reserved2[2]; + int reserved1[1]; + int reserved[60]; +}; +# 2373 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef __attribute__((device_builtin)) struct __attribute__((device_builtin)) cudaIpcEventHandle_st +{ + char reserved[64]; +}cudaIpcEventHandle_t; + + + + +typedef __attribute__((device_builtin)) struct __attribute__((device_builtin)) cudaIpcMemHandle_st +{ + char reserved[64]; +}cudaIpcMemHandle_t; + + + + +typedef __attribute__((device_builtin)) struct __attribute__((device_builtin)) cudaMemFabricHandle_st +{ + char reserved[64]; +}cudaMemFabricHandle_t; + + + + +enum __attribute__((device_builtin)) cudaExternalMemoryHandleType { + + + + cudaExternalMemoryHandleTypeOpaqueFd = 1, + + + + cudaExternalMemoryHandleTypeOpaqueWin32 = 2, + + + + cudaExternalMemoryHandleTypeOpaqueWin32Kmt = 3, + + + + cudaExternalMemoryHandleTypeD3D12Heap = 4, + + + + cudaExternalMemoryHandleTypeD3D12Resource = 5, + + + + cudaExternalMemoryHandleTypeD3D11Resource = 6, + + + + cudaExternalMemoryHandleTypeD3D11ResourceKmt = 7, + + + + cudaExternalMemoryHandleTypeNvSciBuf = 8 +}; +# 2472 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +struct __attribute__((device_builtin)) cudaExternalMemoryHandleDesc { + + + + enum cudaExternalMemoryHandleType type; + union { + + + + + + int fd; +# 2499 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + + + + void *handle; + + + + + const void *name; + } win32; + + + + + const void *nvSciBufObject; + } handle; + + + + unsigned long long size; + + + + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalMemoryBufferDesc { + + + + unsigned long long offset; + + + + unsigned long long size; + + + + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalMemoryMipmappedArrayDesc { + + + + + unsigned long long offset; + + + + struct cudaChannelFormatDesc formatDesc; + + + + struct cudaExtent extent; + + + + + unsigned int flags; + + + + unsigned int numLevels; +}; + + + + +enum __attribute__((device_builtin)) cudaExternalSemaphoreHandleType { + + + + cudaExternalSemaphoreHandleTypeOpaqueFd = 1, + + + + cudaExternalSemaphoreHandleTypeOpaqueWin32 = 2, + + + + cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3, + + + + cudaExternalSemaphoreHandleTypeD3D12Fence = 4, + + + + cudaExternalSemaphoreHandleTypeD3D11Fence = 5, + + + + cudaExternalSemaphoreHandleTypeNvSciSync = 6, + + + + cudaExternalSemaphoreHandleTypeKeyedMutex = 7, + + + + cudaExternalSemaphoreHandleTypeKeyedMutexKmt = 8, + + + + cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9, + + + + cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10 +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreHandleDesc { + + + + enum cudaExternalSemaphoreHandleType type; + union { + + + + + + + int fd; +# 2649 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + + + + void *handle; + + + + + const void *name; + } win32; + + + + const void* nvSciSyncObj; + } handle; + + + + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreSignalParams_v1 { + struct { + + + + struct { + + + + unsigned long long value; + } fence; + union { + + + + + void *fence; + unsigned long long reserved; + } nvSciSync; + + + + struct { + + + + unsigned long long key; + } keyedMutex; + } params; +# 2713 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreWaitParams_v1 { + struct { + + + + struct { + + + + unsigned long long value; + } fence; + union { + + + + + void *fence; + unsigned long long reserved; + } nvSciSync; + + + + struct { + + + + unsigned long long key; + + + + unsigned int timeoutMs; + } keyedMutex; + } params; +# 2762 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned int flags; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreSignalParams{ + struct { + + + + struct { + + + + unsigned long long value; + } fence; + union { + + + + + void *fence; + unsigned long long reserved; + } nvSciSync; + + + + struct { + + + + unsigned long long key; + } keyedMutex; + unsigned int reserved[12]; + } params; +# 2808 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned int flags; + unsigned int reserved[16]; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreWaitParams { + struct { + + + + struct { + + + + unsigned long long value; + } fence; + union { + + + + + void *fence; + unsigned long long reserved; + } nvSciSync; + + + + struct { + + + + unsigned long long key; + + + + unsigned int timeoutMs; + } keyedMutex; + unsigned int reserved[10]; + } params; +# 2859 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned int flags; + unsigned int reserved[16]; +}; +# 2872 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef __attribute__((device_builtin)) enum cudaError cudaError_t; + + + + +typedef __attribute__((device_builtin)) struct CUstream_st *cudaStream_t; + + + + +typedef __attribute__((device_builtin)) struct CUevent_st *cudaEvent_t; + + + + +typedef __attribute__((device_builtin)) struct cudaGraphicsResource *cudaGraphicsResource_t; + + + + +typedef __attribute__((device_builtin)) struct CUexternalMemory_st *cudaExternalMemory_t; + + + + +typedef __attribute__((device_builtin)) struct CUexternalSemaphore_st *cudaExternalSemaphore_t; + + + + +typedef __attribute__((device_builtin)) struct CUgraph_st *cudaGraph_t; + + + + +typedef __attribute__((device_builtin)) struct CUgraphNode_st *cudaGraphNode_t; + + + + +typedef __attribute__((device_builtin)) struct CUuserObject_st *cudaUserObject_t; + + + + +typedef __attribute__((device_builtin)) unsigned long long cudaGraphConditionalHandle; + + + + +typedef __attribute__((device_builtin)) struct CUfunc_st *cudaFunction_t; + + + + +typedef __attribute__((device_builtin)) struct CUkern_st *cudaKernel_t; + + + + +typedef __attribute__((device_builtin)) struct CUmemPoolHandle_st *cudaMemPool_t; + + + + +enum __attribute__((device_builtin)) cudaCGScope { + cudaCGScopeInvalid = 0, + cudaCGScopeGrid = 1, + cudaCGScopeMultiGrid = 2 +}; + + + + +struct __attribute__((device_builtin)) cudaLaunchParams +{ + void *func; + dim3 gridDim; + dim3 blockDim; + void **args; + size_t sharedMem; + cudaStream_t stream; +}; + + + + +struct __attribute__((device_builtin)) cudaKernelNodeParams { + void* func; + dim3 gridDim; + dim3 blockDim; + unsigned int sharedMemBytes; + void **kernelParams; + void **extra; +}; + + + + +struct __attribute__((device_builtin)) cudaKernelNodeParamsV2 { + void* func; + + dim3 gridDim; + dim3 blockDim; + + + + + + unsigned int sharedMemBytes; + void **kernelParams; + void **extra; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreSignalNodeParams { + cudaExternalSemaphore_t* extSemArray; + const struct cudaExternalSemaphoreSignalParams* paramsArray; + unsigned int numExtSems; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreSignalNodeParamsV2 { + cudaExternalSemaphore_t* extSemArray; + const struct cudaExternalSemaphoreSignalParams* paramsArray; + unsigned int numExtSems; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreWaitNodeParams { + cudaExternalSemaphore_t* extSemArray; + const struct cudaExternalSemaphoreWaitParams* paramsArray; + unsigned int numExtSems; +}; + + + + +struct __attribute__((device_builtin)) cudaExternalSemaphoreWaitNodeParamsV2 { + cudaExternalSemaphore_t* extSemArray; + const struct cudaExternalSemaphoreWaitParams* paramsArray; + unsigned int numExtSems; +}; + +enum __attribute__((device_builtin)) cudaGraphConditionalHandleFlags { + cudaGraphCondAssignDefault = 1 +}; + + + + +enum __attribute__((device_builtin)) cudaGraphConditionalNodeType { + cudaGraphCondTypeIf = 0, + cudaGraphCondTypeWhile = 1, +}; + + + + +struct __attribute__((device_builtin)) cudaConditionalNodeParams { + cudaGraphConditionalHandle handle; + + + enum cudaGraphConditionalNodeType type; + unsigned int size; + cudaGraph_t *phGraph_out; +# 3053 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +}; + + + + +enum __attribute__((device_builtin)) cudaGraphNodeType { + cudaGraphNodeTypeKernel = 0x00, + cudaGraphNodeTypeMemcpy = 0x01, + cudaGraphNodeTypeMemset = 0x02, + cudaGraphNodeTypeHost = 0x03, + cudaGraphNodeTypeGraph = 0x04, + cudaGraphNodeTypeEmpty = 0x05, + cudaGraphNodeTypeWaitEvent = 0x06, + cudaGraphNodeTypeEventRecord = 0x07, + cudaGraphNodeTypeExtSemaphoreSignal = 0x08, + cudaGraphNodeTypeExtSemaphoreWait = 0x09, + cudaGraphNodeTypeMemAlloc = 0x0a, + cudaGraphNodeTypeMemFree = 0x0b, + cudaGraphNodeTypeConditional = 0x0d, +# 3088 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + cudaGraphNodeTypeCount +}; + + + + +struct __attribute__((device_builtin)) cudaChildGraphNodeParams { + cudaGraph_t graph; + +}; + + + + +struct __attribute__((device_builtin)) cudaEventRecordNodeParams { + cudaEvent_t event; +}; + + + + +struct __attribute__((device_builtin)) cudaEventWaitNodeParams { + cudaEvent_t event; +}; + + + + +struct __attribute__((device_builtin)) cudaGraphNodeParams { + enum cudaGraphNodeType type; + int reserved0[3]; + + union { + long long reserved1[29]; + struct cudaKernelNodeParamsV2 kernel; + struct cudaMemcpyNodeParams memcpy; + struct cudaMemsetParamsV2 memset; + struct cudaHostNodeParamsV2 host; + struct cudaChildGraphNodeParams graph; + struct cudaEventWaitNodeParams eventWait; + struct cudaEventRecordNodeParams eventRecord; + struct cudaExternalSemaphoreSignalNodeParamsV2 extSemSignal; + struct cudaExternalSemaphoreWaitNodeParamsV2 extSemWait; + struct cudaMemAllocNodeParamsV2 alloc; + struct cudaMemFreeNodeParams free; + struct cudaConditionalNodeParams conditional; + }; + + long long reserved2; +}; + + + + +typedef __attribute__((device_builtin)) enum cudaGraphDependencyType_enum { + cudaGraphDependencyTypeDefault = 0, + cudaGraphDependencyTypeProgrammatic = 1 + + + + +} cudaGraphDependencyType; + + + + + + +typedef __attribute__((device_builtin)) struct cudaGraphEdgeData_st { + unsigned char from_port; +# 3167 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + unsigned char to_port; + + + + + + + unsigned char type; + + + unsigned char reserved[5]; + +} cudaGraphEdgeData; +# 3200 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef struct CUgraphExec_st* cudaGraphExec_t; + + + + +enum __attribute__((device_builtin)) cudaGraphExecUpdateResult { + cudaGraphExecUpdateSuccess = 0x0, + cudaGraphExecUpdateError = 0x1, + cudaGraphExecUpdateErrorTopologyChanged = 0x2, + cudaGraphExecUpdateErrorNodeTypeChanged = 0x3, + cudaGraphExecUpdateErrorFunctionChanged = 0x4, + cudaGraphExecUpdateErrorParametersChanged = 0x5, + cudaGraphExecUpdateErrorNotSupported = 0x6, + cudaGraphExecUpdateErrorUnsupportedFunctionChange = 0x7, + cudaGraphExecUpdateErrorAttributesChanged = 0x8 +}; + + + + +typedef __attribute__((device_builtin)) enum cudaGraphInstantiateResult { + cudaGraphInstantiateSuccess = 0, + cudaGraphInstantiateError = 1, + cudaGraphInstantiateInvalidStructure = 2, + cudaGraphInstantiateNodeOperationNotSupported = 3, + cudaGraphInstantiateMultipleDevicesNotSupported = 4 +} cudaGraphInstantiateResult; + + + + +typedef __attribute__((device_builtin)) struct cudaGraphInstantiateParams_st +{ + unsigned long long flags; + cudaStream_t uploadStream; + cudaGraphNode_t errNode_out; + cudaGraphInstantiateResult result_out; +} cudaGraphInstantiateParams; + + + + +typedef __attribute__((device_builtin)) struct cudaGraphExecUpdateResultInfo_st { + + + + enum cudaGraphExecUpdateResult result; + + + + + + + cudaGraphNode_t errorNode; + + + + + cudaGraphNode_t errorFromNode; +} cudaGraphExecUpdateResultInfo; + + + + +typedef struct CUgraphDeviceUpdatableNode_st* cudaGraphDeviceNode_t; + + + + +enum __attribute__((device_builtin)) cudaGraphKernelNodeField +{ + cudaGraphKernelNodeFieldInvalid = 0, + cudaGraphKernelNodeFieldGridDim, + cudaGraphKernelNodeFieldParam, + cudaGraphKernelNodeFieldEnabled +}; + + + + +struct __attribute__((device_builtin)) cudaGraphKernelNodeUpdate { + cudaGraphDeviceNode_t node; + enum cudaGraphKernelNodeField field; + union { + + dim3 gridDim; + + + + + struct { + const void *pValue; + size_t offset; + size_t size; + } param; + unsigned int isEnabled; + } updateData; +}; + + + + + +enum __attribute__((device_builtin)) cudaGetDriverEntryPointFlags { + cudaEnableDefault = 0x0, + cudaEnableLegacyStream = 0x1, + cudaEnablePerThreadDefaultStream = 0x2 +}; + + + + +enum __attribute__((device_builtin)) cudaDriverEntryPointQueryResult { + cudaDriverEntryPointSuccess = 0, + cudaDriverEntryPointSymbolNotFound = 1, + cudaDriverEntryPointVersionNotSufficent = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaGraphDebugDotFlags { + cudaGraphDebugDotFlagsVerbose = 1<<0, + cudaGraphDebugDotFlagsKernelNodeParams = 1<<2, + cudaGraphDebugDotFlagsMemcpyNodeParams = 1<<3, + cudaGraphDebugDotFlagsMemsetNodeParams = 1<<4, + cudaGraphDebugDotFlagsHostNodeParams = 1<<5, + cudaGraphDebugDotFlagsEventNodeParams = 1<<6, + cudaGraphDebugDotFlagsExtSemasSignalNodeParams = 1<<7, + cudaGraphDebugDotFlagsExtSemasWaitNodeParams = 1<<8, + cudaGraphDebugDotFlagsKernelNodeAttributes = 1<<9, + cudaGraphDebugDotFlagsHandles = 1<<10 + ,cudaGraphDebugDotFlagsConditionalNodeParams = 1<<15, +}; + + + + +enum __attribute__((device_builtin)) cudaGraphInstantiateFlags { + cudaGraphInstantiateFlagAutoFreeOnLaunch = 1 + , cudaGraphInstantiateFlagUpload = 2 + + + , cudaGraphInstantiateFlagDeviceLaunch = 4 + + + , cudaGraphInstantiateFlagUseNodePriority = 8 + +}; +# 3366 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef __attribute__((device_builtin)) enum cudaLaunchMemSyncDomain { + cudaLaunchMemSyncDomainDefault = 0, + cudaLaunchMemSyncDomainRemote = 1 +} cudaLaunchMemSyncDomain; +# 3382 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +typedef __attribute__((device_builtin)) struct cudaLaunchMemSyncDomainMap_st { + unsigned char default_; + unsigned char remote; +} cudaLaunchMemSyncDomainMap; + + + + +typedef __attribute__((device_builtin)) enum cudaLaunchAttributeID { + cudaLaunchAttributeIgnore = 0 + , cudaLaunchAttributeAccessPolicyWindow = 1 + + , cudaLaunchAttributeCooperative = 2 + + , cudaLaunchAttributeSynchronizationPolicy = 3 + , cudaLaunchAttributeClusterDimension = 4 + + , cudaLaunchAttributeClusterSchedulingPolicyPreference = 5 + + , cudaLaunchAttributeProgrammaticStreamSerialization = 6 +# 3412 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributeProgrammaticEvent = 7 +# 3438 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributePriority = 8 + + , cudaLaunchAttributeMemSyncDomainMap = 9 + + , cudaLaunchAttributeMemSyncDomain = 10 + + , cudaLaunchAttributeLaunchCompletionEvent = 12 +# 3466 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributeDeviceUpdatableKernelNode = 13 +# 3494 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + , cudaLaunchAttributePreferredSharedMemoryCarveout = 14 + + + + + + +} cudaLaunchAttributeID; + + + + +typedef __attribute__((device_builtin)) union cudaLaunchAttributeValue { + char pad[64]; + struct cudaAccessPolicyWindow accessPolicyWindow; + int cooperative; + + enum cudaSynchronizationPolicy syncPolicy; +# 3525 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" + struct { + unsigned int x; + unsigned int y; + unsigned int z; + } clusterDim; + enum cudaClusterSchedulingPolicy clusterSchedulingPolicyPreference; + + + int programmaticStreamSerializationAllowed; + + struct { + cudaEvent_t event; + int flags; + + int triggerAtBlockStart; + } programmaticEvent; + int priority; + cudaLaunchMemSyncDomainMap memSyncDomainMap; + + + cudaLaunchMemSyncDomain memSyncDomain; + + struct { + cudaEvent_t event; + int flags; + + } launchCompletionEvent; + + struct { + int deviceUpdatable; + cudaGraphDeviceNode_t devNode; + } deviceUpdatableKernelNode; + unsigned int sharedMemCarveout; +} cudaLaunchAttributeValue; + + + + +typedef __attribute__((device_builtin)) struct cudaLaunchAttribute_st { + cudaLaunchAttributeID id; + char pad[8 - sizeof(cudaLaunchAttributeID)]; + cudaLaunchAttributeValue val; +} cudaLaunchAttribute; + + + + +typedef __attribute__((device_builtin)) struct cudaLaunchConfig_st { + dim3 gridDim; + dim3 blockDim; + size_t dynamicSmemBytes; + cudaStream_t stream; + cudaLaunchAttribute *attrs; + unsigned int numAttrs; +} cudaLaunchConfig_t; +# 3606 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_types.h" +enum __attribute__((device_builtin)) cudaDeviceNumaConfig { + cudaDeviceNumaConfigNone = 0, + cudaDeviceNumaConfigNumaNode, +}; + + + + +typedef struct cudaAsyncCallbackEntry* cudaAsyncCallbackHandle_t; + +struct cudaAsyncCallbackEntry; + + + + +typedef __attribute__((device_builtin)) enum cudaAsyncNotificationType_enum { + cudaAsyncNotificationTypeOverBudget = 0x1 +} cudaAsyncNotificationType; + + + + +typedef __attribute__((device_builtin)) struct cudaAsyncNotificationInfo +{ + cudaAsyncNotificationType type; + union { + struct { + unsigned long long bytesOverBudget; + } overBudget; + } info; +} cudaAsyncNotificationInfo_t; + +typedef void (*cudaAsyncCallback)(cudaAsyncNotificationInfo_t*, void*, cudaAsyncCallbackHandle_t); +# 60 "/usr/local/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 2 + + +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/surface_types.h" 1 +# 86 "/usr/local/cuda/bin/../targets/x86_64-linux/include/surface_types.h" +enum __attribute__((device_builtin)) cudaSurfaceBoundaryMode +{ + cudaBoundaryModeZero = 0, + cudaBoundaryModeClamp = 1, + cudaBoundaryModeTrap = 2 +}; + + + + +enum __attribute__((device_builtin)) cudaSurfaceFormatMode +{ + cudaFormatModeForced = 0, + cudaFormatModeAuto = 1 +}; + + + + +typedef __attribute__((device_builtin)) unsigned long long cudaSurfaceObject_t; +# 63 "/usr/local/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/texture_types.h" 1 +# 86 "/usr/local/cuda/bin/../targets/x86_64-linux/include/texture_types.h" +enum __attribute__((device_builtin)) cudaTextureAddressMode +{ + cudaAddressModeWrap = 0, + cudaAddressModeClamp = 1, + cudaAddressModeMirror = 2, + cudaAddressModeBorder = 3 +}; + + + + +enum __attribute__((device_builtin)) cudaTextureFilterMode +{ + cudaFilterModePoint = 0, + cudaFilterModeLinear = 1 +}; + + + + +enum __attribute__((device_builtin)) cudaTextureReadMode +{ + cudaReadModeElementType = 0, + cudaReadModeNormalizedFloat = 1 +}; + + + + +struct __attribute__((device_builtin)) cudaTextureDesc +{ + + + + enum cudaTextureAddressMode addressMode[3]; + + + + enum cudaTextureFilterMode filterMode; + + + + enum cudaTextureReadMode readMode; + + + + int sRGB; + + + + float borderColor[4]; + + + + int normalizedCoords; + + + + unsigned int maxAnisotropy; + + + + enum cudaTextureFilterMode mipmapFilterMode; + + + + float mipmapLevelBias; + + + + float minMipmapLevelClamp; + + + + float maxMipmapLevelClamp; + + + + int disableTrilinearOptimization; + + + + int seamlessCubemap; +}; + + + + +typedef __attribute__((device_builtin)) unsigned long long cudaTextureObject_t; +# 64 "/usr/local/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 2 +# 91 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/library_types.h" 1 +# 57 "/usr/local/cuda/bin/../targets/x86_64-linux/include/library_types.h" +typedef enum cudaDataType_t +{ + CUDA_R_16F = 2, + CUDA_C_16F = 6, + CUDA_R_16BF = 14, + CUDA_C_16BF = 15, + CUDA_R_32F = 0, + CUDA_C_32F = 4, + CUDA_R_64F = 1, + CUDA_C_64F = 5, + CUDA_R_4I = 16, + CUDA_C_4I = 17, + CUDA_R_4U = 18, + CUDA_C_4U = 19, + CUDA_R_8I = 3, + CUDA_C_8I = 7, + CUDA_R_8U = 8, + CUDA_C_8U = 9, + CUDA_R_16I = 20, + CUDA_C_16I = 21, + CUDA_R_16U = 22, + CUDA_C_16U = 23, + CUDA_R_32I = 10, + CUDA_C_32I = 11, + CUDA_R_32U = 12, + CUDA_C_32U = 13, + CUDA_R_64I = 24, + CUDA_C_64I = 25, + CUDA_R_64U = 26, + CUDA_C_64U = 27, + CUDA_R_8F_E4M3 = 28, + CUDA_R_8F_E5M2 = 29, +} cudaDataType; + + +typedef enum libraryPropertyType_t +{ + MAJOR_VERSION, + MINOR_VERSION, + PATCH_LEVEL +} libraryPropertyType; +# 92 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + + +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" 1 +# 61 "/usr/local/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 1 +# 148 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 149 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 2 + +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 151 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 2 + + +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" 1 +# 54 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +# 1 "/usr/include/c++/11/stdlib.h" 1 3 +# 36 "/usr/include/c++/11/stdlib.h" 3 +# 1 "/usr/include/c++/11/cstdlib" 1 3 +# 39 "/usr/include/c++/11/cstdlib" 3 + +# 40 "/usr/include/c++/11/cstdlib" 3 + +# 1 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 1 3 +# 278 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 3 + +# 278 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 3 +namespace std +{ + typedef long unsigned int size_t; + typedef long int ptrdiff_t; + + + typedef decltype(nullptr) nullptr_t; + +} +# 300 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 3 +namespace std +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +namespace __gnu_cxx +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +# 586 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 3 +# 1 "/usr/include/x86_64-linux-gnu/c++/11/bits/os_defines.h" 1 3 +# 587 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 2 3 + + +# 1 "/usr/include/x86_64-linux-gnu/c++/11/bits/cpu_defines.h" 1 3 +# 590 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 2 3 +# 777 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 3 +# 1 "/usr/include/c++/11/pstl/pstl_config.h" 1 3 +# 778 "/usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h" 2 3 +# 42 "/usr/include/c++/11/cstdlib" 2 3 +# 75 "/usr/include/c++/11/cstdlib" 3 +# 1 "/usr/include/stdlib.h" 1 3 4 +# 26 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/stdlib.h" 2 3 4 + + + + + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4 +# 33 "/usr/include/stdlib.h" 2 3 4 + +extern "C" { + + + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 1 3 4 +# 41 "/usr/include/stdlib.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 1 3 4 +# 42 "/usr/include/stdlib.h" 2 3 4 +# 56 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 1 3 4 +# 74 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4 +typedef _Complex float __cfloat128 __attribute__ ((__mode__ (__TC__))); +# 86 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4 +typedef __float128 _Float128; +# 119 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4 +# 25 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 2 3 4 +# 214 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4 +typedef float _Float32; +# 251 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4 +typedef double _Float64; +# 268 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4 +typedef double _Float32x; +# 285 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4 +typedef long double _Float64x; +# 120 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 2 3 4 +# 57 "/usr/include/stdlib.h" 2 3 4 + + +typedef struct + { + int quot; + int rem; + } div_t; + + + +typedef struct + { + long int quot; + long int rem; + } ldiv_t; + + + + + +__extension__ typedef struct + { + long long int quot; + long long int rem; + } lldiv_t; +# 98 "/usr/include/stdlib.h" 3 4 +extern size_t __ctype_get_mb_cur_max (void) noexcept (true) ; + + + +extern double atof (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern int atoi (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern long int atol (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + +__extension__ extern long long int atoll (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + +extern double strtod (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern float strtof (const char *__restrict __nptr, + char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern long double strtold (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 141 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float64 strtof64 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float128 strtof128 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float32x strtof32x (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float64x strtof64x (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 177 "/usr/include/stdlib.h" 3 4 +extern long int strtol (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern unsigned long int strtoul (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +__extension__ +extern long long int strtoq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtouq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +__extension__ +extern long long int strtoll (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtoull (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern int strfromd (char *__dest, size_t __size, const char *__format, + double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfromf (char *__dest, size_t __size, const char *__format, + float __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfroml (char *__dest, size_t __size, const char *__format, + long double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 233 "/usr/include/stdlib.h" 3 4 +extern int strfromf32 (char *__dest, size_t __size, const char * __format, + _Float32 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64 (char *__dest, size_t __size, const char * __format, + _Float64 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf128 (char *__dest, size_t __size, const char * __format, + _Float128 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf32x (char *__dest, size_t __size, const char * __format, + _Float32x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64x (char *__dest, size_t __size, const char * __format, + _Float64x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 275 "/usr/include/stdlib.h" 3 4 +extern long int strtol_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +extern unsigned long int strtoul_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +extern double strtod_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern float strtof_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern long double strtold_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 317 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64 strtof64_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float128 strtof128_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float32x strtof32x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64x strtof64x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 386 "/usr/include/stdlib.h" 3 4 +extern char *l64a (long int __n) noexcept (true) ; + + +extern long int a64l (const char *__s) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + + +# 1 "/usr/include/x86_64-linux-gnu/sys/types.h" 1 3 4 +# 27 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 +extern "C" { + + + + + +typedef __u_char u_char; +typedef __u_short u_short; +typedef __u_int u_int; +typedef __u_long u_long; +typedef __quad_t quad_t; +typedef __u_quad_t u_quad_t; +typedef __fsid_t fsid_t; + + +typedef __loff_t loff_t; + + + + +typedef __ino_t ino_t; + + + + + + +typedef __ino64_t ino64_t; + + + + +typedef __dev_t dev_t; + + + + +typedef __gid_t gid_t; + + + + +typedef __mode_t mode_t; + + + + +typedef __nlink_t nlink_t; + + + + +typedef __uid_t uid_t; + + + + + +typedef __off_t off_t; + + + + + + +typedef __off64_t off64_t; + + + + +typedef __pid_t pid_t; + + + + + +typedef __id_t id_t; + + + + +typedef __ssize_t ssize_t; + + + + + +typedef __daddr_t daddr_t; +typedef __caddr_t caddr_t; + + + + + +typedef __key_t key_t; + + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/clock_t.h" 1 3 4 + + + + + + +typedef __clock_t clock_t; +# 127 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h" 1 3 4 + + + + + + +typedef __clockid_t clockid_t; +# 129 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/types/time_t.h" 1 3 4 +# 10 "/usr/include/x86_64-linux-gnu/bits/types/time_t.h" 3 4 +typedef __time_t time_t; +# 130 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/types/timer_t.h" 1 3 4 + + + + + + +typedef __timer_t timer_t; +# 131 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + + + +typedef __useconds_t useconds_t; + + + +typedef __suseconds_t suseconds_t; + + + + + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4 +# 145 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + + + +typedef unsigned long int ulong; +typedef unsigned short int ushort; +typedef unsigned int uint; + + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 3 4 +typedef __int8_t int8_t; +typedef __int16_t int16_t; +typedef __int32_t int32_t; +typedef __int64_t int64_t; +# 156 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + + +typedef __uint8_t u_int8_t; +typedef __uint16_t u_int16_t; +typedef __uint32_t u_int32_t; +typedef __uint64_t u_int64_t; + + +typedef int register_t __attribute__ ((__mode__ (__word__))); +# 176 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 +# 1 "/usr/include/endian.h" 1 3 4 +# 35 "/usr/include/endian.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 1 3 4 +# 33 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4 +static __inline __uint16_t +__bswap_16 (__uint16_t __bsx) +{ + + return __builtin_bswap16 (__bsx); + + + +} + + + + + + +static __inline __uint32_t +__bswap_32 (__uint32_t __bsx) +{ + + return __builtin_bswap32 (__bsx); + + + +} +# 69 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4 +__extension__ static __inline __uint64_t +__bswap_64 (__uint64_t __bsx) +{ + + return __builtin_bswap64 (__bsx); + + + +} +# 36 "/usr/include/endian.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 1 3 4 +# 32 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 3 4 +static __inline __uint16_t +__uint16_identity (__uint16_t __x) +{ + return __x; +} + +static __inline __uint32_t +__uint32_identity (__uint32_t __x) +{ + return __x; +} + +static __inline __uint64_t +__uint64_identity (__uint64_t __x) +{ + return __x; +} +# 37 "/usr/include/endian.h" 2 3 4 +# 177 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + + +# 1 "/usr/include/x86_64-linux-gnu/sys/select.h" 1 3 4 +# 30 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/select.h" 1 3 4 +# 31 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 + + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h" 1 3 4 + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h" 1 3 4 + + + + +typedef struct +{ + unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; +} __sigset_t; +# 5 "/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h" 2 3 4 + + +typedef __sigset_t sigset_t; +# 34 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h" 1 3 4 + + + + + + + +struct timeval +{ + + + + + __time_t tv_sec; + __suseconds_t tv_usec; + +}; +# 38 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 1 3 4 +# 11 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4 +struct timespec +{ + + + + __time_t tv_sec; + + + + + __syscall_slong_t tv_nsec; +# 31 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4 +}; +# 40 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 +# 49 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +typedef long int __fd_mask; +# 59 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +typedef struct + { + + + + __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))]; + + + + + + } fd_set; + + + + + + +typedef __fd_mask fd_mask; +# 91 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +extern "C" { +# 102 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +extern int select (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + struct timeval *__restrict __timeout); +# 127 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +extern int pselect (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + const struct timespec *__restrict __timeout, + const __sigset_t *__restrict __sigmask); +# 153 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 +} +# 180 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + + + + + +typedef __blksize_t blksize_t; + + + + + + +typedef __blkcnt_t blkcnt_t; + + + +typedef __fsblkcnt_t fsblkcnt_t; + + + +typedef __fsfilcnt_t fsfilcnt_t; +# 219 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 +typedef __blkcnt64_t blkcnt64_t; +typedef __fsblkcnt64_t fsblkcnt64_t; +typedef __fsfilcnt64_t fsfilcnt64_t; + + + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 1 3 4 +# 23 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 1 3 4 +# 44 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 1 3 4 +# 21 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 +# 22 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 2 3 4 +# 45 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4 + +# 1 "/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h" 1 3 4 +# 25 "/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h" 3 4 +typedef union +{ + __extension__ unsigned long long int __value64; + struct + { + unsigned int __low; + unsigned int __high; + } __value32; +} __atomic_wide_counter; +# 47 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4 + + + + +typedef struct __pthread_internal_list +{ + struct __pthread_internal_list *__prev; + struct __pthread_internal_list *__next; +} __pthread_list_t; + +typedef struct __pthread_internal_slist +{ + struct __pthread_internal_slist *__next; +} __pthread_slist_t; +# 76 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 1 3 4 +# 22 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 3 4 +struct __pthread_mutex_s +{ + int __lock; + unsigned int __count; + int __owner; + + unsigned int __nusers; + + + + int __kind; + + short __spins; + short __elision; + __pthread_list_t __list; +# 53 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 3 4 +}; +# 77 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4 +# 89 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 1 3 4 +# 23 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 3 4 +struct __pthread_rwlock_arch_t +{ + unsigned int __readers; + unsigned int __writers; + unsigned int __wrphase_futex; + unsigned int __writers_futex; + unsigned int __pad3; + unsigned int __pad4; + + int __cur_writer; + int __shared; + signed char __rwelision; + + + + + unsigned char __pad1[7]; + + + unsigned long int __pad2; + + + unsigned int __flags; +# 55 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 3 4 +}; +# 90 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4 + + + + +struct __pthread_cond_s +{ + __atomic_wide_counter __wseq; + __atomic_wide_counter __g1_start; + unsigned int __g_refs[2] ; + unsigned int __g_size[2]; + unsigned int __g1_orig_size; + unsigned int __wrefs; + unsigned int __g_signals[2]; +}; + +typedef unsigned int __tss_t; +typedef unsigned long int __thrd_t; + +typedef struct +{ + int __data ; +} __once_flag; +# 24 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 2 3 4 + + + +typedef unsigned long int pthread_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_mutexattr_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_condattr_t; + + + +typedef unsigned int pthread_key_t; + + + +typedef int pthread_once_t; + + +union pthread_attr_t +{ + char __size[56]; + long int __align; +}; + +typedef union pthread_attr_t pthread_attr_t; + + + + +typedef union +{ + struct __pthread_mutex_s __data; + char __size[40]; + long int __align; +} pthread_mutex_t; + + +typedef union +{ + struct __pthread_cond_s __data; + char __size[48]; + __extension__ long long int __align; +} pthread_cond_t; + + + + + +typedef union +{ + struct __pthread_rwlock_arch_t __data; + char __size[56]; + long int __align; +} pthread_rwlock_t; + +typedef union +{ + char __size[8]; + long int __align; +} pthread_rwlockattr_t; + + + + + +typedef volatile int pthread_spinlock_t; + + + + +typedef union +{ + char __size[32]; + long int __align; +} pthread_barrier_t; + +typedef union +{ + char __size[4]; + int __align; +} pthread_barrierattr_t; +# 228 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 + + +} +# 396 "/usr/include/stdlib.h" 2 3 4 + + + + + + +extern long int random (void) noexcept (true); + + +extern void srandom (unsigned int __seed) noexcept (true); + + + + + +extern char *initstate (unsigned int __seed, char *__statebuf, + size_t __statelen) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + +extern char *setstate (char *__statebuf) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + + +struct random_data + { + int32_t *fptr; + int32_t *rptr; + int32_t *state; + int rand_type; + int rand_deg; + int rand_sep; + int32_t *end_ptr; + }; + +extern int random_r (struct random_data *__restrict __buf, + int32_t *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern int srandom_r (unsigned int __seed, struct random_data *__buf) + noexcept (true) __attribute__ ((__nonnull__ (2))); + +extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, + size_t __statelen, + struct random_data *__restrict __buf) + noexcept (true) __attribute__ ((__nonnull__ (2, 4))); + +extern int setstate_r (char *__restrict __statebuf, + struct random_data *__restrict __buf) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern int rand (void) noexcept (true); + +extern void srand (unsigned int __seed) noexcept (true); + + + +extern int rand_r (unsigned int *__seed) noexcept (true); + + + + + + + +extern double drand48 (void) noexcept (true); +extern double erand48 (unsigned short int __xsubi[3]) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern long int lrand48 (void) noexcept (true); +extern long int nrand48 (unsigned short int __xsubi[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern long int mrand48 (void) noexcept (true); +extern long int jrand48 (unsigned short int __xsubi[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern void srand48 (long int __seedval) noexcept (true); +extern unsigned short int *seed48 (unsigned short int __seed16v[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); +extern void lcong48 (unsigned short int __param[7]) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +struct drand48_data + { + unsigned short int __x[3]; + unsigned short int __old_x[3]; + unsigned short int __c; + unsigned short int __init; + __extension__ unsigned long long int __a; + + }; + + +extern int drand48_r (struct drand48_data *__restrict __buffer, + double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int erand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int lrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int nrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int mrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int jrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int srand48_r (long int __seedval, struct drand48_data *__buffer) + noexcept (true) __attribute__ ((__nonnull__ (2))); + +extern int seed48_r (unsigned short int __seed16v[3], + struct drand48_data *__buffer) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern int lcong48_r (unsigned short int __param[7], + struct drand48_data *__buffer) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern void *malloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) + __attribute__ ((__alloc_size__ (1))) ; + +extern void *calloc (size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1, 2))) ; + + + + + + +extern void *realloc (void *__ptr, size_t __size) + noexcept (true) __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2))); + + +extern void free (void *__ptr) noexcept (true); + + + + + + + +extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__warn_unused_result__)) + __attribute__ ((__alloc_size__ (2, 3))) + __attribute__ ((__malloc__ (__builtin_free, 1))); + + +extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__malloc__ (reallocarray, 1))); + + + +# 1 "/usr/include/alloca.h" 1 3 4 +# 24 "/usr/include/alloca.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4 +# 25 "/usr/include/alloca.h" 2 3 4 + +extern "C" { + + + + + +extern void *alloca (size_t __size) noexcept (true); + + + + + +} +# 575 "/usr/include/stdlib.h" 2 3 4 + + + + + +extern void *valloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) + __attribute__ ((__alloc_size__ (1))) ; + + + + +extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size) + noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + +extern void *aligned_alloc (size_t __alignment, size_t __size) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_align__ (1))) + __attribute__ ((__alloc_size__ (2))) ; + + + +extern void abort (void) noexcept (true) __attribute__ ((__noreturn__)); + + + +extern int atexit (void (*__func) (void)) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern "C++" int at_quick_exit (void (*__func) (void)) + noexcept (true) __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1))); +# 617 "/usr/include/stdlib.h" 3 4 +extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern void exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + + +extern void quick_exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + + +extern void _Exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + +extern char *getenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + +extern char *secure_getenv (const char *__name) + noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + + + +extern int putenv (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern int setenv (const char *__name, const char *__value, int __replace) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + +extern int unsetenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern int clearenv (void) noexcept (true); +# 682 "/usr/include/stdlib.h" 3 4 +extern char *mktemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))); +# 695 "/usr/include/stdlib.h" 3 4 +extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 705 "/usr/include/stdlib.h" 3 4 +extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 717 "/usr/include/stdlib.h" 3 4 +extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ; +# 727 "/usr/include/stdlib.h" 3 4 +extern int mkstemps64 (char *__template, int __suffixlen) + __attribute__ ((__nonnull__ (1))) ; +# 738 "/usr/include/stdlib.h" 3 4 +extern char *mkdtemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))) ; +# 749 "/usr/include/stdlib.h" 3 4 +extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 759 "/usr/include/stdlib.h" 3 4 +extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 769 "/usr/include/stdlib.h" 3 4 +extern int mkostemps (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 781 "/usr/include/stdlib.h" 3 4 +extern int mkostemps64 (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 791 "/usr/include/stdlib.h" 3 4 +extern int system (const char *__command) ; + + + + + +extern char *canonicalize_file_name (const char *__name) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__malloc__)) + __attribute__ ((__malloc__ (__builtin_free, 1))) ; +# 808 "/usr/include/stdlib.h" 3 4 +extern char *realpath (const char *__restrict __name, + char *__restrict __resolved) noexcept (true) ; + + + + + + +typedef int (*__compar_fn_t) (const void *, const void *); + + +typedef __compar_fn_t comparison_fn_t; + + + +typedef int (*__compar_d_fn_t) (const void *, const void *, void *); + + + + +extern void *bsearch (const void *__key, const void *__base, + size_t __nmemb, size_t __size, __compar_fn_t __compar) + __attribute__ ((__nonnull__ (1, 2, 5))) ; + + + + + + + +extern void qsort (void *__base, size_t __nmemb, size_t __size, + __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4))); + +extern void qsort_r (void *__base, size_t __nmemb, size_t __size, + __compar_d_fn_t __compar, void *__arg) + __attribute__ ((__nonnull__ (1, 4))); + + + + +extern int abs (int __x) noexcept (true) __attribute__ ((__const__)) ; +extern long int labs (long int __x) noexcept (true) __attribute__ ((__const__)) ; + + +__extension__ extern long long int llabs (long long int __x) + noexcept (true) __attribute__ ((__const__)) ; + + + + + + +extern div_t div (int __numer, int __denom) + noexcept (true) __attribute__ ((__const__)) ; +extern ldiv_t ldiv (long int __numer, long int __denom) + noexcept (true) __attribute__ ((__const__)) ; + + +__extension__ extern lldiv_t lldiv (long long int __numer, + long long int __denom) + noexcept (true) __attribute__ ((__const__)) ; +# 880 "/usr/include/stdlib.h" 3 4 +extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *gcvt (double __value, int __ndigit, char *__buf) + noexcept (true) __attribute__ ((__nonnull__ (3))) ; + + + + +extern char *qecvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qfcvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qgcvt (long double __value, int __ndigit, char *__buf) + noexcept (true) __attribute__ ((__nonnull__ (3))) ; + + + + +extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); +extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); + +extern int qecvt_r (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign, + char *__restrict __buf, size_t __len) + noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); +extern int qfcvt_r (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign, + char *__restrict __buf, size_t __len) + noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); + + + + + +extern int mblen (const char *__s, size_t __n) noexcept (true); + + +extern int mbtowc (wchar_t *__restrict __pwc, + const char *__restrict __s, size_t __n) noexcept (true); + + +extern int wctomb (char *__s, wchar_t __wchar) noexcept (true); + + + +extern size_t mbstowcs (wchar_t *__restrict __pwcs, + const char *__restrict __s, size_t __n) noexcept (true) + __attribute__ ((__access__ (__read_only__, 2))); + +extern size_t wcstombs (char *__restrict __s, + const wchar_t *__restrict __pwcs, size_t __n) + noexcept (true) + __attribute__ ((__access__ (__write_only__, 1, 3))) + __attribute__ ((__access__ (__read_only__, 2))); + + + + + + +extern int rpmatch (const char *__response) noexcept (true) __attribute__ ((__nonnull__ (1))) ; +# 967 "/usr/include/stdlib.h" 3 4 +extern int getsubopt (char **__restrict __optionp, + char *const *__restrict __tokens, + char **__restrict __valuep) + noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))) ; + + + + + + + +extern int posix_openpt (int __oflag) ; + + + + + + + +extern int grantpt (int __fd) noexcept (true); + + + +extern int unlockpt (int __fd) noexcept (true); + + + + +extern char *ptsname (int __fd) noexcept (true) ; + + + + + + +extern int ptsname_r (int __fd, char *__buf, size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3))); + + +extern int getpt (void); + + + + + + +extern int getloadavg (double __loadavg[], int __nelem) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 1023 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/stdlib-float.h" 1 3 4 +# 1024 "/usr/include/stdlib.h" 2 3 4 +# 1035 "/usr/include/stdlib.h" 3 4 +} +# 76 "/usr/include/c++/11/cstdlib" 2 3 + +# 1 "/usr/include/c++/11/bits/std_abs.h" 1 3 +# 33 "/usr/include/c++/11/bits/std_abs.h" 3 + +# 34 "/usr/include/c++/11/bits/std_abs.h" 3 +# 46 "/usr/include/c++/11/bits/std_abs.h" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::abs; + + + inline long + abs(long __i) { return __builtin_labs(__i); } + + + + inline long long + abs(long long __x) { return __builtin_llabs (__x); } +# 70 "/usr/include/c++/11/bits/std_abs.h" 3 + inline constexpr double + abs(double __x) + { return __builtin_fabs(__x); } + + inline constexpr float + abs(float __x) + { return __builtin_fabsf(__x); } + + inline constexpr long double + abs(long double __x) + { return __builtin_fabsl(__x); } + + + + inline constexpr __int128 + abs(__int128 __x) { return __x >= 0 ? __x : -__x; } +# 107 "/usr/include/c++/11/bits/std_abs.h" 3 + +} +} +# 78 "/usr/include/c++/11/cstdlib" 2 3 +# 121 "/usr/include/c++/11/cstdlib" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::div_t; + using ::ldiv_t; + + using ::abort; + + using ::aligned_alloc; + + using ::atexit; + + + using ::at_quick_exit; + + + using ::atof; + using ::atoi; + using ::atol; + using ::bsearch; + using ::calloc; + using ::div; + using ::exit; + using ::free; + using ::getenv; + using ::labs; + using ::ldiv; + using ::malloc; + + using ::mblen; + using ::mbstowcs; + using ::mbtowc; + + using ::qsort; + + + using ::quick_exit; + + + using ::rand; + using ::realloc; + using ::srand; + using ::strtod; + using ::strtol; + using ::strtoul; + using ::system; + + using ::wcstombs; + using ::wctomb; + + + + inline ldiv_t + div(long __i, long __j) { return ldiv(__i, __j); } + + + + +} +# 195 "/usr/include/c++/11/cstdlib" 3 +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + using ::lldiv_t; + + + + + + using ::_Exit; + + + + using ::llabs; + + inline lldiv_t + div(long long __n, long long __d) + { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; } + + using ::lldiv; +# 227 "/usr/include/c++/11/cstdlib" 3 + using ::atoll; + using ::strtoll; + using ::strtoull; + + using ::strtof; + using ::strtold; + + +} + +namespace std +{ + + using ::__gnu_cxx::lldiv_t; + + using ::__gnu_cxx::_Exit; + + using ::__gnu_cxx::llabs; + using ::__gnu_cxx::div; + using ::__gnu_cxx::lldiv; + + using ::__gnu_cxx::atoll; + using ::__gnu_cxx::strtof; + using ::__gnu_cxx::strtoll; + using ::__gnu_cxx::strtoull; + using ::__gnu_cxx::strtold; +} + + + +} +# 37 "/usr/include/c++/11/stdlib.h" 2 3 + +using std::abort; +using std::atexit; +using std::exit; + + + using std::at_quick_exit; + + + using std::quick_exit; + + + + +using std::div_t; +using std::ldiv_t; + +using std::abs; +using std::atof; +using std::atoi; +using std::atol; +using std::bsearch; +using std::calloc; +using std::div; +using std::free; +using std::getenv; +using std::labs; +using std::ldiv; +using std::malloc; + +using std::mblen; +using std::mbstowcs; +using std::mbtowc; + +using std::qsort; +using std::rand; +using std::realloc; +using std::srand; +using std::strtod; +using std::strtol; +using std::strtoul; +using std::system; + +using std::wcstombs; +using std::wctomb; +# 55 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" 2 +# 173 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 174 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" 2 +# 184 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" + +# 184 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern "C" +{ + + + + + +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaDeviceSynchronizeDeprecationAvoidance(void); +# 244 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2DeviceGetAttribute(int *value, enum cudaDeviceAttr attr, int device); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2DeviceGetLimit(size_t *pValue, enum cudaLimit limit); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2DeviceGetCacheConfig(enum cudaFuncCache *pCacheConfig); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2DeviceGetSharedMemConfig(enum cudaSharedMemConfig *pConfig); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2GetLastError(void); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2PeekAtLastError(void); +extern __attribute__((device)) __attribute__((cudart_builtin)) const char* __cudaCDP2GetErrorString(cudaError_t error); +extern __attribute__((device)) __attribute__((cudart_builtin)) const char* __cudaCDP2GetErrorName(cudaError_t error); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2GetDeviceCount(int *count); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2GetDevice(int *device); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2StreamCreateWithFlags(cudaStream_t *pStream, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2StreamDestroy(cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2StreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2StreamWaitEvent_ptsz(cudaStream_t stream, cudaEvent_t event, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventCreateWithFlags(cudaEvent_t *event, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventRecord(cudaEvent_t event, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventRecord_ptsz(cudaEvent_t event, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventRecordWithFlags_ptsz(cudaEvent_t event, cudaStream_t stream, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2EventDestroy(cudaEvent_t event); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2FuncGetAttributes(struct cudaFuncAttributes *attr, const void *func); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Free(void *devPtr); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Malloc(void **devPtr, size_t size); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2MemcpyAsync(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2MemcpyAsync_ptsz(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memcpy2DAsync(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memcpy2DAsync_ptsz(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memcpy3DAsync(const struct cudaMemcpy3DParms *p, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memcpy3DAsync_ptsz(const struct cudaMemcpy3DParms *p, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2MemsetAsync(void *devPtr, int value, size_t count, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2MemsetAsync_ptsz(void *devPtr, int value, size_t count, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memset2DAsync(void *devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memset2DAsync_ptsz(void *devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memset3DAsync(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2Memset3DAsync_ptsz(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2RuntimeGetVersion(int *runtimeVersion); +extern __attribute__((device)) __attribute__((cudart_builtin)) void * __cudaCDP2GetParameterBuffer(size_t alignment, size_t size); +extern __attribute__((device)) __attribute__((cudart_builtin)) void * __cudaCDP2GetParameterBufferV2(void *func, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2LaunchDevice_ptsz(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2LaunchDeviceV2_ptsz(void *parameterBuffer, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2LaunchDevice(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2LaunchDeviceV2(void *parameterBuffer, cudaStream_t stream); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *func, int blockSize, size_t dynamicSmemSize); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t __cudaCDP2OccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, const void *func, int blockSize, size_t dynamicSmemSize, unsigned int flags); + + +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream); +# 311 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +static inline __attribute__((device)) __attribute__((cudart_builtin)) cudaGraphExec_t cudaGetCurrentGraphExec(void) +{ + unsigned long long current_graph_exec; + asm ("mov.u64 %0, %%current_graph_exec;" : "=l"(current_graph_exec)); + return (cudaGraphExec_t)current_graph_exec; +} +# 346 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetParam(cudaGraphDeviceNode_t node, size_t offset, const void *value , size_t size); +# 374 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetEnabled(cudaGraphDeviceNode_t node, bool enable); +# 401 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetGridDim(cudaGraphDeviceNode_t node, dim3 gridDim); +# 430 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeUpdatesApply(const cudaGraphKernelNodeUpdate *updates, size_t updateCount); +# 448 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +static inline __attribute__((device)) __attribute__((cudart_builtin)) void cudaTriggerProgrammaticLaunchCompletion(void) +{ + asm volatile("griddepcontrol.launch_dependents;":::); +} +# 464 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +static inline __attribute__((device)) __attribute__((cudart_builtin)) void cudaGridDependencySynchronize(void) +{ + asm volatile("griddepcontrol.wait;":::"memory"); +} +# 476 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +extern __attribute__((device)) __attribute__((cudart_builtin)) void cudaGraphSetConditional(cudaGraphConditionalHandle handle, unsigned int value); + + +extern __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long cudaCGGetIntrinsicHandle(enum cudaCGScope scope); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaCGSynchronize(unsigned long long handle, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaCGSynchronizeGrid(unsigned long long handle, unsigned int flags); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaCGGetSize(unsigned int *numThreads, unsigned int *numGrids, unsigned long long handle); +extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaCGGetRank(unsigned int *threadRank, unsigned int *gridRank, unsigned long long handle); +# 711 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) void * cudaGetParameterBuffer(size_t alignment, size_t size) +{ + return __cudaCDP2GetParameterBuffer(alignment, size); +} + + + + + + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) void * cudaGetParameterBufferV2(void *func, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize) +{ + return __cudaCDP2GetParameterBufferV2(func, gridDimension, blockDimension, sharedMemSize); +} + + + + + + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDevice_ptsz(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize, cudaStream_t stream) +{ + return __cudaCDP2LaunchDevice_ptsz(func, parameterBuffer, gridDimension, blockDimension, sharedMemSize, stream); +} + +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDeviceV2_ptsz(void *parameterBuffer, cudaStream_t stream) +{ + return __cudaCDP2LaunchDeviceV2_ptsz(parameterBuffer, stream); +} +# 797 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" + static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDevice(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize, cudaStream_t stream) + { + return __cudaCDP2LaunchDevice(func, parameterBuffer, gridDimension, blockDimension, sharedMemSize, stream); + } + + static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDeviceV2(void *parameterBuffer, cudaStream_t stream) + { + return __cudaCDP2LaunchDeviceV2(parameterBuffer, stream); + } +# 859 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +} + + + + + +template static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMalloc(T **devPtr, size_t size); +template static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetAttributes(struct cudaFuncAttributes *attr, T *entry); +template static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, T func, int blockSize, size_t dynamicSmemSize); +template static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, T func, int blockSize, size_t dynamicSmemSize, unsigned int flags); +# 898 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_device_runtime_api.h" +template +static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGraphKernelNodeSetParam(cudaGraphDeviceNode_t node, size_t offset, const T &value) +{ + return cudaGraphKernelNodeSetParam(node, offset, &value, sizeof(T)); +} +# 154 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 2 +# 284 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern "C" { +# 331 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceReset(void); +# 353 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceSynchronize(void); +# 439 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetLimit(enum cudaLimit limit, size_t value); +# 475 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetLimit(size_t *pValue, enum cudaLimit limit); +# 498 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t *maxWidthInElements, const struct cudaChannelFormatDesc *fmtDesc, int device); +# 532 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetCacheConfig(enum cudaFuncCache *pCacheConfig); +# 569 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetStreamPriorityRange(int *leastPriority, int *greatestPriority); +# 613 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetCacheConfig(enum cudaFuncCache cacheConfig); +# 640 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetByPCIBusId(int *device, const char *pciBusId); +# 670 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetPCIBusId(char *pciBusId, int len, int device); +# 721 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t *handle, cudaEvent_t event); +# 765 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcOpenEventHandle(cudaEvent_t *event, cudaIpcEventHandle_t handle); +# 810 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t *handle, void *devPtr); +# 877 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcOpenMemHandle(void **devPtr, cudaIpcMemHandle_t handle, unsigned int flags); +# 916 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaIpcCloseMemHandle(void *devPtr); +# 948 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(enum cudaFlushGPUDirectRDMAWritesTarget target, enum cudaFlushGPUDirectRDMAWritesScope scope); +# 986 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceRegisterAsyncNotification(int device, cudaAsyncCallback callbackFunc, void* userData, cudaAsyncCallbackHandle_t* callback); +# 1009 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceUnregisterAsyncNotification(int device, cudaAsyncCallbackHandle_t callback); +# 1056 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetSharedMemConfig(enum cudaSharedMemConfig *pConfig); +# 1102 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaDeviceSetSharedMemConfig(enum cudaSharedMemConfig config); +# 1143 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadExit(void); +# 1169 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSynchronize(void); +# 1218 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSetLimit(enum cudaLimit limit, size_t value); +# 1251 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadGetLimit(size_t *pValue, enum cudaLimit limit); +# 1287 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadGetCacheConfig(enum cudaFuncCache *pCacheConfig); +# 1334 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaThreadSetCacheConfig(enum cudaFuncCache cacheConfig); +# 1399 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetLastError(void); +# 1450 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaPeekAtLastError(void); +# 1466 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) const char* cudaGetErrorName(cudaError_t error); +# 1482 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) const char* cudaGetErrorString(cudaError_t error); +# 1511 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceCount(int *count); +# 1816 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceProperties_v2(struct cudaDeviceProp *prop, int device); +# 2020 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetAttribute(int *value, enum cudaDeviceAttr attr, int device); +# 2038 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetDefaultMemPool(cudaMemPool_t *memPool, int device); +# 2062 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetMemPool(int device, cudaMemPool_t memPool); +# 2082 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetMemPool(cudaMemPool_t *memPool, int device); +# 2144 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetNvSciSyncAttributes(void *nvSciSyncAttrList, int device, int flags); +# 2184 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetP2PAttribute(int *value, enum cudaDeviceP2PAttr attr, int srcDevice, int dstDevice); +# 2206 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaChooseDevice(int *device, const struct cudaDeviceProp *prop); +# 2235 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaInitDevice(int device, unsigned int deviceFlags, unsigned int flags); +# 2281 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSetDevice(int device); +# 2303 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDevice(int *device); +# 2334 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSetValidDevices(int *device_arr, int len); +# 2404 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSetDeviceFlags( unsigned int flags ); +# 2449 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetDeviceFlags( unsigned int *flags ); +# 2489 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamCreate(cudaStream_t *pStream); +# 2521 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCreateWithFlags(cudaStream_t *pStream, unsigned int flags); +# 2569 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCreateWithPriority(cudaStream_t *pStream, unsigned int flags, int priority); +# 2596 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int *priority); +# 2621 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned int *flags); +# 2658 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetId(cudaStream_t hStream, unsigned long long *streamId); +# 2673 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaCtxResetPersistingL2Cache(void); +# 2693 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src); +# 2714 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetAttribute( + cudaStream_t hStream, cudaLaunchAttributeID attr, + cudaLaunchAttributeValue *value_out); +# 2738 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamSetAttribute( + cudaStream_t hStream, cudaLaunchAttributeID attr, + const cudaLaunchAttributeValue *value); +# 2772 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamDestroy(cudaStream_t stream); +# 2803 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags = 0); + + + + + + + +typedef void ( *cudaStreamCallback_t)(cudaStream_t stream, cudaError_t status, void *userData); +# 2878 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamAddCallback(cudaStream_t stream, + cudaStreamCallback_t callback, void *userData, unsigned int flags); +# 2902 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamSynchronize(cudaStream_t stream); +# 2927 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamQuery(cudaStream_t stream); +# 3011 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamAttachMemAsync(cudaStream_t stream, void *devPtr, size_t length = 0, unsigned int flags = 0x04); +# 3050 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamBeginCapture(cudaStream_t stream, enum cudaStreamCaptureMode mode); +# 3091 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamBeginCaptureToGraph(cudaStream_t stream, cudaGraph_t graph, const cudaGraphNode_t *dependencies, const cudaGraphEdgeData *dependencyData, size_t numDependencies, enum cudaStreamCaptureMode mode); +# 3142 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaThreadExchangeStreamCaptureMode(enum cudaStreamCaptureMode *mode); +# 3171 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t *pGraph); +# 3209 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamIsCapturing(cudaStream_t stream, enum cudaStreamCaptureStatus *pCaptureStatus); +# 3258 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamGetCaptureInfo_v2(cudaStream_t stream, enum cudaStreamCaptureStatus *captureStatus_out, unsigned long long *id_out = 0, cudaGraph_t *graph_out = 0, const cudaGraphNode_t **dependencies_out = 0, size_t *numDependencies_out = 0); +# 3317 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamGetCaptureInfo_v3(cudaStream_t stream, + enum cudaStreamCaptureStatus *captureStatus_out, unsigned long long *id_out = 0, + cudaGraph_t *graph_out = 0, const cudaGraphNode_t **dependencies_out = 0, + const cudaGraphEdgeData **edgeData_out = 0, size_t *numDependencies_out = 0); +# 3357 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t *dependencies, size_t numDependencies, unsigned int flags = 0); +# 3392 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaStreamUpdateCaptureDependencies_v2(cudaStream_t stream, cudaGraphNode_t *dependencies, const cudaGraphEdgeData *dependencyData, size_t numDependencies, unsigned int flags = 0); +# 3429 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventCreate(cudaEvent_t *event); +# 3466 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventCreateWithFlags(cudaEvent_t *event, unsigned int flags); +# 3507 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream = 0); +# 3555 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream = 0, unsigned int flags = 0); +# 3588 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventQuery(cudaEvent_t event); +# 3619 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventSynchronize(cudaEvent_t event); +# 3649 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventDestroy(cudaEvent_t event); +# 3694 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaEventElapsedTime(float *ms, cudaEvent_t start, cudaEvent_t end); +# 3875 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaImportExternalMemory(cudaExternalMemory_t *extMem_out, const struct cudaExternalMemoryHandleDesc *memHandleDesc); +# 3930 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaExternalMemoryGetMappedBuffer(void **devPtr, cudaExternalMemory_t extMem, const struct cudaExternalMemoryBufferDesc *bufferDesc); +# 3990 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t *mipmap, cudaExternalMemory_t extMem, const struct cudaExternalMemoryMipmappedArrayDesc *mipmapDesc); +# 4014 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroyExternalMemory(cudaExternalMemory_t extMem); +# 4168 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaImportExternalSemaphore(cudaExternalSemaphore_t *extSem_out, const struct cudaExternalSemaphoreHandleDesc *semHandleDesc); +# 4251 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaSignalExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t *extSemArray, const struct cudaExternalSemaphoreSignalParams *paramsArray, unsigned int numExtSems, cudaStream_t stream = 0); +# 4327 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaWaitExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t *extSemArray, const struct cudaExternalSemaphoreWaitParams *paramsArray, unsigned int numExtSems, cudaStream_t stream = 0); +# 4350 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem); +# 4417 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchKernel(const void *func, dim3 gridDim, dim3 blockDim, void **args, size_t sharedMem, cudaStream_t stream); +# 4479 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchKernelExC(const cudaLaunchConfig_t *config, const void *func, void **args); +# 4536 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchCooperativeKernel(const void *func, dim3 gridDim, dim3 blockDim, void **args, size_t sharedMem, cudaStream_t stream); +# 4637 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaLaunchCooperativeKernelMultiDevice(struct cudaLaunchParams *launchParamsList, unsigned int numDevices, unsigned int flags = 0); +# 4682 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFuncSetCacheConfig(const void *func, enum cudaFuncCache cacheConfig); +# 4715 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetAttributes(struct cudaFuncAttributes *attr, const void *func); +# 4772 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncSetAttribute(const void *func, enum cudaFuncAttribute attr, int value); +# 4796 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetName(const char **name, const void *func); +# 4818 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetParamInfo(const void *func, size_t paramIndex, size_t *paramOffset, size_t *paramSize); +# 4842 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaSetDoubleForDevice(double *d); +# 4866 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaSetDoubleForHost(double *d); +# 4932 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void *userData); +# 5006 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaFuncSetSharedMemConfig(const void *func, enum cudaSharedMemConfig config); +# 5062 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *func, int blockSize, size_t dynamicSMemSize); +# 5091 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t *dynamicSmemSize, const void *func, int numBlocks, int blockSize); +# 5136 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, const void *func, int blockSize, size_t dynamicSMemSize, unsigned int flags); +# 5171 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxPotentialClusterSize(int *clusterSize, const void *func, const cudaLaunchConfig_t *launchConfig); +# 5210 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveClusters(int *numClusters, const void *func, const cudaLaunchConfig_t *launchConfig); +# 5330 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMallocManaged(void **devPtr, size_t size, unsigned int flags = 0x01); +# 5363 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMalloc(void **devPtr, size_t size); +# 5400 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocHost(void **ptr, size_t size); +# 5443 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocPitch(void **devPtr, size_t *pitch, size_t width, size_t height); +# 5495 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocArray(cudaArray_t *array, const struct cudaChannelFormatDesc *desc, size_t width, size_t height = 0, unsigned int flags = 0); +# 5533 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFree(void *devPtr); +# 5556 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeHost(void *ptr); +# 5579 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeArray(cudaArray_t array); +# 5602 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray); +# 5668 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostAlloc(void **pHost, size_t size, unsigned int flags); +# 5765 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostRegister(void *ptr, size_t size, unsigned int flags); +# 5788 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostUnregister(void *ptr); +# 5833 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostGetDevicePointer(void **pDevice, void *pHost, unsigned int flags); +# 5855 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaHostGetFlags(unsigned int *pFlags, void *pHost); +# 5894 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMalloc3D(struct cudaPitchedPtr* pitchedDevPtr, struct cudaExtent extent); +# 6039 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMalloc3DArray(cudaArray_t *array, const struct cudaChannelFormatDesc* desc, struct cudaExtent extent, unsigned int flags = 0); +# 6184 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocMipmappedArray(cudaMipmappedArray_t *mipmappedArray, const struct cudaChannelFormatDesc* desc, struct cudaExtent extent, unsigned int numLevels, unsigned int flags = 0); +# 6217 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t *levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level); +# 6322 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3D(const struct cudaMemcpy3DParms *p); +# 6354 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3DPeer(const struct cudaMemcpy3DPeerParms *p); +# 6472 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy3DAsync(const struct cudaMemcpy3DParms *p, cudaStream_t stream = 0); +# 6499 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy3DPeerAsync(const struct cudaMemcpy3DPeerParms *p, cudaStream_t stream = 0); +# 6533 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemGetInfo(size_t *free, size_t *total); +# 6559 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaArrayGetInfo(struct cudaChannelFormatDesc *desc, struct cudaExtent *extent, unsigned int *flags, cudaArray_t array); +# 6588 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaArrayGetPlane(cudaArray_t *pPlaneArray, cudaArray_t hArray, unsigned int planeIdx); +# 6611 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaArrayGetMemoryRequirements(struct cudaArrayMemoryRequirements *memoryRequirements, cudaArray_t array, int device); +# 6635 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMipmappedArrayGetMemoryRequirements(struct cudaArrayMemoryRequirements *memoryRequirements, cudaMipmappedArray_t mipmap, int device); +# 6663 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaArrayGetSparseProperties(struct cudaArraySparseProperties *sparseProperties, cudaArray_t array); +# 6693 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaMipmappedArrayGetSparseProperties(struct cudaArraySparseProperties *sparseProperties, cudaMipmappedArray_t mipmap); +# 6738 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind); +# 6773 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyPeer(void *dst, int dstDevice, const void *src, int srcDevice, size_t count); +# 6822 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2D(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind); +# 6872 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind); +# 6922 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DFromArray(void *dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, enum cudaMemcpyKind kind); +# 6969 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, enum cudaMemcpyKind kind = cudaMemcpyDeviceToDevice); +# 7012 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyToSymbol(const void *symbol, const void *src, size_t count, size_t offset = 0, enum cudaMemcpyKind kind = cudaMemcpyHostToDevice); +# 7056 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyFromSymbol(void *dst, const void *symbol, size_t count, size_t offset = 0, enum cudaMemcpyKind kind = cudaMemcpyDeviceToHost); +# 7113 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpyAsync(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7148 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyPeerAsync(void *dst, int dstDevice, const void *src, int srcDevice, size_t count, cudaStream_t stream = 0); +# 7211 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy2DAsync(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7269 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7326 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpy2DFromArrayAsync(void *dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7377 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyToSymbolAsync(const void *symbol, const void *src, size_t count, size_t offset, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7428 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemcpyFromSymbolAsync(void *dst, const void *symbol, size_t count, size_t offset, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 7457 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemset(void *devPtr, int value, size_t count); +# 7491 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemset2D(void *devPtr, size_t pitch, int value, size_t width, size_t height); +# 7537 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemset3D(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent); +# 7573 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemsetAsync(void *devPtr, int value, size_t count, cudaStream_t stream = 0); +# 7614 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemset2DAsync(void *devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream = 0); +# 7667 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemset3DAsync(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent, cudaStream_t stream = 0); +# 7695 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetSymbolAddress(void **devPtr, const void *symbol); +# 7722 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetSymbolSize(size_t *size, const void *symbol); +# 7792 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPrefetchAsync(const void *devPtr, size_t count, int dstDevice, cudaStream_t stream = 0); + +extern __attribute__((host)) cudaError_t cudaMemPrefetchAsync_v2(const void *devPtr, size_t count, struct cudaMemLocation location, unsigned int flags, cudaStream_t stream = 0); +# 7908 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemAdvise(const void *devPtr, size_t count, enum cudaMemoryAdvise advice, int device); +# 8031 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemAdvise_v2(const void *devPtr, size_t count, enum cudaMemoryAdvise advice, struct cudaMemLocation location); +# 8113 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemRangeGetAttribute(void *data, size_t dataSize, enum cudaMemRangeAttribute attribute, const void *devPtr, size_t count); +# 8156 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemRangeGetAttributes(void **data, size_t *dataSizes, enum cudaMemRangeAttribute *attributes, size_t numAttributes, const void *devPtr, size_t count); +# 8216 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t count, enum cudaMemcpyKind kind); +# 8258 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyFromArray(void *dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, enum cudaMemcpyKind kind); +# 8301 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, enum cudaMemcpyKind kind = cudaMemcpyDeviceToDevice); +# 8352 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 8402 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((deprecated)) __attribute__((host)) cudaError_t cudaMemcpyFromArrayAsync(void *dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream = 0); +# 8471 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocAsync(void **devPtr, size_t size, cudaStream_t hStream); +# 8497 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaFreeAsync(void *devPtr, cudaStream_t hStream); +# 8522 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep); +# 8566 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolSetAttribute(cudaMemPool_t memPool, enum cudaMemPoolAttr attr, void *value ); +# 8614 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolGetAttribute(cudaMemPool_t memPool, enum cudaMemPoolAttr attr, void *value ); +# 8629 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolSetAccess(cudaMemPool_t memPool, const struct cudaMemAccessDesc *descList, size_t count); +# 8642 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolGetAccess(enum cudaMemAccessFlags *flags, cudaMemPool_t memPool, struct cudaMemLocation *location); +# 8680 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolCreate(cudaMemPool_t *memPool, const struct cudaMemPoolProps *poolProps); +# 8702 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolDestroy(cudaMemPool_t memPool); +# 8738 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMallocFromPoolAsync(void **ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream); +# 8763 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolExportToShareableHandle( + void *shareableHandle, + cudaMemPool_t memPool, + enum cudaMemAllocationHandleType handleType, + unsigned int flags); +# 8790 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolImportFromShareableHandle( + cudaMemPool_t *memPool, + void *shareableHandle, + enum cudaMemAllocationHandleType handleType, + unsigned int flags); +# 8813 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolExportPointer(struct cudaMemPoolPtrExportData *exportData, void *ptr); +# 8842 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaMemPoolImportPointer(void **ptr, cudaMemPool_t memPool, struct cudaMemPoolPtrExportData *exportData); +# 8995 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaPointerGetAttributes(struct cudaPointerAttributes *attributes, const void *ptr); +# 9036 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceCanAccessPeer(int *canAccessPeer, int device, int peerDevice); +# 9078 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags); +# 9100 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceDisablePeerAccess(int peerDevice); +# 9164 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource); +# 9199 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags); +# 9238 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t *resources, cudaStream_t stream = 0); +# 9273 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t *resources, cudaStream_t stream = 0); +# 9305 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsResourceGetMappedPointer(void **devPtr, size_t *size, cudaGraphicsResource_t resource); +# 9343 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t *array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel); +# 9372 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t *mipmappedArray, cudaGraphicsResource_t resource); +# 9407 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetChannelDesc(struct cudaChannelFormatDesc *desc, cudaArray_const_t array); +# 9437 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) struct cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, enum cudaChannelFormatKind f); +# 9662 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaCreateTextureObject(cudaTextureObject_t *pTexObject, const struct cudaResourceDesc *pResDesc, const struct cudaTextureDesc *pTexDesc, const struct cudaResourceViewDesc *pResViewDesc); +# 9682 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject); +# 9702 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetTextureObjectResourceDesc(struct cudaResourceDesc *pResDesc, cudaTextureObject_t texObject); +# 9722 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetTextureObjectTextureDesc(struct cudaTextureDesc *pTexDesc, cudaTextureObject_t texObject); +# 9743 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetTextureObjectResourceViewDesc(struct cudaResourceViewDesc *pResViewDesc, cudaTextureObject_t texObject); +# 9788 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t *pSurfObject, const struct cudaResourceDesc *pResDesc); +# 9808 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject); +# 9827 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetSurfaceObjectResourceDesc(struct cudaResourceDesc *pResDesc, cudaSurfaceObject_t surfObject); +# 9861 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDriverGetVersion(int *driverVersion); +# 9890 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaRuntimeGetVersion(int *runtimeVersion); +# 9937 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphCreate(cudaGraph_t *pGraph, unsigned int flags); +# 10035 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddKernelNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaKernelNodeParams *pNodeParams); +# 10068 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeGetParams(cudaGraphNode_t node, struct cudaKernelNodeParams *pNodeParams); +# 10094 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const struct cudaKernelNodeParams *pNodeParams); +# 10114 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeCopyAttributes( + cudaGraphNode_t hSrc, + cudaGraphNode_t hDst); +# 10137 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeGetAttribute( + cudaGraphNode_t hNode, + cudaLaunchAttributeID attr, + cudaLaunchAttributeValue *value_out); +# 10161 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphKernelNodeSetAttribute( + cudaGraphNode_t hNode, + cudaLaunchAttributeID attr, + const cudaLaunchAttributeValue *value); +# 10212 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddMemcpyNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaMemcpy3DParms *pCopyParams); +# 10271 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddMemcpyNodeToSymbol( + cudaGraphNode_t *pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t *pDependencies, + size_t numDependencies, + const void* symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 10340 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddMemcpyNodeFromSymbol( + cudaGraphNode_t* pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t* pDependencies, + size_t numDependencies, + void* dst, + const void* symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 10408 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddMemcpyNode1D( + cudaGraphNode_t *pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t *pDependencies, + size_t numDependencies, + void* dst, + const void* src, + size_t count, + enum cudaMemcpyKind kind); +# 10440 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, struct cudaMemcpy3DParms *pNodeParams); +# 10467 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const struct cudaMemcpy3DParms *pNodeParams); +# 10506 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParamsToSymbol( + cudaGraphNode_t node, + const void* symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 10552 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParamsFromSymbol( + cudaGraphNode_t node, + void* dst, + const void* symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 10598 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParams1D( + cudaGraphNode_t node, + void* dst, + const void* src, + size_t count, + enum cudaMemcpyKind kind); +# 10646 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddMemsetNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaMemsetParams *pMemsetParams); +# 10669 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, struct cudaMemsetParams *pNodeParams); +# 10693 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const struct cudaMemsetParams *pNodeParams); +# 10735 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddHostNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaHostNodeParams *pNodeParams); +# 10758 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphHostNodeGetParams(cudaGraphNode_t node, struct cudaHostNodeParams *pNodeParams); +# 10782 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphHostNodeSetParams(cudaGraphNode_t node, const struct cudaHostNodeParams *pNodeParams); +# 10823 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddChildGraphNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, cudaGraph_t childGraph); +# 10850 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t *pGraph); +# 10888 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddEmptyNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies); +# 10932 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddEventRecordNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, cudaEvent_t event); +# 10959 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t *event_out); +# 10987 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event); +# 11034 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphAddEventWaitNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, cudaEvent_t event); +# 11061 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t *event_out); +# 11089 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event); +# 11139 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaExternalSemaphoreSignalNodeParams *nodeParams); +# 11172 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, struct cudaExternalSemaphoreSignalNodeParams *params_out); +# 11200 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const struct cudaExternalSemaphoreSignalNodeParams *nodeParams); +# 11250 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, const struct cudaExternalSemaphoreWaitNodeParams *nodeParams); +# 11283 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, struct cudaExternalSemaphoreWaitNodeParams *params_out); +# 11311 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const struct cudaExternalSemaphoreWaitNodeParams *nodeParams); +# 11389 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddMemAllocNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, struct cudaMemAllocNodeParams *nodeParams); +# 11416 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, struct cudaMemAllocNodeParams *params_out); +# 11477 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddMemFreeNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, void *dptr); +# 11501 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void *dptr_out); +# 11529 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGraphMemTrim(int device); +# 11566 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceGetGraphMemAttribute(int device, enum cudaGraphMemAttributeType attr, void* value); +# 11600 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaDeviceSetGraphMemAttribute(int device, enum cudaGraphMemAttributeType attr, void* value); +# 11628 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphClone(cudaGraph_t *pGraphClone, cudaGraph_t originalGraph); +# 11656 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeFindInClone(cudaGraphNode_t *pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph); +# 11687 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetType(cudaGraphNode_t node, enum cudaGraphNodeType *pType); +# 11718 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t *nodes, size_t *numNodes); +# 11749 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t *pRootNodes, size_t *pNumRootNodes); +# 11783 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t *from, cudaGraphNode_t *to, size_t *numEdges); +# 11823 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphGetEdges_v2(cudaGraph_t graph, cudaGraphNode_t *from, cudaGraphNode_t *to, cudaGraphEdgeData *edgeData, size_t *numEdges); +# 11854 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t *pDependencies, size_t *pNumDependencies); +# 11891 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependencies_v2(cudaGraphNode_t node, cudaGraphNode_t *pDependencies, cudaGraphEdgeData *edgeData, size_t *pNumDependencies); +# 11923 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t *pDependentNodes, size_t *pNumDependentNodes); +# 11961 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetDependentNodes_v2(cudaGraphNode_t node, cudaGraphNode_t *pDependentNodes, cudaGraphEdgeData *edgeData, size_t *pNumDependentNodes); +# 11992 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, size_t numDependencies); +# 12024 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, const cudaGraphEdgeData *edgeData, size_t numDependencies); +# 12055 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, size_t numDependencies); +# 12090 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphRemoveDependencies_v2(cudaGraph_t graph, const cudaGraphNode_t *from, const cudaGraphNode_t *to, const cudaGraphEdgeData *edgeData, size_t numDependencies); +# 12120 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphDestroyNode(cudaGraphNode_t node); +# 12191 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphInstantiate(cudaGraphExec_t *pGraphExec, cudaGraph_t graph, unsigned long long flags = 0); +# 12264 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphInstantiateWithFlags(cudaGraphExec_t *pGraphExec, cudaGraph_t graph, unsigned long long flags = 0); +# 12371 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphInstantiateWithParams(cudaGraphExec_t *pGraphExec, cudaGraph_t graph, cudaGraphInstantiateParams *instantiateParams); +# 12396 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecGetFlags(cudaGraphExec_t graphExec, unsigned long long *flags); +# 12455 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaKernelNodeParams *pNodeParams); +# 12506 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaMemcpy3DParms *pNodeParams); +# 12561 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParamsToSymbol( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + const void* symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 12624 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParamsFromSymbol( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + void* dst, + const void* symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind); +# 12685 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParams1D( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + void* dst, + const void* src, + size_t count, + enum cudaMemcpyKind kind); +# 12740 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaMemsetParams *pNodeParams); +# 12780 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const struct cudaHostNodeParams *pNodeParams); +# 12827 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph); +# 12872 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event); +# 12917 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event); +# 12965 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const struct cudaExternalSemaphoreSignalNodeParams *nodeParams); +# 13013 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const struct cudaExternalSemaphoreWaitNodeParams *nodeParams); +# 13053 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled); +# 13087 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int *isEnabled); +# 13179 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphExecUpdateResultInfo *resultInfo); +# 13204 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + extern __attribute__((host)) cudaError_t cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream); +# 13235 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream); +# 13258 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecDestroy(cudaGraphExec_t graphExec); +# 13279 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphDestroy(cudaGraph_t graph); +# 13298 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphDebugDotPrint(cudaGraph_t graph, const char *path, unsigned int flags); +# 13334 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaUserObjectCreate(cudaUserObject_t *object_out, void *ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags); +# 13358 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaUserObjectRetain(cudaUserObject_t object, unsigned int count = 1); +# 13386 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaUserObjectRelease(cudaUserObject_t object, unsigned int count = 1); +# 13414 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count = 1, unsigned int flags = 0); +# 13439 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count = 1); +# 13481 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddNode(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, size_t numDependencies, struct cudaGraphNodeParams *nodeParams); +# 13525 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphAddNode_v2(cudaGraphNode_t *pGraphNode, cudaGraph_t graph, const cudaGraphNode_t *pDependencies, const cudaGraphEdgeData *dependencyData, size_t numDependencies, struct cudaGraphNodeParams *nodeParams); +# 13554 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphNodeSetParams(cudaGraphNode_t node, struct cudaGraphNodeParams *nodeParams); +# 13603 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphExecNodeSetParams(cudaGraphExec_t graphExec, cudaGraphNode_t node, struct cudaGraphNodeParams *nodeParams); +# 13629 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGraphConditionalHandleCreate(cudaGraphConditionalHandle *pHandle_out, cudaGraph_t graph, unsigned int defaultLaunchValue = 0, unsigned int flags = 0); +# 13710 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetDriverEntryPoint(const char *symbol, void **funcPtr, unsigned long long flags, enum cudaDriverEntryPointQueryResult *driverStatus = +# 13710 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 3 4 + __null +# 13710 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + ); +# 13786 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetDriverEntryPointByVersion(const char *symbol, void **funcPtr, unsigned int cudaVersion, unsigned long long flags, enum cudaDriverEntryPointQueryResult *driverStatus = +# 13786 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" 3 4 + __null +# 13786 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" + ); + + + + + + + +extern __attribute__((host)) cudaError_t cudaGetExportTable(const void **ppExportTable, const cudaUUID_t *pExportTableId); +# 13973 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetFuncBySymbol(cudaFunction_t* functionPtr, const void* symbolPtr); +# 13989 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +extern __attribute__((host)) cudaError_t cudaGetKernel(cudaKernel_t *kernelPtr, const void *entryFuncAddr); +# 14161 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime_api.h" +} +# 62 "/usr/local/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" 2 +# 117 "/usr/local/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" +template __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(0, 0, 0, 0, cudaChannelFormatKindNone); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescHalf(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescHalf1(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescHalf2(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindFloat); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescHalf4(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindFloat); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(char) * 8; + + + + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); + +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(signed char) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned char) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(signed char) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned char) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(signed char) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned char) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(signed char) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned char) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(short) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(short) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned short) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(int) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned int) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(int) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned int) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(int) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned int) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(int) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(unsigned int) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned); +} +# 389 "/usr/local/cuda/bin/../targets/x86_64-linux/include/channel_descriptor.h" +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(float) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(float) * 8; + + return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(float) * 8; + + return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindFloat); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + int e = (int)sizeof(float) * 8; + + return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindFloat); +} + +static __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDescNV12(void) +{ + int e = (int)sizeof(char) * 8; + + return cudaCreateChannelDesc(e, e, e, 0, cudaChannelFormatKindNV12); +} + +template __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(0, 0, 0, 0, cudaChannelFormatKindNone); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindSignedNormalized8X1); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindSignedNormalized8X2); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindSignedNormalized8X4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindUnsignedNormalized8X1); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindUnsignedNormalized8X2); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedNormalized8X4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 0, 0, 0, cudaChannelFormatKindSignedNormalized16X1); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 0, 0, cudaChannelFormatKindSignedNormalized16X2); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 16, 16, cudaChannelFormatKindSignedNormalized16X4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 0, 0, 0, cudaChannelFormatKindUnsignedNormalized16X1); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 0, 0, cudaChannelFormatKindUnsignedNormalized16X2); +} + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 16, 16, cudaChannelFormatKindUnsignedNormalized16X4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 0, cudaChannelFormatKindNV12); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed1); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed1SRGB); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed2); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed2SRGB); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed3); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed3SRGB); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindUnsignedBlockCompressed4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 0, 0, 0, cudaChannelFormatKindSignedBlockCompressed4); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindUnsignedBlockCompressed5); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 0, 0, cudaChannelFormatKindSignedBlockCompressed5); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 16, 0, cudaChannelFormatKindUnsignedBlockCompressed6H); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(16, 16, 16, 0, cudaChannelFormatKindSignedBlockCompressed6H); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed7); +} + + +template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc(void) +{ + return cudaCreateChannelDesc(8, 8, 8, 8, cudaChannelFormatKindUnsignedBlockCompressed7SRGB); +} +# 95 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" 1 +# 53 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 54 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 55 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" 2 +# 79 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +static __inline__ __attribute__((host)) struct cudaPitchedPtr make_cudaPitchedPtr(void *d, size_t p, size_t xsz, size_t ysz) +{ + struct cudaPitchedPtr s; + + s.ptr = d; + s.pitch = p; + s.xsize = xsz; + s.ysize = ysz; + + return s; +} +# 106 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +static __inline__ __attribute__((host)) struct cudaPos make_cudaPos(size_t x, size_t y, size_t z) +{ + struct cudaPos p; + + p.x = x; + p.y = y; + p.z = z; + + return p; +} +# 132 "/usr/local/cuda/bin/../targets/x86_64-linux/include/driver_functions.h" +static __inline__ __attribute__((host)) struct cudaExtent make_cudaExtent(size_t w, size_t h, size_t d) +{ + struct cudaExtent e; + + e.width = w; + e.height = h; + e.depth = d; + + return e; +} +# 97 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + + +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 100 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 + + + + + +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/vector_functions.h" 1 +# 77 "/usr/local/cuda/bin/../targets/x86_64-linux/include/vector_functions.h" +static __inline__ __attribute__((host)) __attribute__((device)) char1 make_char1(signed char x); + +static __inline__ __attribute__((host)) __attribute__((device)) uchar1 make_uchar1(unsigned char x); + +static __inline__ __attribute__((host)) __attribute__((device)) char2 make_char2(signed char x, signed char y); + +static __inline__ __attribute__((host)) __attribute__((device)) uchar2 make_uchar2(unsigned char x, unsigned char y); + +static __inline__ __attribute__((host)) __attribute__((device)) char3 make_char3(signed char x, signed char y, signed char z); + +static __inline__ __attribute__((host)) __attribute__((device)) uchar3 make_uchar3(unsigned char x, unsigned char y, unsigned char z); + +static __inline__ __attribute__((host)) __attribute__((device)) char4 make_char4(signed char x, signed char y, signed char z, signed char w); + +static __inline__ __attribute__((host)) __attribute__((device)) uchar4 make_uchar4(unsigned char x, unsigned char y, unsigned char z, unsigned char w); + +static __inline__ __attribute__((host)) __attribute__((device)) short1 make_short1(short x); + +static __inline__ __attribute__((host)) __attribute__((device)) ushort1 make_ushort1(unsigned short x); + +static __inline__ __attribute__((host)) __attribute__((device)) short2 make_short2(short x, short y); + +static __inline__ __attribute__((host)) __attribute__((device)) ushort2 make_ushort2(unsigned short x, unsigned short y); + +static __inline__ __attribute__((host)) __attribute__((device)) short3 make_short3(short x,short y, short z); + +static __inline__ __attribute__((host)) __attribute__((device)) ushort3 make_ushort3(unsigned short x, unsigned short y, unsigned short z); + +static __inline__ __attribute__((host)) __attribute__((device)) short4 make_short4(short x, short y, short z, short w); + +static __inline__ __attribute__((host)) __attribute__((device)) ushort4 make_ushort4(unsigned short x, unsigned short y, unsigned short z, unsigned short w); + +static __inline__ __attribute__((host)) __attribute__((device)) int1 make_int1(int x); + +static __inline__ __attribute__((host)) __attribute__((device)) uint1 make_uint1(unsigned int x); + +static __inline__ __attribute__((host)) __attribute__((device)) int2 make_int2(int x, int y); + +static __inline__ __attribute__((host)) __attribute__((device)) uint2 make_uint2(unsigned int x, unsigned int y); + +static __inline__ __attribute__((host)) __attribute__((device)) int3 make_int3(int x, int y, int z); + +static __inline__ __attribute__((host)) __attribute__((device)) uint3 make_uint3(unsigned int x, unsigned int y, unsigned int z); + +static __inline__ __attribute__((host)) __attribute__((device)) int4 make_int4(int x, int y, int z, int w); + +static __inline__ __attribute__((host)) __attribute__((device)) uint4 make_uint4(unsigned int x, unsigned int y, unsigned int z, unsigned int w); + +static __inline__ __attribute__((host)) __attribute__((device)) long1 make_long1(long int x); + +static __inline__ __attribute__((host)) __attribute__((device)) ulong1 make_ulong1(unsigned long int x); + +static __inline__ __attribute__((host)) __attribute__((device)) long2 make_long2(long int x, long int y); + +static __inline__ __attribute__((host)) __attribute__((device)) ulong2 make_ulong2(unsigned long int x, unsigned long int y); + +static __inline__ __attribute__((host)) __attribute__((device)) long3 make_long3(long int x, long int y, long int z); + +static __inline__ __attribute__((host)) __attribute__((device)) ulong3 make_ulong3(unsigned long int x, unsigned long int y, unsigned long int z); + +static __inline__ __attribute__((host)) __attribute__((device)) long4 make_long4(long int x, long int y, long int z, long int w); + +static __inline__ __attribute__((host)) __attribute__((device)) ulong4 make_ulong4(unsigned long int x, unsigned long int y, unsigned long int z, unsigned long int w); + +static __inline__ __attribute__((host)) __attribute__((device)) float1 make_float1(float x); + +static __inline__ __attribute__((host)) __attribute__((device)) float2 make_float2(float x, float y); + +static __inline__ __attribute__((host)) __attribute__((device)) float3 make_float3(float x, float y, float z); + +static __inline__ __attribute__((host)) __attribute__((device)) float4 make_float4(float x, float y, float z, float w); + +static __inline__ __attribute__((host)) __attribute__((device)) longlong1 make_longlong1(long long int x); + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong1 make_ulonglong1(unsigned long long int x); + +static __inline__ __attribute__((host)) __attribute__((device)) longlong2 make_longlong2(long long int x, long long int y); + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong2 make_ulonglong2(unsigned long long int x, unsigned long long int y); + +static __inline__ __attribute__((host)) __attribute__((device)) longlong3 make_longlong3(long long int x, long long int y, long long int z); + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong3 make_ulonglong3(unsigned long long int x, unsigned long long int y, unsigned long long int z); + +static __inline__ __attribute__((host)) __attribute__((device)) longlong4 make_longlong4(long long int x, long long int y, long long int z, long long int w); + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong4 make_ulonglong4(unsigned long long int x, unsigned long long int y, unsigned long long int z, unsigned long long int w); + +static __inline__ __attribute__((host)) __attribute__((device)) double1 make_double1(double x); + +static __inline__ __attribute__((host)) __attribute__((device)) double2 make_double2(double x, double y); + +static __inline__ __attribute__((host)) __attribute__((device)) double3 make_double3(double x, double y, double z); + +static __inline__ __attribute__((host)) __attribute__((device)) double4 make_double4(double x, double y, double z, double w); + + + + +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/vector_functions.hpp" 1 +# 73 "/usr/local/cuda/bin/../targets/x86_64-linux/include/vector_functions.hpp" +static __inline__ __attribute__((host)) __attribute__((device)) char1 make_char1(signed char x) +{ + char1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uchar1 make_uchar1(unsigned char x) +{ + uchar1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) char2 make_char2(signed char x, signed char y) +{ + char2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uchar2 make_uchar2(unsigned char x, unsigned char y) +{ + uchar2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) char3 make_char3(signed char x, signed char y, signed char z) +{ + char3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uchar3 make_uchar3(unsigned char x, unsigned char y, unsigned char z) +{ + uchar3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) char4 make_char4(signed char x, signed char y, signed char z, signed char w) +{ + char4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uchar4 make_uchar4(unsigned char x, unsigned char y, unsigned char z, unsigned char w) +{ + uchar4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) short1 make_short1(short x) +{ + short1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ushort1 make_ushort1(unsigned short x) +{ + ushort1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) short2 make_short2(short x, short y) +{ + short2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ushort2 make_ushort2(unsigned short x, unsigned short y) +{ + ushort2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) short3 make_short3(short x,short y, short z) +{ + short3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ushort3 make_ushort3(unsigned short x, unsigned short y, unsigned short z) +{ + ushort3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) short4 make_short4(short x, short y, short z, short w) +{ + short4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ushort4 make_ushort4(unsigned short x, unsigned short y, unsigned short z, unsigned short w) +{ + ushort4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) int1 make_int1(int x) +{ + int1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uint1 make_uint1(unsigned int x) +{ + uint1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) int2 make_int2(int x, int y) +{ + int2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uint2 make_uint2(unsigned int x, unsigned int y) +{ + uint2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) int3 make_int3(int x, int y, int z) +{ + int3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uint3 make_uint3(unsigned int x, unsigned int y, unsigned int z) +{ + uint3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) int4 make_int4(int x, int y, int z, int w) +{ + int4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) uint4 make_uint4(unsigned int x, unsigned int y, unsigned int z, unsigned int w) +{ + uint4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) long1 make_long1(long int x) +{ + long1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulong1 make_ulong1(unsigned long int x) +{ + ulong1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) long2 make_long2(long int x, long int y) +{ + long2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulong2 make_ulong2(unsigned long int x, unsigned long int y) +{ + ulong2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) long3 make_long3(long int x, long int y, long int z) +{ + long3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulong3 make_ulong3(unsigned long int x, unsigned long int y, unsigned long int z) +{ + ulong3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) long4 make_long4(long int x, long int y, long int z, long int w) +{ + long4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulong4 make_ulong4(unsigned long int x, unsigned long int y, unsigned long int z, unsigned long int w) +{ + ulong4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) float1 make_float1(float x) +{ + float1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) float2 make_float2(float x, float y) +{ + float2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) float3 make_float3(float x, float y, float z) +{ + float3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) float4 make_float4(float x, float y, float z, float w) +{ + float4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) longlong1 make_longlong1(long long int x) +{ + longlong1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong1 make_ulonglong1(unsigned long long int x) +{ + ulonglong1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) longlong2 make_longlong2(long long int x, long long int y) +{ + longlong2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong2 make_ulonglong2(unsigned long long int x, unsigned long long int y) +{ + ulonglong2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) longlong3 make_longlong3(long long int x, long long int y, long long int z) +{ + longlong3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong3 make_ulonglong3(unsigned long long int x, unsigned long long int y, unsigned long long int z) +{ + ulonglong3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) longlong4 make_longlong4(long long int x, long long int y, long long int z, long long int w) +{ + longlong4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) ulonglong4 make_ulonglong4(unsigned long long int x, unsigned long long int y, unsigned long long int z, unsigned long long int w) +{ + ulonglong4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) double1 make_double1(double x) +{ + double1 t; t.x = x; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) double2 make_double2(double x, double y) +{ + double2 t; t.x = x; t.y = y; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) double3 make_double3(double x, double y, double z) +{ + double3 t; t.x = x; t.y = y; t.z = z; return t; +} + +static __inline__ __attribute__((host)) __attribute__((device)) double4 make_double4(double x, double y, double z, double w) +{ + double4 t; t.x = x; t.y = y; t.z = z; t.w = w; return t; +} +# 177 "/usr/local/cuda/bin/../targets/x86_64-linux/include/vector_functions.h" 2 +# 106 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 117 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 1 +# 71 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 72 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 73 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 85 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +# 1 "/usr/include/string.h" 1 3 4 +# 26 "/usr/include/string.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/string.h" 2 3 4 + + +# 28 "/usr/include/string.h" 3 4 +extern "C" { + + + + +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4 +# 34 "/usr/include/string.h" 2 3 4 +# 43 "/usr/include/string.h" 3 4 +extern void *memcpy (void *__restrict __dest, const void *__restrict __src, + size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern void *memmove (void *__dest, const void *__src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern void *memccpy (void *__restrict __dest, const void *__restrict __src, + int __c, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__write_only__, 1, 4))); + + + + +extern void *memset (void *__s, int __c, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int memcmp (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 80 "/usr/include/string.h" 3 4 +extern int __memcmpeq (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + +extern "C++" +{ +extern void *memchr (void *__s, int __c, size_t __n) + noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const void *memchr (const void *__s, int __c, size_t __n) + noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 105 "/usr/include/string.h" 3 4 +} +# 115 "/usr/include/string.h" 3 4 +extern "C++" void *rawmemchr (void *__s, int __c) + noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern "C++" const void *rawmemchr (const void *__s, int __c) + noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + + + + +extern "C++" void *memrchr (void *__s, int __c, size_t __n) + noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__read_only__, 1, 3))); +extern "C++" const void *memrchr (const void *__s, int __c, size_t __n) + noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__read_only__, 1, 3))); +# 141 "/usr/include/string.h" 3 4 +extern char *strcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strcat (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncat (char *__restrict __dest, const char *__restrict __src, + size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern int strncmp (const char *__s1, const char *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcoll (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern size_t strxfrm (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 1, 3))); + + + + + + +extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + + +extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n, + locale_t __l) noexcept (true) __attribute__ ((__nonnull__ (2, 4))) + __attribute__ ((__access__ (__write_only__, 1, 3))); + + + + + +extern char *strdup (const char *__s) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); + + + + + + +extern char *strndup (const char *__string, size_t __n) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); +# 224 "/usr/include/string.h" 3 4 +extern "C++" +{ +extern char *strchr (char *__s, int __c) + noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *strchr (const char *__s, int __c) + noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 244 "/usr/include/string.h" 3 4 +} + + + + + + +extern "C++" +{ +extern char *strrchr (char *__s, int __c) + noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *strrchr (const char *__s, int __c) + noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 271 "/usr/include/string.h" 3 4 +} +# 281 "/usr/include/string.h" 3 4 +extern "C++" char *strchrnul (char *__s, int __c) + noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern "C++" const char *strchrnul (const char *__s, int __c) + noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 293 "/usr/include/string.h" 3 4 +extern size_t strcspn (const char *__s, const char *__reject) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern size_t strspn (const char *__s, const char *__accept) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern "C++" +{ +extern char *strpbrk (char *__s, const char *__accept) + noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern const char *strpbrk (const char *__s, const char *__accept) + noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 321 "/usr/include/string.h" 3 4 +} + + + + + + +extern "C++" +{ +extern char *strstr (char *__haystack, const char *__needle) + noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern const char *strstr (const char *__haystack, const char *__needle) + noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 348 "/usr/include/string.h" 3 4 +} + + + + + + + +extern char *strtok (char *__restrict __s, const char *__restrict __delim) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + + +extern char *__strtok_r (char *__restrict __s, + const char *__restrict __delim, + char **__restrict __save_ptr) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); + +extern char *strtok_r (char *__restrict __s, const char *__restrict __delim, + char **__restrict __save_ptr) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); + + + + + +extern "C++" char *strcasestr (char *__haystack, const char *__needle) + noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern "C++" const char *strcasestr (const char *__haystack, + const char *__needle) + noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 389 "/usr/include/string.h" 3 4 +extern void *memmem (const void *__haystack, size_t __haystacklen, + const void *__needle, size_t __needlelen) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3))) + __attribute__ ((__access__ (__read_only__, 1, 2))) + __attribute__ ((__access__ (__read_only__, 3, 4))); + + + +extern void *__mempcpy (void *__restrict __dest, + const void *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern void *mempcpy (void *__restrict __dest, + const void *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern size_t strlen (const char *__s) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + +extern size_t strnlen (const char *__string, size_t __maxlen) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + +extern char *strerror (int __errnum) noexcept (true); +# 444 "/usr/include/string.h" 3 4 +extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3))); + + + + +extern const char *strerrordesc_np (int __err) noexcept (true); + +extern const char *strerrorname_np (int __err) noexcept (true); + + + + + +extern char *strerror_l (int __errnum, locale_t __l) noexcept (true); + + + +# 1 "/usr/include/strings.h" 1 3 4 +# 23 "/usr/include/strings.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4 +# 24 "/usr/include/strings.h" 2 3 4 + + + + + + +extern "C" { + + + +extern int bcmp (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern void bcopy (const void *__src, void *__dest, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern void bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern "C++" +{ +extern char *index (char *__s, int __c) + noexcept (true) __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *index (const char *__s, int __c) + noexcept (true) __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 66 "/usr/include/strings.h" 3 4 +} + + + + + + + +extern "C++" +{ +extern char *rindex (char *__s, int __c) + noexcept (true) __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *rindex (const char *__s, int __c) + noexcept (true) __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 94 "/usr/include/strings.h" 3 4 +} +# 104 "/usr/include/strings.h" 3 4 +extern int ffs (int __i) noexcept (true) __attribute__ ((__const__)); + + + + + +extern int ffsl (long int __l) noexcept (true) __attribute__ ((__const__)); +__extension__ extern int ffsll (long long int __ll) + noexcept (true) __attribute__ ((__const__)); + + + +extern int strcasecmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strncasecmp (const char *__s1, const char *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + + + + +extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + + + +extern int strncasecmp_l (const char *__s1, const char *__s2, + size_t __n, locale_t __loc) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4))); + + +} +# 463 "/usr/include/string.h" 2 3 4 + + + +extern void explicit_bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__write_only__, 1, 2))); + + + +extern char *strsep (char **__restrict __stringp, + const char *__restrict __delim) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern char *strsignal (int __sig) noexcept (true); + + + +extern const char *sigabbrev_np (int __sig) noexcept (true); + + +extern const char *sigdescr_np (int __sig) noexcept (true); + + + +extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern char *stpcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + +extern char *__stpncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern char *stpncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern int strverscmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strfry (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern void *memfrob (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__read_write__, 1, 2))); + + + + + + + +extern "C++" char *basename (char *__filename) + noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1))); +extern "C++" const char *basename (const char *__filename) + noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1))); +# 539 "/usr/include/string.h" 3 4 +} +# 86 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 1 "/usr/include/time.h" 1 3 4 +# 29 "/usr/include/time.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4 +# 30 "/usr/include/time.h" 2 3 4 + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/time.h" 1 3 4 +# 73 "/usr/include/x86_64-linux-gnu/bits/time.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/timex.h" 1 3 4 +# 26 "/usr/include/x86_64-linux-gnu/bits/timex.h" 3 4 +struct timex +{ +# 58 "/usr/include/x86_64-linux-gnu/bits/timex.h" 3 4 + unsigned int modes; + __syscall_slong_t offset; + __syscall_slong_t freq; + __syscall_slong_t maxerror; + __syscall_slong_t esterror; + int status; + __syscall_slong_t constant; + __syscall_slong_t precision; + __syscall_slong_t tolerance; + struct timeval time; + __syscall_slong_t tick; + __syscall_slong_t ppsfreq; + __syscall_slong_t jitter; + int shift; + __syscall_slong_t stabil; + __syscall_slong_t jitcnt; + __syscall_slong_t calcnt; + __syscall_slong_t errcnt; + __syscall_slong_t stbcnt; + + int tai; + + + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; + +}; +# 74 "/usr/include/x86_64-linux-gnu/bits/time.h" 2 3 4 + +extern "C" { + + +extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) noexcept (true); +# 90 "/usr/include/x86_64-linux-gnu/bits/time.h" 3 4 +} +# 34 "/usr/include/time.h" 2 3 4 + + + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_tm.h" 1 3 4 + + + + + + +struct tm +{ + int tm_sec; + int tm_min; + int tm_hour; + int tm_mday; + int tm_mon; + int tm_year; + int tm_wday; + int tm_yday; + int tm_isdst; + + + long int tm_gmtoff; + const char *tm_zone; + + + + +}; +# 40 "/usr/include/time.h" 2 3 4 +# 48 "/usr/include/time.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h" 1 3 4 + + + + + + + +struct itimerspec + { + struct timespec it_interval; + struct timespec it_value; + }; +# 49 "/usr/include/time.h" 2 3 4 +struct sigevent; +# 68 "/usr/include/time.h" 3 4 +extern "C" { + + + +extern clock_t clock (void) noexcept (true); + + + +extern time_t time (time_t *__timer) noexcept (true); + + +extern double difftime (time_t __time1, time_t __time0) + noexcept (true) __attribute__ ((__const__)); + + +extern time_t mktime (struct tm *__tp) noexcept (true); +# 100 "/usr/include/time.h" 3 4 +extern size_t strftime (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp) noexcept (true); + + + + +extern char *strptime (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp) + noexcept (true); + + + + + + +extern size_t strftime_l (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp, + locale_t __loc) noexcept (true); + + + +extern char *strptime_l (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp, + locale_t __loc) noexcept (true); + + + + + + +extern struct tm *gmtime (const time_t *__timer) noexcept (true); + + + +extern struct tm *localtime (const time_t *__timer) noexcept (true); +# 154 "/usr/include/time.h" 3 4 +extern struct tm *gmtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) noexcept (true); + + + +extern struct tm *localtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) noexcept (true); +# 179 "/usr/include/time.h" 3 4 +extern char *asctime (const struct tm *__tp) noexcept (true); + + + +extern char *ctime (const time_t *__timer) noexcept (true); +# 197 "/usr/include/time.h" 3 4 +extern char *asctime_r (const struct tm *__restrict __tp, + char *__restrict __buf) noexcept (true); + + + +extern char *ctime_r (const time_t *__restrict __timer, + char *__restrict __buf) noexcept (true); +# 217 "/usr/include/time.h" 3 4 +extern char *__tzname[2]; +extern int __daylight; +extern long int __timezone; + + + + +extern char *tzname[2]; + + + +extern void tzset (void) noexcept (true); + + + +extern int daylight; +extern long int timezone; +# 249 "/usr/include/time.h" 3 4 +extern time_t timegm (struct tm *__tp) noexcept (true); + +extern time_t timelocal (struct tm *__tp) noexcept (true); +# 262 "/usr/include/time.h" 3 4 +extern int dysize (int __year) noexcept (true) __attribute__ ((__const__)); +# 272 "/usr/include/time.h" 3 4 +extern int nanosleep (const struct timespec *__requested_time, + struct timespec *__remaining); + + +extern int clock_getres (clockid_t __clock_id, struct timespec *__res) noexcept (true); + + +extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) noexcept (true); + + +extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp) + noexcept (true); +# 311 "/usr/include/time.h" 3 4 +extern int clock_nanosleep (clockid_t __clock_id, int __flags, + const struct timespec *__req, + struct timespec *__rem); +# 326 "/usr/include/time.h" 3 4 +extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) noexcept (true); + + + + +extern int timer_create (clockid_t __clock_id, + struct sigevent *__restrict __evp, + timer_t *__restrict __timerid) noexcept (true); + + +extern int timer_delete (timer_t __timerid) noexcept (true); + + + +extern int timer_settime (timer_t __timerid, int __flags, + const struct itimerspec *__restrict __value, + struct itimerspec *__restrict __ovalue) noexcept (true); + + +extern int timer_gettime (timer_t __timerid, struct itimerspec *__value) + noexcept (true); +# 364 "/usr/include/time.h" 3 4 +extern int timer_getoverrun (timer_t __timerid) noexcept (true); + + + + + + +extern int timespec_get (struct timespec *__ts, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 387 "/usr/include/time.h" 3 4 +extern int timespec_getres (struct timespec *__ts, int __base) + noexcept (true); +# 413 "/usr/include/time.h" 3 4 +extern int getdate_err; +# 422 "/usr/include/time.h" 3 4 +extern struct tm *getdate (const char *__string); +# 436 "/usr/include/time.h" 3 4 +extern int getdate_r (const char *__restrict __string, + struct tm *__restrict __resbufp); + + +} +# 87 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 + + +# 88 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +extern "C" +{ + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) clock_t clock(void) + + + + +# 95 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 3 4 +noexcept (true) +# 95 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void* memset(void*, int, size_t) +# 96 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 3 4 + noexcept (true) +# 96 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void* memcpy(void*, const void*, size_t) +# 97 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 3 4 + noexcept (true) +# 97 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" + ; + +} +# 303 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 1 +# 114 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 115 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 116 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 126 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern "C" +{ +# 231 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) int abs(int a) +# 231 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 231 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 242 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) long int labs(long int a) +# 242 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 242 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 253 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) long long int llabs(long long int a) +# 253 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 253 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 281 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fabs(double x) +# 281 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 281 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 301 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fabsf(float x) +# 301 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 301 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 311 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int min(const int a, const int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned int umin(const unsigned int a, const unsigned int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llmin(const long long int a, const long long int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned long long int ullmin(const unsigned long long int a, const unsigned long long int b); +# 353 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fminf(float x, float y) +# 353 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 353 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 373 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmin(double x, double y) +# 373 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 373 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 386 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int max(const int a, const int b); + + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned int umax(const unsigned int a, const unsigned int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llmax(const long long int a, const long long int b); + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned long long int ullmax(const unsigned long long int a, const unsigned long long int b); +# 429 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmaxf(float x, float y) +# 429 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 429 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 449 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmax(double, double) +# 449 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 449 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 471 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sin(double x) +# 471 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 471 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 489 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cos(double x) +# 489 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 489 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 505 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincos(double x, double *sptr, double *cptr) +# 505 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 505 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 518 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincosf(float x, float *sptr, float *cptr) +# 518 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 518 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 541 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tan(double x) +# 541 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 541 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 565 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sqrt(double x) +# 565 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 565 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 591 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rsqrt(double x); +# 615 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rsqrtf(float x); +# 642 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log2(double x) +# 642 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 642 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 671 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp2(double x) +# 671 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 671 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 700 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float exp2f(float x) +# 700 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 700 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 731 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp10(double x) +# 731 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 731 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 758 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float exp10f(float x) +# 758 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 758 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 792 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double expm1(double x) +# 792 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 792 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 825 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float expm1f(float x) +# 825 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 825 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 852 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log2f(float x) +# 852 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 852 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 877 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log10(double x) +# 877 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 877 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 903 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log(double x) +# 903 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 903 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 930 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log1p(double x) +# 930 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 930 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 960 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log1pf(float x) +# 960 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 960 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 986 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double floor(double x) +# 986 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 986 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1015 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp(double x) +# 1015 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1015 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1034 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cosh(double x) +# 1034 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1034 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1054 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sinh(double x) +# 1054 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1054 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1074 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tanh(double x) +# 1074 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1074 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1098 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double acosh(double x) +# 1098 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1098 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1125 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float acoshf(float x) +# 1125 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1125 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1149 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double asinh(double x) +# 1149 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1149 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1173 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float asinhf(float x) +# 1173 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1173 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1198 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atanh(double x) +# 1198 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1198 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1223 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atanhf(float x) +# 1223 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1223 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1241 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double ldexp(double x, int exp) +# 1241 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1241 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1256 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ldexpf(float x, int exp) +# 1256 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1256 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1277 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double logb(double x) +# 1277 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1277 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1301 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float logbf(float x) +# 1301 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1301 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1325 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int ilogb(double x) +# 1325 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1325 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1349 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int ilogbf(float x) +# 1349 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1349 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1377 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double scalbn(double x, int n) +# 1377 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1377 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1405 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float scalbnf(float x, int n) +# 1405 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1405 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1433 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double scalbln(double x, long int n) +# 1433 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1433 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1461 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float scalblnf(float x, long int n) +# 1461 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1461 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1493 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double frexp(double x, int *nptr) +# 1493 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1493 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1522 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float frexpf(float x, int *nptr) +# 1522 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1522 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1545 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double round(double x) +# 1545 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1545 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1571 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float roundf(float x) +# 1571 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1571 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1589 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lround(double x) +# 1589 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1589 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1607 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lroundf(float x) +# 1607 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1607 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1625 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llround(double x) +# 1625 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1625 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1643 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llroundf(float x) +# 1643 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1643 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1713 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rintf(float x) +# 1713 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1713 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1730 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lrint(double x) +# 1730 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1730 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1747 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lrintf(float x) +# 1747 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1747 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1764 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llrint(double x) +# 1764 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1764 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1781 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llrintf(float x) +# 1781 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1781 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1805 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nearbyint(double x) +# 1805 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1805 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1829 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nearbyintf(float x) +# 1829 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1829 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1853 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double ceil(double x) +# 1853 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1853 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1876 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double trunc(double x) +# 1876 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1876 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1902 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float truncf(float x) +# 1902 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1902 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1924 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fdim(double x, double y) +# 1924 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1924 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 1945 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fdimf(float x, float y) +# 1945 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 1945 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2028 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atan2(double y, double x) +# 2028 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2028 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2054 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atan(double x) +# 2054 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2054 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2071 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double acos(double x) +# 2071 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2071 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2093 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double asin(double x) +# 2093 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2093 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2124 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double hypot(double x, double y) +# 2124 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2124 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2150 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rhypot(double x, double y) +# 2150 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2150 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2181 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float hypotf(float x, float y) +# 2181 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2181 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2207 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rhypotf(float x, float y) +# 2207 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2207 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2225 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double norm3d(double a, double b, double c) +# 2225 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2225 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2243 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rnorm3d(double a, double b, double c) +# 2243 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2243 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2261 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double norm4d(double a, double b, double c, double d) +# 2261 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2261 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2279 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rnorm4d(double a, double b, double c, double d) +# 2279 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2279 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2297 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +__attribute__((device)) __attribute__((device_builtin)) double norm(int dim, double const * p) +# 2297 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2297 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2315 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double rnorm(int dim, double const * p) +# 2315 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2315 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2334 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rnormf(int dim, float const * p) +# 2334 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2334 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2352 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +__attribute__((device)) __attribute__((device_builtin)) float normf(int dim, float const * p) +# 2352 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2352 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2371 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float norm3df(float a, float b, float c) +# 2371 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2371 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2389 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rnorm3df(float a, float b, float c) +# 2389 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2389 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2407 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float norm4df(float a, float b, float c, float d) +# 2407 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2407 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2425 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float rnorm4df(float a, float b, float c, float d) +# 2425 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2425 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2453 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cbrt(double x) +# 2453 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2453 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2480 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cbrtf(float x) +# 2480 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2480 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2506 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rcbrt(double x); +# 2527 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rcbrtf(float x); +# 2550 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sinpi(double x); +# 2573 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinpif(float x); +# 2595 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cospi(double x); +# 2617 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cospif(float x); +# 2630 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincospi(double x, double *sptr, double *cptr); +# 2643 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincospif(float x, float *sptr, float *cptr); +# 2729 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double pow(double x, double y) +# 2729 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2729 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2753 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double modf(double x, double *iptr) +# 2753 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2753 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2780 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmod(double x, double y) +# 2780 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2780 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2810 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double remainder(double x, double y) +# 2810 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2810 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2843 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float remainderf(float x, float y) +# 2843 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2843 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2881 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double remquo(double x, double y, int *quo) +# 2881 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2881 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2919 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float remquof(float x, float y, int *quo) +# 2919 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2919 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2940 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double j0(double x) +# 2940 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2940 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2962 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float j0f(float x) +# 2962 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2962 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 2989 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double j1(double x) +# 2989 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 2989 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3016 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float j1f(float x) +# 3016 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3016 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3039 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double jn(int n, double x) +# 3039 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3039 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3062 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float jnf(int n, float x) +# 3062 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3062 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3089 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double y0(double x) +# 3089 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3089 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3116 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float y0f(float x) +# 3116 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3116 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3143 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double y1(double x) +# 3143 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3143 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3170 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float y1f(float x) +# 3170 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3170 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3198 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double yn(int n, double x) +# 3198 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3198 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3226 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ynf(int n, float x) +# 3226 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3226 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3244 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double cyl_bessel_i0(double x) +# 3244 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3244 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3261 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float cyl_bessel_i0f(float x) +# 3261 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3261 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3279 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double cyl_bessel_i1(double x) +# 3279 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3279 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3296 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float cyl_bessel_i1f(float x) +# 3296 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3296 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3322 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erf(double x) +# 3322 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3322 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3347 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erff(float x) +# 3347 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3347 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3377 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfinv(double x); +# 3400 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfinvf(float x); +# 3424 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfc(double x) +# 3424 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3424 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3447 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcf(float x) +# 3447 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3447 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3479 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double lgamma(double x) +# 3479 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3479 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3507 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfcinv(double x); +# 3528 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcinvf(float x); +# 3550 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double normcdfinv(double x); +# 3572 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float normcdfinvf(float x); +# 3591 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double normcdf(double x); +# 3610 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float normcdff(float x); +# 3630 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfcx(double x); +# 3650 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcxf(float x); +# 3683 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float lgammaf(float x) +# 3683 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3683 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3712 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tgamma(double x) +# 3712 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3712 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3741 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tgammaf(float x) +# 3741 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3741 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3755 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double copysign(double x, double y) +# 3755 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3755 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3769 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float copysignf(float x, float y) +# 3769 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3769 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3788 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nextafter(double x, double y) +# 3788 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3788 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3807 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nextafterf(float x, float y) +# 3807 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3807 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3823 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nan(const char *tagp) +# 3823 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3823 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3839 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nanf(const char *tagp) +# 3839 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3839 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinff(float) +# 3846 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3846 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnanf(float) +# 3847 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3847 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3857 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finite(double) +# 3857 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3857 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finitef(float) +# 3858 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3858 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbit(double) +# 3859 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3859 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnan(double) +# 3860 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3860 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinf(double) +# 3861 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3861 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbitf(float) +# 3864 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3864 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3915 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fma(double x, double y, double z) +# 3915 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3915 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3965 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmaf(float x, float y, float z) +# 3965 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3965 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 3976 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbitl(long double) +# 3976 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3976 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finitel(long double) +# 3982 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3982 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinfl(long double) +# 3983 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3983 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnanl(long double) +# 3984 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 3984 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4028 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float acosf(float x) +# 4028 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4028 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4050 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float asinf(float x) +# 4050 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4050 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4077 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atanf(float x) +# 4077 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4077 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4157 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atan2f(float y, float x) +# 4157 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4157 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4176 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cosf(float x) +# 4176 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4176 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4196 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinf(float x) +# 4196 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4196 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4216 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tanf(float x) +# 4216 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4216 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4235 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float coshf(float x) +# 4235 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4235 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4255 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinhf(float x) +# 4255 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4255 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4275 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tanhf(float x) +# 4275 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4275 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4298 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float logf(float x) +# 4298 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4298 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4328 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float expf(float x) +# 4328 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4328 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4351 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log10f(float x) +# 4351 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4351 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4374 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float modff(float x, float *iptr) +# 4374 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4374 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4457 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float powf(float x, float y) +# 4457 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4457 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4481 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sqrtf(float x) +# 4481 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4481 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4504 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ceilf(float x) +# 4504 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4504 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4527 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float floorf(float x) +# 4527 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4527 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4553 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmodf(float x, float y) +# 4553 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 3 4 + noexcept (true) +# 4553 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + ; +# 4568 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +} + + +# 1 "/usr/include/c++/11/math.h" 1 3 +# 36 "/usr/include/c++/11/math.h" 3 +# 1 "/usr/include/c++/11/cmath" 1 3 +# 39 "/usr/include/c++/11/cmath" 3 + +# 40 "/usr/include/c++/11/cmath" 3 + + +# 1 "/usr/include/c++/11/bits/cpp_type_traits.h" 1 3 +# 35 "/usr/include/c++/11/bits/cpp_type_traits.h" 3 + +# 36 "/usr/include/c++/11/bits/cpp_type_traits.h" 3 +# 67 "/usr/include/c++/11/bits/cpp_type_traits.h" 3 + +# 67 "/usr/include/c++/11/bits/cpp_type_traits.h" 3 +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + struct __true_type { }; + struct __false_type { }; + + template + struct __truth_type + { typedef __false_type __type; }; + + template<> + struct __truth_type + { typedef __true_type __type; }; + + + + template + struct __traitor + { + enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; + typedef typename __truth_type<__value>::__type __type; + }; + + + template + struct __are_same + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __are_same<_Tp, _Tp> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_void + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_void + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_integer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 184 "/usr/include/c++/11/bits/cpp_type_traits.h" 3 + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 270 "/usr/include/c++/11/bits/cpp_type_traits.h" 3 +template<> struct __is_integer<__int128> { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; +# 287 "/usr/include/c++/11/bits/cpp_type_traits.h" 3 + template + struct __is_floating + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_pointer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __is_pointer<_Tp*> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_arithmetic + : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > + { }; + + + + + template + struct __is_scalar + : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > + { }; + + + + + template + struct __is_char + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_byte + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + enum class byte : unsigned char; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 423 "/usr/include/c++/11/bits/cpp_type_traits.h" 3 + template struct iterator_traits; + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = __is_trivially_copyable(_Tp) }; + }; + + + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = 0 }; + }; + + + template + struct __memcpyable + { + enum { __value = 0 }; + }; + + template + struct __memcpyable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcpyable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + template + struct __memcmpable + { + enum { __value = 0 }; + }; + + + template + struct __memcmpable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + + template::__value + + > + struct __is_memcmp_ordered + { + static const bool __value = _Tp(-1) > _Tp(1); + }; + + template + struct __is_memcmp_ordered<_Tp, false> + { + static const bool __value = false; + }; + + + template + struct __is_memcmp_ordered_with + { + static const bool __value = __is_memcmp_ordered<_Tp>::__value + && __is_memcmp_ordered<_Up>::__value; + }; + + template + struct __is_memcmp_ordered_with<_Tp, _Up, false> + { + static const bool __value = false; + }; +# 532 "/usr/include/c++/11/bits/cpp_type_traits.h" 3 + template<> + struct __is_memcmp_ordered_with + { static constexpr bool __value = true; }; + + template + struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize> + { static constexpr bool __value = false; }; + + template + struct __is_memcmp_ordered_with + { static constexpr bool __value = false; }; + + + + + + template + struct __is_move_iterator + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + template + + inline _Iterator + __miter_base(_Iterator __it) + { return __it; } + + +} +} +# 43 "/usr/include/c++/11/cmath" 2 3 +# 1 "/usr/include/c++/11/ext/type_traits.h" 1 3 +# 32 "/usr/include/c++/11/ext/type_traits.h" 3 + +# 33 "/usr/include/c++/11/ext/type_traits.h" 3 + + + + +extern "C++" { + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct __enable_if + { }; + + template + struct __enable_if + { typedef _Tp __type; }; + + + + template + struct __conditional_type + { typedef _Iftrue __type; }; + + template + struct __conditional_type + { typedef _Iffalse __type; }; + + + + template + struct __add_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned short __type; }; + + template<> + struct __add_unsigned + { typedef unsigned int __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long long __type; }; + + + template<> + struct __add_unsigned; + + template<> + struct __add_unsigned; + + + + template + struct __remove_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef short __type; }; + + template<> + struct __remove_unsigned + { typedef int __type; }; + + template<> + struct __remove_unsigned + { typedef long __type; }; + + template<> + struct __remove_unsigned + { typedef long long __type; }; + + + template<> + struct __remove_unsigned; + + template<> + struct __remove_unsigned; + + + + template + inline bool + __is_null_pointer(_Type* __ptr) + { return __ptr == 0; } + + template + inline bool + __is_null_pointer(_Type) + { return false; } + + + inline bool + __is_null_pointer(std::nullptr_t) + { return true; } + + + + + template::__value> + struct __promote + { typedef double __type; }; + + + + + template + struct __promote<_Tp, false> + { }; + + template<> + struct __promote + { typedef long double __type; }; + + template<> + struct __promote + { typedef double __type; }; + + template<> + struct __promote + { typedef float __type; }; + + + template + using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...)); + + + template::__type, + typename _Up2 = typename __promote<_Up>::__type> + struct __promote_2 + { + typedef __typeof__(_Tp2() + _Up2()) __type; + }; + + template::__type, + typename _Up2 = typename __promote<_Up>::__type, + typename _Vp2 = typename __promote<_Vp>::__type> + struct __promote_3 + { + typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type; + }; + + template::__type, + typename _Up2 = typename __promote<_Up>::__type, + typename _Vp2 = typename __promote<_Vp>::__type, + typename _Wp2 = typename __promote<_Wp>::__type> + struct __promote_4 + { + typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type; + }; + + +} +} +# 44 "/usr/include/c++/11/cmath" 2 3 + +# 1 "/usr/include/math.h" 1 3 4 +# 27 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4 +# 28 "/usr/include/math.h" 2 3 4 + + + + + + +extern "C" { + + + + + +# 1 "/usr/include/x86_64-linux-gnu/bits/math-vector.h" 1 3 4 +# 25 "/usr/include/x86_64-linux-gnu/bits/math-vector.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h" 1 3 4 +# 26 "/usr/include/x86_64-linux-gnu/bits/math-vector.h" 2 3 4 +# 41 "/usr/include/math.h" 2 3 4 +# 152 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h" 1 3 4 +# 153 "/usr/include/math.h" 2 3 4 +# 163 "/usr/include/math.h" 3 4 +typedef float float_t; +typedef double double_t; +# 204 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/fp-logb.h" 1 3 4 +# 205 "/usr/include/math.h" 2 3 4 +# 247 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/fp-fast.h" 1 3 4 +# 248 "/usr/include/math.h" 2 3 4 + + + +enum + { + FP_INT_UPWARD = + + 0, + FP_INT_DOWNWARD = + + 1, + FP_INT_TOWARDZERO = + + 2, + FP_INT_TONEARESTFROMZERO = + + 3, + FP_INT_TONEAREST = + + 4, + }; +# 312 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassify (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbit (double __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinf (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finite (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnan (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsig (double __x, double __y) noexcept (true); + + +extern int __issignaling (double __value) noexcept (true) + __attribute__ ((__const__)); +# 313 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 + extern double acos (double __x) noexcept (true); extern double __acos (double __x) noexcept (true); + + extern double asin (double __x) noexcept (true); extern double __asin (double __x) noexcept (true); + + extern double atan (double __x) noexcept (true); extern double __atan (double __x) noexcept (true); + + extern double atan2 (double __y, double __x) noexcept (true); extern double __atan2 (double __y, double __x) noexcept (true); + + + extern double cos (double __x) noexcept (true); extern double __cos (double __x) noexcept (true); + + extern double sin (double __x) noexcept (true); extern double __sin (double __x) noexcept (true); + + extern double tan (double __x) noexcept (true); extern double __tan (double __x) noexcept (true); + + + + + extern double cosh (double __x) noexcept (true); extern double __cosh (double __x) noexcept (true); + + extern double sinh (double __x) noexcept (true); extern double __sinh (double __x) noexcept (true); + + extern double tanh (double __x) noexcept (true); extern double __tanh (double __x) noexcept (true); + + + + extern void sincos (double __x, double *__sinx, double *__cosx) noexcept (true); extern void __sincos (double __x, double *__sinx, double *__cosx) noexcept (true) + ; + + + + + extern double acosh (double __x) noexcept (true); extern double __acosh (double __x) noexcept (true); + + extern double asinh (double __x) noexcept (true); extern double __asinh (double __x) noexcept (true); + + extern double atanh (double __x) noexcept (true); extern double __atanh (double __x) noexcept (true); + + + + + + extern double exp (double __x) noexcept (true); extern double __exp (double __x) noexcept (true); + + +extern double frexp (double __x, int *__exponent) noexcept (true); extern double __frexp (double __x, int *__exponent) noexcept (true); + + +extern double ldexp (double __x, int __exponent) noexcept (true); extern double __ldexp (double __x, int __exponent) noexcept (true); + + + extern double log (double __x) noexcept (true); extern double __log (double __x) noexcept (true); + + + extern double log10 (double __x) noexcept (true); extern double __log10 (double __x) noexcept (true); + + +extern double modf (double __x, double *__iptr) noexcept (true); extern double __modf (double __x, double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern double exp10 (double __x) noexcept (true); extern double __exp10 (double __x) noexcept (true); + + + + + extern double expm1 (double __x) noexcept (true); extern double __expm1 (double __x) noexcept (true); + + + extern double log1p (double __x) noexcept (true); extern double __log1p (double __x) noexcept (true); + + +extern double logb (double __x) noexcept (true); extern double __logb (double __x) noexcept (true); + + + + + extern double exp2 (double __x) noexcept (true); extern double __exp2 (double __x) noexcept (true); + + + extern double log2 (double __x) noexcept (true); extern double __log2 (double __x) noexcept (true); + + + + + + + extern double pow (double __x, double __y) noexcept (true); extern double __pow (double __x, double __y) noexcept (true); + + +extern double sqrt (double __x) noexcept (true); extern double __sqrt (double __x) noexcept (true); + + + + extern double hypot (double __x, double __y) noexcept (true); extern double __hypot (double __x, double __y) noexcept (true); + + + + + extern double cbrt (double __x) noexcept (true); extern double __cbrt (double __x) noexcept (true); + + + + + + +extern double ceil (double __x) noexcept (true) __attribute__ ((__const__)); extern double __ceil (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double fabs (double __x) noexcept (true) __attribute__ ((__const__)); extern double __fabs (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double floor (double __x) noexcept (true) __attribute__ ((__const__)); extern double __floor (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double fmod (double __x, double __y) noexcept (true); extern double __fmod (double __x, double __y) noexcept (true); +# 183 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern int finite (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern double drem (double __x, double __y) noexcept (true); extern double __drem (double __x, double __y) noexcept (true); + + + +extern double significand (double __x) noexcept (true); extern double __significand (double __x) noexcept (true); + + + + + + +extern double copysign (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __copysign (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern double nan (const char *__tagb) noexcept (true); extern double __nan (const char *__tagb) noexcept (true); +# 220 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern double j0 (double) noexcept (true); extern double __j0 (double) noexcept (true); +extern double j1 (double) noexcept (true); extern double __j1 (double) noexcept (true); +extern double jn (int, double) noexcept (true); extern double __jn (int, double) noexcept (true); +extern double y0 (double) noexcept (true); extern double __y0 (double) noexcept (true); +extern double y1 (double) noexcept (true); extern double __y1 (double) noexcept (true); +extern double yn (int, double) noexcept (true); extern double __yn (int, double) noexcept (true); + + + + + + extern double erf (double) noexcept (true); extern double __erf (double) noexcept (true); + extern double erfc (double) noexcept (true); extern double __erfc (double) noexcept (true); +extern double lgamma (double) noexcept (true); extern double __lgamma (double) noexcept (true); + + + + +extern double tgamma (double) noexcept (true); extern double __tgamma (double) noexcept (true); + + + + + +extern double gamma (double) noexcept (true); extern double __gamma (double) noexcept (true); + + + + + + + +extern double lgamma_r (double, int *__signgamp) noexcept (true); extern double __lgamma_r (double, int *__signgamp) noexcept (true); + + + + + + +extern double rint (double __x) noexcept (true); extern double __rint (double __x) noexcept (true); + + +extern double nextafter (double __x, double __y) noexcept (true); extern double __nextafter (double __x, double __y) noexcept (true); + +extern double nexttoward (double __x, long double __y) noexcept (true); extern double __nexttoward (double __x, long double __y) noexcept (true); + + + + +extern double nextdown (double __x) noexcept (true); extern double __nextdown (double __x) noexcept (true); + +extern double nextup (double __x) noexcept (true); extern double __nextup (double __x) noexcept (true); + + + +extern double remainder (double __x, double __y) noexcept (true); extern double __remainder (double __x, double __y) noexcept (true); + + + +extern double scalbn (double __x, int __n) noexcept (true); extern double __scalbn (double __x, int __n) noexcept (true); + + + +extern int ilogb (double __x) noexcept (true); extern int __ilogb (double __x) noexcept (true); + + + + +extern long int llogb (double __x) noexcept (true); extern long int __llogb (double __x) noexcept (true); + + + + +extern double scalbln (double __x, long int __n) noexcept (true); extern double __scalbln (double __x, long int __n) noexcept (true); + + + +extern double nearbyint (double __x) noexcept (true); extern double __nearbyint (double __x) noexcept (true); + + + +extern double round (double __x) noexcept (true) __attribute__ ((__const__)); extern double __round (double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern double trunc (double __x) noexcept (true) __attribute__ ((__const__)); extern double __trunc (double __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern double remquo (double __x, double __y, int *__quo) noexcept (true); extern double __remquo (double __x, double __y, int *__quo) noexcept (true); + + + + + + +extern long int lrint (double __x) noexcept (true); extern long int __lrint (double __x) noexcept (true); +__extension__ +extern long long int llrint (double __x) noexcept (true); extern long long int __llrint (double __x) noexcept (true); + + + +extern long int lround (double __x) noexcept (true); extern long int __lround (double __x) noexcept (true); +__extension__ +extern long long int llround (double __x) noexcept (true); extern long long int __llround (double __x) noexcept (true); + + + +extern double fdim (double __x, double __y) noexcept (true); extern double __fdim (double __x, double __y) noexcept (true); + + + +extern double fmax (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmax (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + +extern double fma (double __x, double __y, double __z) noexcept (true); extern double __fma (double __x, double __y, double __z) noexcept (true); + + + + +extern double roundeven (double __x) noexcept (true) __attribute__ ((__const__)); extern double __roundeven (double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfp (double __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfp (double __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpx (double __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpx (double __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalize (double *__cx, const double *__x) noexcept (true); + + + + + + +extern double fmaxmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaxmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern double fmaximum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorder (const double *__x, const double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermag (const double *__x, const double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern double getpayload (const double *__x) noexcept (true); extern double __getpayload (const double *__x) noexcept (true); + + +extern int setpayload (double *__x, double __payload) noexcept (true); + + +extern int setpayloadsig (double *__x, double __payload) noexcept (true); + + + + + + + +extern double scalb (double __x, double __n) noexcept (true); extern double __scalb (double __x, double __n) noexcept (true); +# 314 "/usr/include/math.h" 2 3 4 +# 329 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyf (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitf (float __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinff (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitef (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanf (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigf (float __x, float __y) noexcept (true); + + +extern int __issignalingf (float __value) noexcept (true) + __attribute__ ((__const__)); +# 330 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 + extern float acosf (float __x) noexcept (true); extern float __acosf (float __x) noexcept (true); + + extern float asinf (float __x) noexcept (true); extern float __asinf (float __x) noexcept (true); + + extern float atanf (float __x) noexcept (true); extern float __atanf (float __x) noexcept (true); + + extern float atan2f (float __y, float __x) noexcept (true); extern float __atan2f (float __y, float __x) noexcept (true); + + + extern float cosf (float __x) noexcept (true); extern float __cosf (float __x) noexcept (true); + + extern float sinf (float __x) noexcept (true); extern float __sinf (float __x) noexcept (true); + + extern float tanf (float __x) noexcept (true); extern float __tanf (float __x) noexcept (true); + + + + + extern float coshf (float __x) noexcept (true); extern float __coshf (float __x) noexcept (true); + + extern float sinhf (float __x) noexcept (true); extern float __sinhf (float __x) noexcept (true); + + extern float tanhf (float __x) noexcept (true); extern float __tanhf (float __x) noexcept (true); + + + + extern void sincosf (float __x, float *__sinx, float *__cosx) noexcept (true); extern void __sincosf (float __x, float *__sinx, float *__cosx) noexcept (true) + ; + + + + + extern float acoshf (float __x) noexcept (true); extern float __acoshf (float __x) noexcept (true); + + extern float asinhf (float __x) noexcept (true); extern float __asinhf (float __x) noexcept (true); + + extern float atanhf (float __x) noexcept (true); extern float __atanhf (float __x) noexcept (true); + + + + + + extern float expf (float __x) noexcept (true); extern float __expf (float __x) noexcept (true); + + +extern float frexpf (float __x, int *__exponent) noexcept (true); extern float __frexpf (float __x, int *__exponent) noexcept (true); + + +extern float ldexpf (float __x, int __exponent) noexcept (true); extern float __ldexpf (float __x, int __exponent) noexcept (true); + + + extern float logf (float __x) noexcept (true); extern float __logf (float __x) noexcept (true); + + + extern float log10f (float __x) noexcept (true); extern float __log10f (float __x) noexcept (true); + + +extern float modff (float __x, float *__iptr) noexcept (true); extern float __modff (float __x, float *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern float exp10f (float __x) noexcept (true); extern float __exp10f (float __x) noexcept (true); + + + + + extern float expm1f (float __x) noexcept (true); extern float __expm1f (float __x) noexcept (true); + + + extern float log1pf (float __x) noexcept (true); extern float __log1pf (float __x) noexcept (true); + + +extern float logbf (float __x) noexcept (true); extern float __logbf (float __x) noexcept (true); + + + + + extern float exp2f (float __x) noexcept (true); extern float __exp2f (float __x) noexcept (true); + + + extern float log2f (float __x) noexcept (true); extern float __log2f (float __x) noexcept (true); + + + + + + + extern float powf (float __x, float __y) noexcept (true); extern float __powf (float __x, float __y) noexcept (true); + + +extern float sqrtf (float __x) noexcept (true); extern float __sqrtf (float __x) noexcept (true); + + + + extern float hypotf (float __x, float __y) noexcept (true); extern float __hypotf (float __x, float __y) noexcept (true); + + + + + extern float cbrtf (float __x) noexcept (true); extern float __cbrtf (float __x) noexcept (true); + + + + + + +extern float ceilf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __ceilf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float fabsf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __fabsf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float floorf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __floorf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float fmodf (float __x, float __y) noexcept (true); extern float __fmodf (float __x, float __y) noexcept (true); +# 177 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern int isinff (float __value) noexcept (true) + __attribute__ ((__const__)); + + + + +extern int finitef (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern float dremf (float __x, float __y) noexcept (true); extern float __dremf (float __x, float __y) noexcept (true); + + + +extern float significandf (float __x) noexcept (true); extern float __significandf (float __x) noexcept (true); + + + + + + +extern float copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern float nanf (const char *__tagb) noexcept (true); extern float __nanf (const char *__tagb) noexcept (true); +# 213 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern int isnanf (float __value) noexcept (true) + __attribute__ ((__const__)); + + + + + +extern float j0f (float) noexcept (true); extern float __j0f (float) noexcept (true); +extern float j1f (float) noexcept (true); extern float __j1f (float) noexcept (true); +extern float jnf (int, float) noexcept (true); extern float __jnf (int, float) noexcept (true); +extern float y0f (float) noexcept (true); extern float __y0f (float) noexcept (true); +extern float y1f (float) noexcept (true); extern float __y1f (float) noexcept (true); +extern float ynf (int, float) noexcept (true); extern float __ynf (int, float) noexcept (true); + + + + + + extern float erff (float) noexcept (true); extern float __erff (float) noexcept (true); + extern float erfcf (float) noexcept (true); extern float __erfcf (float) noexcept (true); +extern float lgammaf (float) noexcept (true); extern float __lgammaf (float) noexcept (true); + + + + +extern float tgammaf (float) noexcept (true); extern float __tgammaf (float) noexcept (true); + + + + + +extern float gammaf (float) noexcept (true); extern float __gammaf (float) noexcept (true); + + + + + + + +extern float lgammaf_r (float, int *__signgamp) noexcept (true); extern float __lgammaf_r (float, int *__signgamp) noexcept (true); + + + + + + +extern float rintf (float __x) noexcept (true); extern float __rintf (float __x) noexcept (true); + + +extern float nextafterf (float __x, float __y) noexcept (true); extern float __nextafterf (float __x, float __y) noexcept (true); + +extern float nexttowardf (float __x, long double __y) noexcept (true); extern float __nexttowardf (float __x, long double __y) noexcept (true); + + + + +extern float nextdownf (float __x) noexcept (true); extern float __nextdownf (float __x) noexcept (true); + +extern float nextupf (float __x) noexcept (true); extern float __nextupf (float __x) noexcept (true); + + + +extern float remainderf (float __x, float __y) noexcept (true); extern float __remainderf (float __x, float __y) noexcept (true); + + + +extern float scalbnf (float __x, int __n) noexcept (true); extern float __scalbnf (float __x, int __n) noexcept (true); + + + +extern int ilogbf (float __x) noexcept (true); extern int __ilogbf (float __x) noexcept (true); + + + + +extern long int llogbf (float __x) noexcept (true); extern long int __llogbf (float __x) noexcept (true); + + + + +extern float scalblnf (float __x, long int __n) noexcept (true); extern float __scalblnf (float __x, long int __n) noexcept (true); + + + +extern float nearbyintf (float __x) noexcept (true); extern float __nearbyintf (float __x) noexcept (true); + + + +extern float roundf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __roundf (float __x) noexcept (true) __attribute__ ((__const__)); + + + +extern float truncf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __truncf (float __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern float remquof (float __x, float __y, int *__quo) noexcept (true); extern float __remquof (float __x, float __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf (float __x) noexcept (true); extern long int __lrintf (float __x) noexcept (true); +__extension__ +extern long long int llrintf (float __x) noexcept (true); extern long long int __llrintf (float __x) noexcept (true); + + + +extern long int lroundf (float __x) noexcept (true); extern long int __lroundf (float __x) noexcept (true); +__extension__ +extern long long int llroundf (float __x) noexcept (true); extern long long int __llroundf (float __x) noexcept (true); + + + +extern float fdimf (float __x, float __y) noexcept (true); extern float __fdimf (float __x, float __y) noexcept (true); + + + +extern float fmaxf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + +extern float fmaf (float __x, float __y, float __z) noexcept (true); extern float __fmaf (float __x, float __y, float __z) noexcept (true); + + + + +extern float roundevenf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __roundevenf (float __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf (float __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf (float __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf (float __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef (float *__cx, const float *__x) noexcept (true); + + + + + + +extern float fmaxmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaxmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern float fmaximumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf (const float *__x, const float *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf (const float *__x, const float *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern float getpayloadf (const float *__x) noexcept (true); extern float __getpayloadf (const float *__x) noexcept (true); + + +extern int setpayloadf (float *__x, float __payload) noexcept (true); + + +extern int setpayloadsigf (float *__x, float __payload) noexcept (true); + + + + + + + +extern float scalbf (float __x, float __n) noexcept (true); extern float __scalbf (float __x, float __n) noexcept (true); +# 331 "/usr/include/math.h" 2 3 4 +# 398 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinfl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitel (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigl (long double __x, long double __y) noexcept (true); + + +extern int __issignalingl (long double __value) noexcept (true) + __attribute__ ((__const__)); +# 399 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 + extern long double acosl (long double __x) noexcept (true); extern long double __acosl (long double __x) noexcept (true); + + extern long double asinl (long double __x) noexcept (true); extern long double __asinl (long double __x) noexcept (true); + + extern long double atanl (long double __x) noexcept (true); extern long double __atanl (long double __x) noexcept (true); + + extern long double atan2l (long double __y, long double __x) noexcept (true); extern long double __atan2l (long double __y, long double __x) noexcept (true); + + + extern long double cosl (long double __x) noexcept (true); extern long double __cosl (long double __x) noexcept (true); + + extern long double sinl (long double __x) noexcept (true); extern long double __sinl (long double __x) noexcept (true); + + extern long double tanl (long double __x) noexcept (true); extern long double __tanl (long double __x) noexcept (true); + + + + + extern long double coshl (long double __x) noexcept (true); extern long double __coshl (long double __x) noexcept (true); + + extern long double sinhl (long double __x) noexcept (true); extern long double __sinhl (long double __x) noexcept (true); + + extern long double tanhl (long double __x) noexcept (true); extern long double __tanhl (long double __x) noexcept (true); + + + + extern void sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true) + ; + + + + + extern long double acoshl (long double __x) noexcept (true); extern long double __acoshl (long double __x) noexcept (true); + + extern long double asinhl (long double __x) noexcept (true); extern long double __asinhl (long double __x) noexcept (true); + + extern long double atanhl (long double __x) noexcept (true); extern long double __atanhl (long double __x) noexcept (true); + + + + + + extern long double expl (long double __x) noexcept (true); extern long double __expl (long double __x) noexcept (true); + + +extern long double frexpl (long double __x, int *__exponent) noexcept (true); extern long double __frexpl (long double __x, int *__exponent) noexcept (true); + + +extern long double ldexpl (long double __x, int __exponent) noexcept (true); extern long double __ldexpl (long double __x, int __exponent) noexcept (true); + + + extern long double logl (long double __x) noexcept (true); extern long double __logl (long double __x) noexcept (true); + + + extern long double log10l (long double __x) noexcept (true); extern long double __log10l (long double __x) noexcept (true); + + +extern long double modfl (long double __x, long double *__iptr) noexcept (true); extern long double __modfl (long double __x, long double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern long double exp10l (long double __x) noexcept (true); extern long double __exp10l (long double __x) noexcept (true); + + + + + extern long double expm1l (long double __x) noexcept (true); extern long double __expm1l (long double __x) noexcept (true); + + + extern long double log1pl (long double __x) noexcept (true); extern long double __log1pl (long double __x) noexcept (true); + + +extern long double logbl (long double __x) noexcept (true); extern long double __logbl (long double __x) noexcept (true); + + + + + extern long double exp2l (long double __x) noexcept (true); extern long double __exp2l (long double __x) noexcept (true); + + + extern long double log2l (long double __x) noexcept (true); extern long double __log2l (long double __x) noexcept (true); + + + + + + + extern long double powl (long double __x, long double __y) noexcept (true); extern long double __powl (long double __x, long double __y) noexcept (true); + + +extern long double sqrtl (long double __x) noexcept (true); extern long double __sqrtl (long double __x) noexcept (true); + + + + extern long double hypotl (long double __x, long double __y) noexcept (true); extern long double __hypotl (long double __x, long double __y) noexcept (true); + + + + + extern long double cbrtl (long double __x) noexcept (true); extern long double __cbrtl (long double __x) noexcept (true); + + + + + + +extern long double ceill (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __ceill (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double fabsl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __fabsl (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double floorl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __floorl (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmodl (long double __x, long double __y) noexcept (true); extern long double __fmodl (long double __x, long double __y) noexcept (true); +# 177 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern int isinfl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + + +extern int finitel (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern long double dreml (long double __x, long double __y) noexcept (true); extern long double __dreml (long double __x, long double __y) noexcept (true); + + + +extern long double significandl (long double __x) noexcept (true); extern long double __significandl (long double __x) noexcept (true); + + + + + + +extern long double copysignl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double nanl (const char *__tagb) noexcept (true); extern long double __nanl (const char *__tagb) noexcept (true); +# 213 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern int isnanl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + + + +extern long double j0l (long double) noexcept (true); extern long double __j0l (long double) noexcept (true); +extern long double j1l (long double) noexcept (true); extern long double __j1l (long double) noexcept (true); +extern long double jnl (int, long double) noexcept (true); extern long double __jnl (int, long double) noexcept (true); +extern long double y0l (long double) noexcept (true); extern long double __y0l (long double) noexcept (true); +extern long double y1l (long double) noexcept (true); extern long double __y1l (long double) noexcept (true); +extern long double ynl (int, long double) noexcept (true); extern long double __ynl (int, long double) noexcept (true); + + + + + + extern long double erfl (long double) noexcept (true); extern long double __erfl (long double) noexcept (true); + extern long double erfcl (long double) noexcept (true); extern long double __erfcl (long double) noexcept (true); +extern long double lgammal (long double) noexcept (true); extern long double __lgammal (long double) noexcept (true); + + + + +extern long double tgammal (long double) noexcept (true); extern long double __tgammal (long double) noexcept (true); + + + + + +extern long double gammal (long double) noexcept (true); extern long double __gammal (long double) noexcept (true); + + + + + + + +extern long double lgammal_r (long double, int *__signgamp) noexcept (true); extern long double __lgammal_r (long double, int *__signgamp) noexcept (true); + + + + + + +extern long double rintl (long double __x) noexcept (true); extern long double __rintl (long double __x) noexcept (true); + + +extern long double nextafterl (long double __x, long double __y) noexcept (true); extern long double __nextafterl (long double __x, long double __y) noexcept (true); + +extern long double nexttowardl (long double __x, long double __y) noexcept (true); extern long double __nexttowardl (long double __x, long double __y) noexcept (true); + + + + +extern long double nextdownl (long double __x) noexcept (true); extern long double __nextdownl (long double __x) noexcept (true); + +extern long double nextupl (long double __x) noexcept (true); extern long double __nextupl (long double __x) noexcept (true); + + + +extern long double remainderl (long double __x, long double __y) noexcept (true); extern long double __remainderl (long double __x, long double __y) noexcept (true); + + + +extern long double scalbnl (long double __x, int __n) noexcept (true); extern long double __scalbnl (long double __x, int __n) noexcept (true); + + + +extern int ilogbl (long double __x) noexcept (true); extern int __ilogbl (long double __x) noexcept (true); + + + + +extern long int llogbl (long double __x) noexcept (true); extern long int __llogbl (long double __x) noexcept (true); + + + + +extern long double scalblnl (long double __x, long int __n) noexcept (true); extern long double __scalblnl (long double __x, long int __n) noexcept (true); + + + +extern long double nearbyintl (long double __x) noexcept (true); extern long double __nearbyintl (long double __x) noexcept (true); + + + +extern long double roundl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __roundl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern long double truncl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __truncl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double remquol (long double __x, long double __y, int *__quo) noexcept (true); extern long double __remquol (long double __x, long double __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintl (long double __x) noexcept (true); extern long int __lrintl (long double __x) noexcept (true); +__extension__ +extern long long int llrintl (long double __x) noexcept (true); extern long long int __llrintl (long double __x) noexcept (true); + + + +extern long int lroundl (long double __x) noexcept (true); extern long int __lroundl (long double __x) noexcept (true); +__extension__ +extern long long int llroundl (long double __x) noexcept (true); extern long long int __llroundl (long double __x) noexcept (true); + + + +extern long double fdiml (long double __x, long double __y) noexcept (true); extern long double __fdiml (long double __x, long double __y) noexcept (true); + + + +extern long double fmaxl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + +extern long double fmal (long double __x, long double __y, long double __z) noexcept (true); extern long double __fmal (long double __x, long double __y, long double __z) noexcept (true); + + + + +extern long double roundevenl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __roundevenl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpl (long double __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizel (long double *__cx, const long double *__x) noexcept (true); + + + + + + +extern long double fmaxmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaxmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double fmaximuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmaximum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmaximum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmaximum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderl (const long double *__x, const long double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagl (const long double *__x, const long double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern long double getpayloadl (const long double *__x) noexcept (true); extern long double __getpayloadl (const long double *__x) noexcept (true); + + +extern int setpayloadl (long double *__x, long double __payload) noexcept (true); + + +extern int setpayloadsigl (long double *__x, long double __payload) noexcept (true); + + + + + + + +extern long double scalbl (long double __x, long double __n) noexcept (true); extern long double __scalbl (long double __x, long double __n) noexcept (true); +# 400 "/usr/include/math.h" 2 3 4 +# 450 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 + extern _Float32 acosf32 (_Float32 __x) noexcept (true); extern _Float32 __acosf32 (_Float32 __x) noexcept (true); + + extern _Float32 asinf32 (_Float32 __x) noexcept (true); extern _Float32 __asinf32 (_Float32 __x) noexcept (true); + + extern _Float32 atanf32 (_Float32 __x) noexcept (true); extern _Float32 __atanf32 (_Float32 __x) noexcept (true); + + extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); extern _Float32 __atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); + + + extern _Float32 cosf32 (_Float32 __x) noexcept (true); extern _Float32 __cosf32 (_Float32 __x) noexcept (true); + + extern _Float32 sinf32 (_Float32 __x) noexcept (true); extern _Float32 __sinf32 (_Float32 __x) noexcept (true); + + extern _Float32 tanf32 (_Float32 __x) noexcept (true); extern _Float32 __tanf32 (_Float32 __x) noexcept (true); + + + + + extern _Float32 coshf32 (_Float32 __x) noexcept (true); extern _Float32 __coshf32 (_Float32 __x) noexcept (true); + + extern _Float32 sinhf32 (_Float32 __x) noexcept (true); extern _Float32 __sinhf32 (_Float32 __x) noexcept (true); + + extern _Float32 tanhf32 (_Float32 __x) noexcept (true); extern _Float32 __tanhf32 (_Float32 __x) noexcept (true); + + + + extern void sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true); extern void __sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true) + ; + + + + + extern _Float32 acoshf32 (_Float32 __x) noexcept (true); extern _Float32 __acoshf32 (_Float32 __x) noexcept (true); + + extern _Float32 asinhf32 (_Float32 __x) noexcept (true); extern _Float32 __asinhf32 (_Float32 __x) noexcept (true); + + extern _Float32 atanhf32 (_Float32 __x) noexcept (true); extern _Float32 __atanhf32 (_Float32 __x) noexcept (true); + + + + + + extern _Float32 expf32 (_Float32 __x) noexcept (true); extern _Float32 __expf32 (_Float32 __x) noexcept (true); + + +extern _Float32 frexpf32 (_Float32 __x, int *__exponent) noexcept (true); extern _Float32 __frexpf32 (_Float32 __x, int *__exponent) noexcept (true); + + +extern _Float32 ldexpf32 (_Float32 __x, int __exponent) noexcept (true); extern _Float32 __ldexpf32 (_Float32 __x, int __exponent) noexcept (true); + + + extern _Float32 logf32 (_Float32 __x) noexcept (true); extern _Float32 __logf32 (_Float32 __x) noexcept (true); + + + extern _Float32 log10f32 (_Float32 __x) noexcept (true); extern _Float32 __log10f32 (_Float32 __x) noexcept (true); + + +extern _Float32 modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true); extern _Float32 __modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float32 exp10f32 (_Float32 __x) noexcept (true); extern _Float32 __exp10f32 (_Float32 __x) noexcept (true); + + + + + extern _Float32 expm1f32 (_Float32 __x) noexcept (true); extern _Float32 __expm1f32 (_Float32 __x) noexcept (true); + + + extern _Float32 log1pf32 (_Float32 __x) noexcept (true); extern _Float32 __log1pf32 (_Float32 __x) noexcept (true); + + +extern _Float32 logbf32 (_Float32 __x) noexcept (true); extern _Float32 __logbf32 (_Float32 __x) noexcept (true); + + + + + extern _Float32 exp2f32 (_Float32 __x) noexcept (true); extern _Float32 __exp2f32 (_Float32 __x) noexcept (true); + + + extern _Float32 log2f32 (_Float32 __x) noexcept (true); extern _Float32 __log2f32 (_Float32 __x) noexcept (true); + + + + + + + extern _Float32 powf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __powf32 (_Float32 __x, _Float32 __y) noexcept (true); + + +extern _Float32 sqrtf32 (_Float32 __x) noexcept (true); extern _Float32 __sqrtf32 (_Float32 __x) noexcept (true); + + + + extern _Float32 hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + + + extern _Float32 cbrtf32 (_Float32 __x) noexcept (true); extern _Float32 __cbrtf32 (_Float32 __x) noexcept (true); + + + + + + +extern _Float32 ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fabsf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fabsf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 floorf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __floorf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); +# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 nanf32 (const char *__tagb) noexcept (true); extern _Float32 __nanf32 (const char *__tagb) noexcept (true); +# 220 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32 j0f32 (_Float32) noexcept (true); extern _Float32 __j0f32 (_Float32) noexcept (true); +extern _Float32 j1f32 (_Float32) noexcept (true); extern _Float32 __j1f32 (_Float32) noexcept (true); +extern _Float32 jnf32 (int, _Float32) noexcept (true); extern _Float32 __jnf32 (int, _Float32) noexcept (true); +extern _Float32 y0f32 (_Float32) noexcept (true); extern _Float32 __y0f32 (_Float32) noexcept (true); +extern _Float32 y1f32 (_Float32) noexcept (true); extern _Float32 __y1f32 (_Float32) noexcept (true); +extern _Float32 ynf32 (int, _Float32) noexcept (true); extern _Float32 __ynf32 (int, _Float32) noexcept (true); + + + + + + extern _Float32 erff32 (_Float32) noexcept (true); extern _Float32 __erff32 (_Float32) noexcept (true); + extern _Float32 erfcf32 (_Float32) noexcept (true); extern _Float32 __erfcf32 (_Float32) noexcept (true); +extern _Float32 lgammaf32 (_Float32) noexcept (true); extern _Float32 __lgammaf32 (_Float32) noexcept (true); + + + + +extern _Float32 tgammaf32 (_Float32) noexcept (true); extern _Float32 __tgammaf32 (_Float32) noexcept (true); +# 252 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32 lgammaf32_r (_Float32, int *__signgamp) noexcept (true); extern _Float32 __lgammaf32_r (_Float32, int *__signgamp) noexcept (true); + + + + + + +extern _Float32 rintf32 (_Float32 __x) noexcept (true); extern _Float32 __rintf32 (_Float32 __x) noexcept (true); + + +extern _Float32 nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + + + + +extern _Float32 nextdownf32 (_Float32 __x) noexcept (true); extern _Float32 __nextdownf32 (_Float32 __x) noexcept (true); + +extern _Float32 nextupf32 (_Float32 __x) noexcept (true); extern _Float32 __nextupf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 remainderf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __remainderf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + +extern _Float32 scalbnf32 (_Float32 __x, int __n) noexcept (true); extern _Float32 __scalbnf32 (_Float32 __x, int __n) noexcept (true); + + + +extern int ilogbf32 (_Float32 __x) noexcept (true); extern int __ilogbf32 (_Float32 __x) noexcept (true); + + + + +extern long int llogbf32 (_Float32 __x) noexcept (true); extern long int __llogbf32 (_Float32 __x) noexcept (true); + + + + +extern _Float32 scalblnf32 (_Float32 __x, long int __n) noexcept (true); extern _Float32 __scalblnf32 (_Float32 __x, long int __n) noexcept (true); + + + +extern _Float32 nearbyintf32 (_Float32 __x) noexcept (true); extern _Float32 __nearbyintf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32 truncf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __truncf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true); extern _Float32 __remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf32 (_Float32 __x) noexcept (true); extern long int __lrintf32 (_Float32 __x) noexcept (true); +__extension__ +extern long long int llrintf32 (_Float32 __x) noexcept (true); extern long long int __llrintf32 (_Float32 __x) noexcept (true); + + + +extern long int lroundf32 (_Float32 __x) noexcept (true); extern long int __lroundf32 (_Float32 __x) noexcept (true); +__extension__ +extern long long int llroundf32 (_Float32 __x) noexcept (true); extern long long int __llroundf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + +extern _Float32 fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32 fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true); extern _Float32 __fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true); + + + + +extern _Float32 roundevenf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __roundevenf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef32 (_Float32 *__cx, const _Float32 *__x) noexcept (true); + + + + + + +extern _Float32 fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 fmaximumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float32 getpayloadf32 (const _Float32 *__x) noexcept (true); extern _Float32 __getpayloadf32 (const _Float32 *__x) noexcept (true); + + +extern int setpayloadf32 (_Float32 *__x, _Float32 __payload) noexcept (true); + + +extern int setpayloadsigf32 (_Float32 *__x, _Float32 __payload) noexcept (true); +# 451 "/usr/include/math.h" 2 3 4 +# 467 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 + extern _Float64 acosf64 (_Float64 __x) noexcept (true); extern _Float64 __acosf64 (_Float64 __x) noexcept (true); + + extern _Float64 asinf64 (_Float64 __x) noexcept (true); extern _Float64 __asinf64 (_Float64 __x) noexcept (true); + + extern _Float64 atanf64 (_Float64 __x) noexcept (true); extern _Float64 __atanf64 (_Float64 __x) noexcept (true); + + extern _Float64 atan2f64 (_Float64 __y, _Float64 __x) noexcept (true); extern _Float64 __atan2f64 (_Float64 __y, _Float64 __x) noexcept (true); + + + extern _Float64 cosf64 (_Float64 __x) noexcept (true); extern _Float64 __cosf64 (_Float64 __x) noexcept (true); + + extern _Float64 sinf64 (_Float64 __x) noexcept (true); extern _Float64 __sinf64 (_Float64 __x) noexcept (true); + + extern _Float64 tanf64 (_Float64 __x) noexcept (true); extern _Float64 __tanf64 (_Float64 __x) noexcept (true); + + + + + extern _Float64 coshf64 (_Float64 __x) noexcept (true); extern _Float64 __coshf64 (_Float64 __x) noexcept (true); + + extern _Float64 sinhf64 (_Float64 __x) noexcept (true); extern _Float64 __sinhf64 (_Float64 __x) noexcept (true); + + extern _Float64 tanhf64 (_Float64 __x) noexcept (true); extern _Float64 __tanhf64 (_Float64 __x) noexcept (true); + + + + extern void sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) noexcept (true); extern void __sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) noexcept (true) + ; + + + + + extern _Float64 acoshf64 (_Float64 __x) noexcept (true); extern _Float64 __acoshf64 (_Float64 __x) noexcept (true); + + extern _Float64 asinhf64 (_Float64 __x) noexcept (true); extern _Float64 __asinhf64 (_Float64 __x) noexcept (true); + + extern _Float64 atanhf64 (_Float64 __x) noexcept (true); extern _Float64 __atanhf64 (_Float64 __x) noexcept (true); + + + + + + extern _Float64 expf64 (_Float64 __x) noexcept (true); extern _Float64 __expf64 (_Float64 __x) noexcept (true); + + +extern _Float64 frexpf64 (_Float64 __x, int *__exponent) noexcept (true); extern _Float64 __frexpf64 (_Float64 __x, int *__exponent) noexcept (true); + + +extern _Float64 ldexpf64 (_Float64 __x, int __exponent) noexcept (true); extern _Float64 __ldexpf64 (_Float64 __x, int __exponent) noexcept (true); + + + extern _Float64 logf64 (_Float64 __x) noexcept (true); extern _Float64 __logf64 (_Float64 __x) noexcept (true); + + + extern _Float64 log10f64 (_Float64 __x) noexcept (true); extern _Float64 __log10f64 (_Float64 __x) noexcept (true); + + +extern _Float64 modff64 (_Float64 __x, _Float64 *__iptr) noexcept (true); extern _Float64 __modff64 (_Float64 __x, _Float64 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float64 exp10f64 (_Float64 __x) noexcept (true); extern _Float64 __exp10f64 (_Float64 __x) noexcept (true); + + + + + extern _Float64 expm1f64 (_Float64 __x) noexcept (true); extern _Float64 __expm1f64 (_Float64 __x) noexcept (true); + + + extern _Float64 log1pf64 (_Float64 __x) noexcept (true); extern _Float64 __log1pf64 (_Float64 __x) noexcept (true); + + +extern _Float64 logbf64 (_Float64 __x) noexcept (true); extern _Float64 __logbf64 (_Float64 __x) noexcept (true); + + + + + extern _Float64 exp2f64 (_Float64 __x) noexcept (true); extern _Float64 __exp2f64 (_Float64 __x) noexcept (true); + + + extern _Float64 log2f64 (_Float64 __x) noexcept (true); extern _Float64 __log2f64 (_Float64 __x) noexcept (true); + + + + + + + extern _Float64 powf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __powf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float64 sqrtf64 (_Float64 __x) noexcept (true); extern _Float64 __sqrtf64 (_Float64 __x) noexcept (true); + + + + extern _Float64 hypotf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __hypotf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + + + extern _Float64 cbrtf64 (_Float64 __x) noexcept (true); extern _Float64 __cbrtf64 (_Float64 __x) noexcept (true); + + + + + + +extern _Float64 ceilf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __ceilf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fabsf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fabsf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 floorf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __floorf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmodf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __fmodf64 (_Float64 __x, _Float64 __y) noexcept (true); +# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64 copysignf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __copysignf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64 nanf64 (const char *__tagb) noexcept (true); extern _Float64 __nanf64 (const char *__tagb) noexcept (true); +# 220 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64 j0f64 (_Float64) noexcept (true); extern _Float64 __j0f64 (_Float64) noexcept (true); +extern _Float64 j1f64 (_Float64) noexcept (true); extern _Float64 __j1f64 (_Float64) noexcept (true); +extern _Float64 jnf64 (int, _Float64) noexcept (true); extern _Float64 __jnf64 (int, _Float64) noexcept (true); +extern _Float64 y0f64 (_Float64) noexcept (true); extern _Float64 __y0f64 (_Float64) noexcept (true); +extern _Float64 y1f64 (_Float64) noexcept (true); extern _Float64 __y1f64 (_Float64) noexcept (true); +extern _Float64 ynf64 (int, _Float64) noexcept (true); extern _Float64 __ynf64 (int, _Float64) noexcept (true); + + + + + + extern _Float64 erff64 (_Float64) noexcept (true); extern _Float64 __erff64 (_Float64) noexcept (true); + extern _Float64 erfcf64 (_Float64) noexcept (true); extern _Float64 __erfcf64 (_Float64) noexcept (true); +extern _Float64 lgammaf64 (_Float64) noexcept (true); extern _Float64 __lgammaf64 (_Float64) noexcept (true); + + + + +extern _Float64 tgammaf64 (_Float64) noexcept (true); extern _Float64 __tgammaf64 (_Float64) noexcept (true); +# 252 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64 lgammaf64_r (_Float64, int *__signgamp) noexcept (true); extern _Float64 __lgammaf64_r (_Float64, int *__signgamp) noexcept (true); + + + + + + +extern _Float64 rintf64 (_Float64 __x) noexcept (true); extern _Float64 __rintf64 (_Float64 __x) noexcept (true); + + +extern _Float64 nextafterf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __nextafterf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + + + + +extern _Float64 nextdownf64 (_Float64 __x) noexcept (true); extern _Float64 __nextdownf64 (_Float64 __x) noexcept (true); + +extern _Float64 nextupf64 (_Float64 __x) noexcept (true); extern _Float64 __nextupf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 remainderf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __remainderf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + +extern _Float64 scalbnf64 (_Float64 __x, int __n) noexcept (true); extern _Float64 __scalbnf64 (_Float64 __x, int __n) noexcept (true); + + + +extern int ilogbf64 (_Float64 __x) noexcept (true); extern int __ilogbf64 (_Float64 __x) noexcept (true); + + + + +extern long int llogbf64 (_Float64 __x) noexcept (true); extern long int __llogbf64 (_Float64 __x) noexcept (true); + + + + +extern _Float64 scalblnf64 (_Float64 __x, long int __n) noexcept (true); extern _Float64 __scalblnf64 (_Float64 __x, long int __n) noexcept (true); + + + +extern _Float64 nearbyintf64 (_Float64 __x) noexcept (true); extern _Float64 __nearbyintf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 roundf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __roundf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64 truncf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __truncf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64 remquof64 (_Float64 __x, _Float64 __y, int *__quo) noexcept (true); extern _Float64 __remquof64 (_Float64 __x, _Float64 __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf64 (_Float64 __x) noexcept (true); extern long int __lrintf64 (_Float64 __x) noexcept (true); +__extension__ +extern long long int llrintf64 (_Float64 __x) noexcept (true); extern long long int __llrintf64 (_Float64 __x) noexcept (true); + + + +extern long int lroundf64 (_Float64 __x) noexcept (true); extern long int __lroundf64 (_Float64 __x) noexcept (true); +__extension__ +extern long long int llroundf64 (_Float64 __x) noexcept (true); extern long long int __llroundf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 fdimf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __fdimf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + +extern _Float64 fmaxf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaxf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64 fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); extern _Float64 __fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); + + + + +extern _Float64 roundevenf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __roundevenf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef64 (_Float64 *__cx, const _Float64 *__x) noexcept (true); + + + + + + +extern _Float64 fmaxmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaxmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64 fmaximumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaximumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminimumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmaximum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaximum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminimum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmaximum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaximum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminimum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmaximum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaximum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminimum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf64 (const _Float64 *__x, const _Float64 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf64 (const _Float64 *__x, const _Float64 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float64 getpayloadf64 (const _Float64 *__x) noexcept (true); extern _Float64 __getpayloadf64 (const _Float64 *__x) noexcept (true); + + +extern int setpayloadf64 (_Float64 *__x, _Float64 __payload) noexcept (true); + + +extern int setpayloadsigf64 (_Float64 *__x, _Float64 __payload) noexcept (true); +# 468 "/usr/include/math.h" 2 3 4 +# 481 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyf128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitf128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinff128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitef128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanf128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern int __issignalingf128 (_Float128 __value) noexcept (true) + __attribute__ ((__const__)); +# 482 "/usr/include/math.h" 2 3 4 + + +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 + extern _Float128 acosf128 (_Float128 __x) noexcept (true); extern _Float128 __acosf128 (_Float128 __x) noexcept (true); + + extern _Float128 asinf128 (_Float128 __x) noexcept (true); extern _Float128 __asinf128 (_Float128 __x) noexcept (true); + + extern _Float128 atanf128 (_Float128 __x) noexcept (true); extern _Float128 __atanf128 (_Float128 __x) noexcept (true); + + extern _Float128 atan2f128 (_Float128 __y, _Float128 __x) noexcept (true); extern _Float128 __atan2f128 (_Float128 __y, _Float128 __x) noexcept (true); + + + extern _Float128 cosf128 (_Float128 __x) noexcept (true); extern _Float128 __cosf128 (_Float128 __x) noexcept (true); + + extern _Float128 sinf128 (_Float128 __x) noexcept (true); extern _Float128 __sinf128 (_Float128 __x) noexcept (true); + + extern _Float128 tanf128 (_Float128 __x) noexcept (true); extern _Float128 __tanf128 (_Float128 __x) noexcept (true); + + + + + extern _Float128 coshf128 (_Float128 __x) noexcept (true); extern _Float128 __coshf128 (_Float128 __x) noexcept (true); + + extern _Float128 sinhf128 (_Float128 __x) noexcept (true); extern _Float128 __sinhf128 (_Float128 __x) noexcept (true); + + extern _Float128 tanhf128 (_Float128 __x) noexcept (true); extern _Float128 __tanhf128 (_Float128 __x) noexcept (true); + + + + extern void sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) noexcept (true); extern void __sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) noexcept (true) + ; + + + + + extern _Float128 acoshf128 (_Float128 __x) noexcept (true); extern _Float128 __acoshf128 (_Float128 __x) noexcept (true); + + extern _Float128 asinhf128 (_Float128 __x) noexcept (true); extern _Float128 __asinhf128 (_Float128 __x) noexcept (true); + + extern _Float128 atanhf128 (_Float128 __x) noexcept (true); extern _Float128 __atanhf128 (_Float128 __x) noexcept (true); + + + + + + extern _Float128 expf128 (_Float128 __x) noexcept (true); extern _Float128 __expf128 (_Float128 __x) noexcept (true); + + +extern _Float128 frexpf128 (_Float128 __x, int *__exponent) noexcept (true); extern _Float128 __frexpf128 (_Float128 __x, int *__exponent) noexcept (true); + + +extern _Float128 ldexpf128 (_Float128 __x, int __exponent) noexcept (true); extern _Float128 __ldexpf128 (_Float128 __x, int __exponent) noexcept (true); + + + extern _Float128 logf128 (_Float128 __x) noexcept (true); extern _Float128 __logf128 (_Float128 __x) noexcept (true); + + + extern _Float128 log10f128 (_Float128 __x) noexcept (true); extern _Float128 __log10f128 (_Float128 __x) noexcept (true); + + +extern _Float128 modff128 (_Float128 __x, _Float128 *__iptr) noexcept (true); extern _Float128 __modff128 (_Float128 __x, _Float128 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float128 exp10f128 (_Float128 __x) noexcept (true); extern _Float128 __exp10f128 (_Float128 __x) noexcept (true); + + + + + extern _Float128 expm1f128 (_Float128 __x) noexcept (true); extern _Float128 __expm1f128 (_Float128 __x) noexcept (true); + + + extern _Float128 log1pf128 (_Float128 __x) noexcept (true); extern _Float128 __log1pf128 (_Float128 __x) noexcept (true); + + +extern _Float128 logbf128 (_Float128 __x) noexcept (true); extern _Float128 __logbf128 (_Float128 __x) noexcept (true); + + + + + extern _Float128 exp2f128 (_Float128 __x) noexcept (true); extern _Float128 __exp2f128 (_Float128 __x) noexcept (true); + + + extern _Float128 log2f128 (_Float128 __x) noexcept (true); extern _Float128 __log2f128 (_Float128 __x) noexcept (true); + + + + + + + extern _Float128 powf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __powf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float128 sqrtf128 (_Float128 __x) noexcept (true); extern _Float128 __sqrtf128 (_Float128 __x) noexcept (true); + + + + extern _Float128 hypotf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __hypotf128 (_Float128 __x, _Float128 __y) noexcept (true); + + + + + extern _Float128 cbrtf128 (_Float128 __x) noexcept (true); extern _Float128 __cbrtf128 (_Float128 __x) noexcept (true); + + + + + + +extern _Float128 ceilf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); extern _Float128 __ceilf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fabsf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fabsf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 floorf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); extern _Float128 __floorf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmodf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __fmodf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float128 copysignf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); extern _Float128 __copysignf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float128 nanf128 (const char *__tagb) noexcept (true); extern _Float128 __nanf128 (const char *__tagb) noexcept (true); +# 220 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float128 j0f128 (_Float128) noexcept (true); extern _Float128 __j0f128 (_Float128) noexcept (true); +extern _Float128 j1f128 (_Float128) noexcept (true); extern _Float128 __j1f128 (_Float128) noexcept (true); +extern _Float128 jnf128 (int, _Float128) noexcept (true); extern _Float128 __jnf128 (int, _Float128) noexcept (true); +extern _Float128 y0f128 (_Float128) noexcept (true); extern _Float128 __y0f128 (_Float128) noexcept (true); +extern _Float128 y1f128 (_Float128) noexcept (true); extern _Float128 __y1f128 (_Float128) noexcept (true); +extern _Float128 ynf128 (int, _Float128) noexcept (true); extern _Float128 __ynf128 (int, _Float128) noexcept (true); + + + + + + extern _Float128 erff128 (_Float128) noexcept (true); extern _Float128 __erff128 (_Float128) noexcept (true); + extern _Float128 erfcf128 (_Float128) noexcept (true); extern _Float128 __erfcf128 (_Float128) noexcept (true); +extern _Float128 lgammaf128 (_Float128) noexcept (true); extern _Float128 __lgammaf128 (_Float128) noexcept (true); + + + + +extern _Float128 tgammaf128 (_Float128) noexcept (true); extern _Float128 __tgammaf128 (_Float128) noexcept (true); +# 252 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float128 lgammaf128_r (_Float128, int *__signgamp) noexcept (true); extern _Float128 __lgammaf128_r (_Float128, int *__signgamp) noexcept (true); + + + + + + +extern _Float128 rintf128 (_Float128 __x) noexcept (true); extern _Float128 __rintf128 (_Float128 __x) noexcept (true); + + +extern _Float128 nextafterf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __nextafterf128 (_Float128 __x, _Float128 __y) noexcept (true); + + + + + + +extern _Float128 nextdownf128 (_Float128 __x) noexcept (true); extern _Float128 __nextdownf128 (_Float128 __x) noexcept (true); + +extern _Float128 nextupf128 (_Float128 __x) noexcept (true); extern _Float128 __nextupf128 (_Float128 __x) noexcept (true); + + + +extern _Float128 remainderf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __remainderf128 (_Float128 __x, _Float128 __y) noexcept (true); + + + +extern _Float128 scalbnf128 (_Float128 __x, int __n) noexcept (true); extern _Float128 __scalbnf128 (_Float128 __x, int __n) noexcept (true); + + + +extern int ilogbf128 (_Float128 __x) noexcept (true); extern int __ilogbf128 (_Float128 __x) noexcept (true); + + + + +extern long int llogbf128 (_Float128 __x) noexcept (true); extern long int __llogbf128 (_Float128 __x) noexcept (true); + + + + +extern _Float128 scalblnf128 (_Float128 __x, long int __n) noexcept (true); extern _Float128 __scalblnf128 (_Float128 __x, long int __n) noexcept (true); + + + +extern _Float128 nearbyintf128 (_Float128 __x) noexcept (true); extern _Float128 __nearbyintf128 (_Float128 __x) noexcept (true); + + + +extern _Float128 roundf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); extern _Float128 __roundf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float128 truncf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); extern _Float128 __truncf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float128 remquof128 (_Float128 __x, _Float128 __y, int *__quo) noexcept (true); extern _Float128 __remquof128 (_Float128 __x, _Float128 __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf128 (_Float128 __x) noexcept (true); extern long int __lrintf128 (_Float128 __x) noexcept (true); +__extension__ +extern long long int llrintf128 (_Float128 __x) noexcept (true); extern long long int __llrintf128 (_Float128 __x) noexcept (true); + + + +extern long int lroundf128 (_Float128 __x) noexcept (true); extern long int __lroundf128 (_Float128 __x) noexcept (true); +__extension__ +extern long long int llroundf128 (_Float128 __x) noexcept (true); extern long long int __llroundf128 (_Float128 __x) noexcept (true); + + + +extern _Float128 fdimf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __fdimf128 (_Float128 __x, _Float128 __y) noexcept (true); + + + +extern _Float128 fmaxf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fmaxf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fminf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float128 fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); extern _Float128 __fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + + + +extern _Float128 roundevenf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); extern _Float128 __roundevenf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef128 (_Float128 *__cx, const _Float128 *__x) noexcept (true); + + + + + + +extern _Float128 fmaxmagf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fmaxmagf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminmagf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fminmagf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float128 fmaximumf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fmaximumf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimumf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fminimumf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmaximum_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fmaximum_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimum_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fminimum_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmaximum_magf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fmaximum_magf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimum_magf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fminimum_magf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fmaximum_mag_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fmaximum_mag_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float128 fminimum_mag_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fminimum_mag_numf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf128 (const _Float128 *__x, const _Float128 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf128 (const _Float128 *__x, const _Float128 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float128 getpayloadf128 (const _Float128 *__x) noexcept (true); extern _Float128 __getpayloadf128 (const _Float128 *__x) noexcept (true); + + +extern int setpayloadf128 (_Float128 *__x, _Float128 __payload) noexcept (true); + + +extern int setpayloadsigf128 (_Float128 *__x, _Float128 __payload) noexcept (true); +# 485 "/usr/include/math.h" 2 3 4 +# 501 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 + extern _Float32x acosf32x (_Float32x __x) noexcept (true); extern _Float32x __acosf32x (_Float32x __x) noexcept (true); + + extern _Float32x asinf32x (_Float32x __x) noexcept (true); extern _Float32x __asinf32x (_Float32x __x) noexcept (true); + + extern _Float32x atanf32x (_Float32x __x) noexcept (true); extern _Float32x __atanf32x (_Float32x __x) noexcept (true); + + extern _Float32x atan2f32x (_Float32x __y, _Float32x __x) noexcept (true); extern _Float32x __atan2f32x (_Float32x __y, _Float32x __x) noexcept (true); + + + extern _Float32x cosf32x (_Float32x __x) noexcept (true); extern _Float32x __cosf32x (_Float32x __x) noexcept (true); + + extern _Float32x sinf32x (_Float32x __x) noexcept (true); extern _Float32x __sinf32x (_Float32x __x) noexcept (true); + + extern _Float32x tanf32x (_Float32x __x) noexcept (true); extern _Float32x __tanf32x (_Float32x __x) noexcept (true); + + + + + extern _Float32x coshf32x (_Float32x __x) noexcept (true); extern _Float32x __coshf32x (_Float32x __x) noexcept (true); + + extern _Float32x sinhf32x (_Float32x __x) noexcept (true); extern _Float32x __sinhf32x (_Float32x __x) noexcept (true); + + extern _Float32x tanhf32x (_Float32x __x) noexcept (true); extern _Float32x __tanhf32x (_Float32x __x) noexcept (true); + + + + extern void sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) noexcept (true); extern void __sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) noexcept (true) + ; + + + + + extern _Float32x acoshf32x (_Float32x __x) noexcept (true); extern _Float32x __acoshf32x (_Float32x __x) noexcept (true); + + extern _Float32x asinhf32x (_Float32x __x) noexcept (true); extern _Float32x __asinhf32x (_Float32x __x) noexcept (true); + + extern _Float32x atanhf32x (_Float32x __x) noexcept (true); extern _Float32x __atanhf32x (_Float32x __x) noexcept (true); + + + + + + extern _Float32x expf32x (_Float32x __x) noexcept (true); extern _Float32x __expf32x (_Float32x __x) noexcept (true); + + +extern _Float32x frexpf32x (_Float32x __x, int *__exponent) noexcept (true); extern _Float32x __frexpf32x (_Float32x __x, int *__exponent) noexcept (true); + + +extern _Float32x ldexpf32x (_Float32x __x, int __exponent) noexcept (true); extern _Float32x __ldexpf32x (_Float32x __x, int __exponent) noexcept (true); + + + extern _Float32x logf32x (_Float32x __x) noexcept (true); extern _Float32x __logf32x (_Float32x __x) noexcept (true); + + + extern _Float32x log10f32x (_Float32x __x) noexcept (true); extern _Float32x __log10f32x (_Float32x __x) noexcept (true); + + +extern _Float32x modff32x (_Float32x __x, _Float32x *__iptr) noexcept (true); extern _Float32x __modff32x (_Float32x __x, _Float32x *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float32x exp10f32x (_Float32x __x) noexcept (true); extern _Float32x __exp10f32x (_Float32x __x) noexcept (true); + + + + + extern _Float32x expm1f32x (_Float32x __x) noexcept (true); extern _Float32x __expm1f32x (_Float32x __x) noexcept (true); + + + extern _Float32x log1pf32x (_Float32x __x) noexcept (true); extern _Float32x __log1pf32x (_Float32x __x) noexcept (true); + + +extern _Float32x logbf32x (_Float32x __x) noexcept (true); extern _Float32x __logbf32x (_Float32x __x) noexcept (true); + + + + + extern _Float32x exp2f32x (_Float32x __x) noexcept (true); extern _Float32x __exp2f32x (_Float32x __x) noexcept (true); + + + extern _Float32x log2f32x (_Float32x __x) noexcept (true); extern _Float32x __log2f32x (_Float32x __x) noexcept (true); + + + + + + + extern _Float32x powf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __powf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32x sqrtf32x (_Float32x __x) noexcept (true); extern _Float32x __sqrtf32x (_Float32x __x) noexcept (true); + + + + extern _Float32x hypotf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __hypotf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + + + extern _Float32x cbrtf32x (_Float32x __x) noexcept (true); extern _Float32x __cbrtf32x (_Float32x __x) noexcept (true); + + + + + + +extern _Float32x ceilf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __ceilf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fabsf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fabsf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x floorf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __floorf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); +# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32x copysignf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __copysignf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x nanf32x (const char *__tagb) noexcept (true); extern _Float32x __nanf32x (const char *__tagb) noexcept (true); +# 220 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32x j0f32x (_Float32x) noexcept (true); extern _Float32x __j0f32x (_Float32x) noexcept (true); +extern _Float32x j1f32x (_Float32x) noexcept (true); extern _Float32x __j1f32x (_Float32x) noexcept (true); +extern _Float32x jnf32x (int, _Float32x) noexcept (true); extern _Float32x __jnf32x (int, _Float32x) noexcept (true); +extern _Float32x y0f32x (_Float32x) noexcept (true); extern _Float32x __y0f32x (_Float32x) noexcept (true); +extern _Float32x y1f32x (_Float32x) noexcept (true); extern _Float32x __y1f32x (_Float32x) noexcept (true); +extern _Float32x ynf32x (int, _Float32x) noexcept (true); extern _Float32x __ynf32x (int, _Float32x) noexcept (true); + + + + + + extern _Float32x erff32x (_Float32x) noexcept (true); extern _Float32x __erff32x (_Float32x) noexcept (true); + extern _Float32x erfcf32x (_Float32x) noexcept (true); extern _Float32x __erfcf32x (_Float32x) noexcept (true); +extern _Float32x lgammaf32x (_Float32x) noexcept (true); extern _Float32x __lgammaf32x (_Float32x) noexcept (true); + + + + +extern _Float32x tgammaf32x (_Float32x) noexcept (true); extern _Float32x __tgammaf32x (_Float32x) noexcept (true); +# 252 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float32x lgammaf32x_r (_Float32x, int *__signgamp) noexcept (true); extern _Float32x __lgammaf32x_r (_Float32x, int *__signgamp) noexcept (true); + + + + + + +extern _Float32x rintf32x (_Float32x __x) noexcept (true); extern _Float32x __rintf32x (_Float32x __x) noexcept (true); + + +extern _Float32x nextafterf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __nextafterf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + + + + +extern _Float32x nextdownf32x (_Float32x __x) noexcept (true); extern _Float32x __nextdownf32x (_Float32x __x) noexcept (true); + +extern _Float32x nextupf32x (_Float32x __x) noexcept (true); extern _Float32x __nextupf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x remainderf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __remainderf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + +extern _Float32x scalbnf32x (_Float32x __x, int __n) noexcept (true); extern _Float32x __scalbnf32x (_Float32x __x, int __n) noexcept (true); + + + +extern int ilogbf32x (_Float32x __x) noexcept (true); extern int __ilogbf32x (_Float32x __x) noexcept (true); + + + + +extern long int llogbf32x (_Float32x __x) noexcept (true); extern long int __llogbf32x (_Float32x __x) noexcept (true); + + + + +extern _Float32x scalblnf32x (_Float32x __x, long int __n) noexcept (true); extern _Float32x __scalblnf32x (_Float32x __x, long int __n) noexcept (true); + + + +extern _Float32x nearbyintf32x (_Float32x __x) noexcept (true); extern _Float32x __nearbyintf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x roundf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __roundf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32x truncf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __truncf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x remquof32x (_Float32x __x, _Float32x __y, int *__quo) noexcept (true); extern _Float32x __remquof32x (_Float32x __x, _Float32x __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf32x (_Float32x __x) noexcept (true); extern long int __lrintf32x (_Float32x __x) noexcept (true); +__extension__ +extern long long int llrintf32x (_Float32x __x) noexcept (true); extern long long int __llrintf32x (_Float32x __x) noexcept (true); + + + +extern long int lroundf32x (_Float32x __x) noexcept (true); extern long int __lroundf32x (_Float32x __x) noexcept (true); +__extension__ +extern long long int llroundf32x (_Float32x __x) noexcept (true); extern long long int __llroundf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x fdimf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __fdimf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + +extern _Float32x fmaxf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaxf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32x fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); extern _Float32x __fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); + + + + +extern _Float32x roundevenf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __roundevenf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef32x (_Float32x *__cx, const _Float32x *__x) noexcept (true); + + + + + + +extern _Float32x fmaxmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaxmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x fmaximumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaximumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminimumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaximum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminimum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaximum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminimum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaximum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminimum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf32x (const _Float32x *__x, const _Float32x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf32x (const _Float32x *__x, const _Float32x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float32x getpayloadf32x (const _Float32x *__x) noexcept (true); extern _Float32x __getpayloadf32x (const _Float32x *__x) noexcept (true); + + +extern int setpayloadf32x (_Float32x *__x, _Float32x __payload) noexcept (true); + + +extern int setpayloadsigf32x (_Float32x *__x, _Float32x __payload) noexcept (true); +# 502 "/usr/include/math.h" 2 3 4 +# 518 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 + extern _Float64x acosf64x (_Float64x __x) noexcept (true); extern _Float64x __acosf64x (_Float64x __x) noexcept (true); + + extern _Float64x asinf64x (_Float64x __x) noexcept (true); extern _Float64x __asinf64x (_Float64x __x) noexcept (true); + + extern _Float64x atanf64x (_Float64x __x) noexcept (true); extern _Float64x __atanf64x (_Float64x __x) noexcept (true); + + extern _Float64x atan2f64x (_Float64x __y, _Float64x __x) noexcept (true); extern _Float64x __atan2f64x (_Float64x __y, _Float64x __x) noexcept (true); + + + extern _Float64x cosf64x (_Float64x __x) noexcept (true); extern _Float64x __cosf64x (_Float64x __x) noexcept (true); + + extern _Float64x sinf64x (_Float64x __x) noexcept (true); extern _Float64x __sinf64x (_Float64x __x) noexcept (true); + + extern _Float64x tanf64x (_Float64x __x) noexcept (true); extern _Float64x __tanf64x (_Float64x __x) noexcept (true); + + + + + extern _Float64x coshf64x (_Float64x __x) noexcept (true); extern _Float64x __coshf64x (_Float64x __x) noexcept (true); + + extern _Float64x sinhf64x (_Float64x __x) noexcept (true); extern _Float64x __sinhf64x (_Float64x __x) noexcept (true); + + extern _Float64x tanhf64x (_Float64x __x) noexcept (true); extern _Float64x __tanhf64x (_Float64x __x) noexcept (true); + + + + extern void sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) noexcept (true); extern void __sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) noexcept (true) + ; + + + + + extern _Float64x acoshf64x (_Float64x __x) noexcept (true); extern _Float64x __acoshf64x (_Float64x __x) noexcept (true); + + extern _Float64x asinhf64x (_Float64x __x) noexcept (true); extern _Float64x __asinhf64x (_Float64x __x) noexcept (true); + + extern _Float64x atanhf64x (_Float64x __x) noexcept (true); extern _Float64x __atanhf64x (_Float64x __x) noexcept (true); + + + + + + extern _Float64x expf64x (_Float64x __x) noexcept (true); extern _Float64x __expf64x (_Float64x __x) noexcept (true); + + +extern _Float64x frexpf64x (_Float64x __x, int *__exponent) noexcept (true); extern _Float64x __frexpf64x (_Float64x __x, int *__exponent) noexcept (true); + + +extern _Float64x ldexpf64x (_Float64x __x, int __exponent) noexcept (true); extern _Float64x __ldexpf64x (_Float64x __x, int __exponent) noexcept (true); + + + extern _Float64x logf64x (_Float64x __x) noexcept (true); extern _Float64x __logf64x (_Float64x __x) noexcept (true); + + + extern _Float64x log10f64x (_Float64x __x) noexcept (true); extern _Float64x __log10f64x (_Float64x __x) noexcept (true); + + +extern _Float64x modff64x (_Float64x __x, _Float64x *__iptr) noexcept (true); extern _Float64x __modff64x (_Float64x __x, _Float64x *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float64x exp10f64x (_Float64x __x) noexcept (true); extern _Float64x __exp10f64x (_Float64x __x) noexcept (true); + + + + + extern _Float64x expm1f64x (_Float64x __x) noexcept (true); extern _Float64x __expm1f64x (_Float64x __x) noexcept (true); + + + extern _Float64x log1pf64x (_Float64x __x) noexcept (true); extern _Float64x __log1pf64x (_Float64x __x) noexcept (true); + + +extern _Float64x logbf64x (_Float64x __x) noexcept (true); extern _Float64x __logbf64x (_Float64x __x) noexcept (true); + + + + + extern _Float64x exp2f64x (_Float64x __x) noexcept (true); extern _Float64x __exp2f64x (_Float64x __x) noexcept (true); + + + extern _Float64x log2f64x (_Float64x __x) noexcept (true); extern _Float64x __log2f64x (_Float64x __x) noexcept (true); + + + + + + + extern _Float64x powf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __powf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64x sqrtf64x (_Float64x __x) noexcept (true); extern _Float64x __sqrtf64x (_Float64x __x) noexcept (true); + + + + extern _Float64x hypotf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __hypotf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + + + extern _Float64x cbrtf64x (_Float64x __x) noexcept (true); extern _Float64x __cbrtf64x (_Float64x __x) noexcept (true); + + + + + + +extern _Float64x ceilf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __ceilf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fabsf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fabsf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x floorf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __floorf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 198 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64x copysignf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __copysignf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x nanf64x (const char *__tagb) noexcept (true); extern _Float64x __nanf64x (const char *__tagb) noexcept (true); +# 220 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64x j0f64x (_Float64x) noexcept (true); extern _Float64x __j0f64x (_Float64x) noexcept (true); +extern _Float64x j1f64x (_Float64x) noexcept (true); extern _Float64x __j1f64x (_Float64x) noexcept (true); +extern _Float64x jnf64x (int, _Float64x) noexcept (true); extern _Float64x __jnf64x (int, _Float64x) noexcept (true); +extern _Float64x y0f64x (_Float64x) noexcept (true); extern _Float64x __y0f64x (_Float64x) noexcept (true); +extern _Float64x y1f64x (_Float64x) noexcept (true); extern _Float64x __y1f64x (_Float64x) noexcept (true); +extern _Float64x ynf64x (int, _Float64x) noexcept (true); extern _Float64x __ynf64x (int, _Float64x) noexcept (true); + + + + + + extern _Float64x erff64x (_Float64x) noexcept (true); extern _Float64x __erff64x (_Float64x) noexcept (true); + extern _Float64x erfcf64x (_Float64x) noexcept (true); extern _Float64x __erfcf64x (_Float64x) noexcept (true); +extern _Float64x lgammaf64x (_Float64x) noexcept (true); extern _Float64x __lgammaf64x (_Float64x) noexcept (true); + + + + +extern _Float64x tgammaf64x (_Float64x) noexcept (true); extern _Float64x __tgammaf64x (_Float64x) noexcept (true); +# 252 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 +extern _Float64x lgammaf64x_r (_Float64x, int *__signgamp) noexcept (true); extern _Float64x __lgammaf64x_r (_Float64x, int *__signgamp) noexcept (true); + + + + + + +extern _Float64x rintf64x (_Float64x __x) noexcept (true); extern _Float64x __rintf64x (_Float64x __x) noexcept (true); + + +extern _Float64x nextafterf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __nextafterf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + + + + +extern _Float64x nextdownf64x (_Float64x __x) noexcept (true); extern _Float64x __nextdownf64x (_Float64x __x) noexcept (true); + +extern _Float64x nextupf64x (_Float64x __x) noexcept (true); extern _Float64x __nextupf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x remainderf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __remainderf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + +extern _Float64x scalbnf64x (_Float64x __x, int __n) noexcept (true); extern _Float64x __scalbnf64x (_Float64x __x, int __n) noexcept (true); + + + +extern int ilogbf64x (_Float64x __x) noexcept (true); extern int __ilogbf64x (_Float64x __x) noexcept (true); + + + + +extern long int llogbf64x (_Float64x __x) noexcept (true); extern long int __llogbf64x (_Float64x __x) noexcept (true); + + + + +extern _Float64x scalblnf64x (_Float64x __x, long int __n) noexcept (true); extern _Float64x __scalblnf64x (_Float64x __x, long int __n) noexcept (true); + + + +extern _Float64x nearbyintf64x (_Float64x __x) noexcept (true); extern _Float64x __nearbyintf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x roundf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __roundf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64x truncf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __truncf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x remquof64x (_Float64x __x, _Float64x __y, int *__quo) noexcept (true); extern _Float64x __remquof64x (_Float64x __x, _Float64x __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf64x (_Float64x __x) noexcept (true); extern long int __lrintf64x (_Float64x __x) noexcept (true); +__extension__ +extern long long int llrintf64x (_Float64x __x) noexcept (true); extern long long int __llrintf64x (_Float64x __x) noexcept (true); + + + +extern long int lroundf64x (_Float64x __x) noexcept (true); extern long int __lroundf64x (_Float64x __x) noexcept (true); +__extension__ +extern long long int llroundf64x (_Float64x __x) noexcept (true); extern long long int __llroundf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x fdimf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __fdimf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + +extern _Float64x fmaxf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaxf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64x fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); extern _Float64x __fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + + + +extern _Float64x roundevenf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __roundevenf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true) + ; + + + +extern __uintmax_t ufromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __intmax_t fromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true) + ; + + + + +extern __uintmax_t ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true) + ; + + +extern int canonicalizef64x (_Float64x *__cx, const _Float64x *__x) noexcept (true); + + + + + + +extern _Float64x fmaxmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaxmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x fmaximumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaximumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminimumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaximum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminimum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaximum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminimum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaximum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminimum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf64x (const _Float64x *__x, const _Float64x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf64x (const _Float64x *__x, const _Float64x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float64x getpayloadf64x (const _Float64x *__x) noexcept (true); extern _Float64x __getpayloadf64x (const _Float64x *__x) noexcept (true); + + +extern int setpayloadf64x (_Float64x *__x, _Float64x __payload) noexcept (true); + + +extern int setpayloadsigf64x (_Float64x *__x, _Float64x __payload) noexcept (true); +# 519 "/usr/include/math.h" 2 3 4 +# 566 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern float fadd (double __x, double __y) noexcept (true); + + +extern float fdiv (double __x, double __y) noexcept (true); + + +extern float ffma (double __x, double __y, double __z) noexcept (true); + + +extern float fmul (double __x, double __y) noexcept (true); + + +extern float fsqrt (double __x) noexcept (true); + + +extern float fsub (double __x, double __y) noexcept (true); +# 567 "/usr/include/math.h" 2 3 4 +# 587 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern float faddl (long double __x, long double __y) noexcept (true); + + +extern float fdivl (long double __x, long double __y) noexcept (true); + + +extern float ffmal (long double __x, long double __y, long double __z) noexcept (true); + + +extern float fmull (long double __x, long double __y) noexcept (true); + + +extern float fsqrtl (long double __x) noexcept (true); + + +extern float fsubl (long double __x, long double __y) noexcept (true); +# 588 "/usr/include/math.h" 2 3 4 +# 616 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern double daddl (long double __x, long double __y) noexcept (true); + + +extern double ddivl (long double __x, long double __y) noexcept (true); + + +extern double dfmal (long double __x, long double __y, long double __z) noexcept (true); + + +extern double dmull (long double __x, long double __y) noexcept (true); + + +extern double dsqrtl (long double __x) noexcept (true); + + +extern double dsubl (long double __x, long double __y) noexcept (true); +# 617 "/usr/include/math.h" 2 3 4 +# 697 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32divf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); + + +extern _Float32 f32mulf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32sqrtf32x (_Float32x __x) noexcept (true); + + +extern _Float32 f32subf32x (_Float32x __x, _Float32x __y) noexcept (true); +# 698 "/usr/include/math.h" 2 3 4 +# 707 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32divf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); + + +extern _Float32 f32mulf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32sqrtf64 (_Float64 __x) noexcept (true); + + +extern _Float32 f32subf64 (_Float64 __x, _Float64 __y) noexcept (true); +# 708 "/usr/include/math.h" 2 3 4 +# 717 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32divf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + +extern _Float32 f32mulf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32sqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float32 f32subf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 718 "/usr/include/math.h" 2 3 4 +# 727 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32 f32divf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32 f32fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float32 f32mulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32 f32sqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float32 f32subf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 728 "/usr/include/math.h" 2 3 4 +# 747 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xdivf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xfmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); + + +extern _Float32x f32xmulf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xsqrtf64 (_Float64 __x) noexcept (true); + + +extern _Float32x f32xsubf64 (_Float64 __x, _Float64 __y) noexcept (true); +# 748 "/usr/include/math.h" 2 3 4 +# 757 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xdivf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xfmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + +extern _Float32x f32xmulf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xsqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float32x f32xsubf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 758 "/usr/include/math.h" 2 3 4 +# 767 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32x f32xdivf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32x f32xfmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float32x f32xmulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float32x f32xsqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float32x f32xsubf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 768 "/usr/include/math.h" 2 3 4 +# 787 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float64 f64addf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64divf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + +extern _Float64 f64mulf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64sqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float64 f64subf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 788 "/usr/include/math.h" 2 3 4 +# 797 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float64 f64addf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64 f64divf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64 f64fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float64 f64mulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64 f64sqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float64 f64subf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 798 "/usr/include/math.h" 2 3 4 +# 817 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 +extern _Float64x f64xaddf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64x f64xdivf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64x f64xfmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); + + +extern _Float64x f64xmulf128 (_Float128 __x, _Float128 __y) noexcept (true); + + +extern _Float64x f64xsqrtf128 (_Float128 __x) noexcept (true); + + +extern _Float64x f64xsubf128 (_Float128 __x, _Float128 __y) noexcept (true); +# 818 "/usr/include/math.h" 2 3 4 +# 854 "/usr/include/math.h" 3 4 +extern int signgam; +# 934 "/usr/include/math.h" 3 4 +enum + { + FP_NAN = + + 0, + FP_INFINITE = + + 1, + FP_ZERO = + + 2, + FP_SUBNORMAL = + + 3, + FP_NORMAL = + + 4 + }; +# 1054 "/usr/include/math.h" 3 4 +# 1 "/usr/include/x86_64-linux-gnu/bits/iscanonical.h" 1 3 4 +# 23 "/usr/include/x86_64-linux-gnu/bits/iscanonical.h" 3 4 +extern int __iscanonicall (long double __x) + noexcept (true) __attribute__ ((__const__)); +# 46 "/usr/include/x86_64-linux-gnu/bits/iscanonical.h" 3 4 +extern "C++" { +inline int iscanonical (float __val) { return ((void) (__typeof (__val)) (__val), 1); } +inline int iscanonical (double __val) { return ((void) (__typeof (__val)) (__val), 1); } +inline int iscanonical (long double __val) { return __iscanonicall (__val); } + +inline int iscanonical (_Float128 __val) { return ((void) (__typeof (__val)) (__val), 1); } + +} +# 1055 "/usr/include/math.h" 2 3 4 +# 1066 "/usr/include/math.h" 3 4 +extern "C++" { +inline int issignaling (float __val) { return __issignalingf (__val); } +inline int issignaling (double __val) { return __issignaling (__val); } +inline int +issignaling (long double __val) +{ + + + + return __issignalingl (__val); + +} + + + +inline int issignaling (_Float128 __val) { return __issignalingf128 (__val); } + +} +# 1097 "/usr/include/math.h" 3 4 +extern "C++" { +# 1128 "/usr/include/math.h" 3 4 +template inline bool +iszero (__T __val) +{ + return __val == 0; +} + +} +# 1363 "/usr/include/math.h" 3 4 +extern "C++" { +template struct __iseqsig_type; + +template<> struct __iseqsig_type +{ + static int __call (float __x, float __y) throw () + { + return __iseqsigf (__x, __y); + } +}; + +template<> struct __iseqsig_type +{ + static int __call (double __x, double __y) throw () + { + return __iseqsig (__x, __y); + } +}; + +template<> struct __iseqsig_type +{ + static int __call (long double __x, long double __y) throw () + { + + return __iseqsigl (__x, __y); + + + + } +}; + + + + +template<> struct __iseqsig_type<_Float128> +{ + static int __call (_Float128 __x, _Float128 __y) throw () + { + return __iseqsigf128 (__x, __y); + } +}; + + +template +inline int +iseqsig (_T1 __x, _T2 __y) throw () +{ + + typedef decltype (((__x) + (__y) + 0.0f)) _T3; + + + + return __iseqsig_type<_T3>::__call (__x, __y); +} + +} + + + + +} +# 46 "/usr/include/c++/11/cmath" 2 3 +# 77 "/usr/include/c++/11/cmath" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::acos; + + + inline constexpr float + acos(float __x) + { return __builtin_acosf(__x); } + + inline constexpr long double + acos(long double __x) + { return __builtin_acosl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + acos(_Tp __x) + { return __builtin_acos(__x); } + + using ::asin; + + + inline constexpr float + asin(float __x) + { return __builtin_asinf(__x); } + + inline constexpr long double + asin(long double __x) + { return __builtin_asinl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + asin(_Tp __x) + { return __builtin_asin(__x); } + + using ::atan; + + + inline constexpr float + atan(float __x) + { return __builtin_atanf(__x); } + + inline constexpr long double + atan(long double __x) + { return __builtin_atanl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + atan(_Tp __x) + { return __builtin_atan(__x); } + + using ::atan2; + + + inline constexpr float + atan2(float __y, float __x) + { return __builtin_atan2f(__y, __x); } + + inline constexpr long double + atan2(long double __y, long double __x) + { return __builtin_atan2l(__y, __x); } + + + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + atan2(_Tp __y, _Up __x) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return atan2(__type(__y), __type(__x)); + } + + using ::ceil; + + + inline constexpr float + ceil(float __x) + { return __builtin_ceilf(__x); } + + inline constexpr long double + ceil(long double __x) + { return __builtin_ceill(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + ceil(_Tp __x) + { return __builtin_ceil(__x); } + + using ::cos; + + + inline constexpr float + cos(float __x) + { return __builtin_cosf(__x); } + + inline constexpr long double + cos(long double __x) + { return __builtin_cosl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cos(_Tp __x) + { return __builtin_cos(__x); } + + using ::cosh; + + + inline constexpr float + cosh(float __x) + { return __builtin_coshf(__x); } + + inline constexpr long double + cosh(long double __x) + { return __builtin_coshl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cosh(_Tp __x) + { return __builtin_cosh(__x); } + + using ::exp; + + + inline constexpr float + exp(float __x) + { return __builtin_expf(__x); } + + inline constexpr long double + exp(long double __x) + { return __builtin_expl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + exp(_Tp __x) + { return __builtin_exp(__x); } + + using ::fabs; + + + inline constexpr float + fabs(float __x) + { return __builtin_fabsf(__x); } + + inline constexpr long double + fabs(long double __x) + { return __builtin_fabsl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + fabs(_Tp __x) + { return __builtin_fabs(__x); } + + using ::floor; + + + inline constexpr float + floor(float __x) + { return __builtin_floorf(__x); } + + inline constexpr long double + floor(long double __x) + { return __builtin_floorl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + floor(_Tp __x) + { return __builtin_floor(__x); } + + using ::fmod; + + + inline constexpr float + fmod(float __x, float __y) + { return __builtin_fmodf(__x, __y); } + + inline constexpr long double + fmod(long double __x, long double __y) + { return __builtin_fmodl(__x, __y); } + + + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmod(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmod(__type(__x), __type(__y)); + } + + using ::frexp; + + + inline float + frexp(float __x, int* __exp) + { return __builtin_frexpf(__x, __exp); } + + inline long double + frexp(long double __x, int* __exp) + { return __builtin_frexpl(__x, __exp); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + frexp(_Tp __x, int* __exp) + { return __builtin_frexp(__x, __exp); } + + using ::ldexp; + + + inline constexpr float + ldexp(float __x, int __exp) + { return __builtin_ldexpf(__x, __exp); } + + inline constexpr long double + ldexp(long double __x, int __exp) + { return __builtin_ldexpl(__x, __exp); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + ldexp(_Tp __x, int __exp) + { return __builtin_ldexp(__x, __exp); } + + using ::log; + + + inline constexpr float + log(float __x) + { return __builtin_logf(__x); } + + inline constexpr long double + log(long double __x) + { return __builtin_logl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log(_Tp __x) + { return __builtin_log(__x); } + + using ::log10; + + + inline constexpr float + log10(float __x) + { return __builtin_log10f(__x); } + + inline constexpr long double + log10(long double __x) + { return __builtin_log10l(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log10(_Tp __x) + { return __builtin_log10(__x); } + + using ::modf; + + + inline float + modf(float __x, float* __iptr) + { return __builtin_modff(__x, __iptr); } + + inline long double + modf(long double __x, long double* __iptr) + { return __builtin_modfl(__x, __iptr); } + + + using ::pow; + + + inline constexpr float + pow(float __x, float __y) + { return __builtin_powf(__x, __y); } + + inline constexpr long double + pow(long double __x, long double __y) + { return __builtin_powl(__x, __y); } +# 412 "/usr/include/c++/11/cmath" 3 + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + pow(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return pow(__type(__x), __type(__y)); + } + + using ::sin; + + + inline constexpr float + sin(float __x) + { return __builtin_sinf(__x); } + + inline constexpr long double + sin(long double __x) + { return __builtin_sinl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sin(_Tp __x) + { return __builtin_sin(__x); } + + using ::sinh; + + + inline constexpr float + sinh(float __x) + { return __builtin_sinhf(__x); } + + inline constexpr long double + sinh(long double __x) + { return __builtin_sinhl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sinh(_Tp __x) + { return __builtin_sinh(__x); } + + using ::sqrt; + + + inline constexpr float + sqrt(float __x) + { return __builtin_sqrtf(__x); } + + inline constexpr long double + sqrt(long double __x) + { return __builtin_sqrtl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sqrt(_Tp __x) + { return __builtin_sqrt(__x); } + + using ::tan; + + + inline constexpr float + tan(float __x) + { return __builtin_tanf(__x); } + + inline constexpr long double + tan(long double __x) + { return __builtin_tanl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tan(_Tp __x) + { return __builtin_tan(__x); } + + using ::tanh; + + + inline constexpr float + tanh(float __x) + { return __builtin_tanhf(__x); } + + inline constexpr long double + tanh(long double __x) + { return __builtin_tanhl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tanh(_Tp __x) + { return __builtin_tanh(__x); } +# 536 "/usr/include/c++/11/cmath" 3 + constexpr int + fpclassify(float __x) + { return __builtin_fpclassify(0, 1, 4, + 3, 2, __x); } + + constexpr int + fpclassify(double __x) + { return __builtin_fpclassify(0, 1, 4, + 3, 2, __x); } + + constexpr int + fpclassify(long double __x) + { return __builtin_fpclassify(0, 1, 4, + 3, 2, __x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + int>::__type + fpclassify(_Tp __x) + { return __x != 0 ? 4 : 2; } + + + + constexpr bool + isfinite(float __x) + { return __builtin_isfinite(__x); } + + constexpr bool + isfinite(double __x) + { return __builtin_isfinite(__x); } + + constexpr bool + isfinite(long double __x) + { return __builtin_isfinite(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isfinite(_Tp __x) + { return true; } + + + + constexpr bool + isinf(float __x) + { return __builtin_isinf(__x); } + + + + + + constexpr bool + isinf(double __x) + { return __builtin_isinf(__x); } + + + constexpr bool + isinf(long double __x) + { return __builtin_isinf(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isinf(_Tp __x) + { return false; } + + + + constexpr bool + isnan(float __x) + { return __builtin_isnan(__x); } + + + + + + constexpr bool + isnan(double __x) + { return __builtin_isnan(__x); } + + + constexpr bool + isnan(long double __x) + { return __builtin_isnan(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isnan(_Tp __x) + { return false; } + + + + constexpr bool + isnormal(float __x) + { return __builtin_isnormal(__x); } + + constexpr bool + isnormal(double __x) + { return __builtin_isnormal(__x); } + + constexpr bool + isnormal(long double __x) + { return __builtin_isnormal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isnormal(_Tp __x) + { return __x != 0 ? true : false; } + + + + + constexpr bool + signbit(float __x) + { return __builtin_signbit(__x); } + + constexpr bool + signbit(double __x) + { return __builtin_signbit(__x); } + + constexpr bool + signbit(long double __x) + { return __builtin_signbit(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + signbit(_Tp __x) + { return __x < 0 ? true : false; } + + + + constexpr bool + isgreater(float __x, float __y) + { return __builtin_isgreater(__x, __y); } + + constexpr bool + isgreater(double __x, double __y) + { return __builtin_isgreater(__x, __y); } + + constexpr bool + isgreater(long double __x, long double __y) + { return __builtin_isgreater(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isgreater(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isgreater(__type(__x), __type(__y)); + } + + + + constexpr bool + isgreaterequal(float __x, float __y) + { return __builtin_isgreaterequal(__x, __y); } + + constexpr bool + isgreaterequal(double __x, double __y) + { return __builtin_isgreaterequal(__x, __y); } + + constexpr bool + isgreaterequal(long double __x, long double __y) + { return __builtin_isgreaterequal(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isgreaterequal(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isgreaterequal(__type(__x), __type(__y)); + } + + + + constexpr bool + isless(float __x, float __y) + { return __builtin_isless(__x, __y); } + + constexpr bool + isless(double __x, double __y) + { return __builtin_isless(__x, __y); } + + constexpr bool + isless(long double __x, long double __y) + { return __builtin_isless(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isless(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isless(__type(__x), __type(__y)); + } + + + + constexpr bool + islessequal(float __x, float __y) + { return __builtin_islessequal(__x, __y); } + + constexpr bool + islessequal(double __x, double __y) + { return __builtin_islessequal(__x, __y); } + + constexpr bool + islessequal(long double __x, long double __y) + { return __builtin_islessequal(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + islessequal(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_islessequal(__type(__x), __type(__y)); + } + + + + constexpr bool + islessgreater(float __x, float __y) + { return __builtin_islessgreater(__x, __y); } + + constexpr bool + islessgreater(double __x, double __y) + { return __builtin_islessgreater(__x, __y); } + + constexpr bool + islessgreater(long double __x, long double __y) + { return __builtin_islessgreater(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + islessgreater(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_islessgreater(__type(__x), __type(__y)); + } + + + + constexpr bool + isunordered(float __x, float __y) + { return __builtin_isunordered(__x, __y); } + + constexpr bool + isunordered(double __x, double __y) + { return __builtin_isunordered(__x, __y); } + + constexpr bool + isunordered(long double __x, long double __y) + { return __builtin_isunordered(__x, __y); } + + + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isunordered(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isunordered(__type(__x), __type(__y)); + } +# 1065 "/usr/include/c++/11/cmath" 3 + using ::double_t; + using ::float_t; + + + using ::acosh; + using ::acoshf; + using ::acoshl; + + using ::asinh; + using ::asinhf; + using ::asinhl; + + using ::atanh; + using ::atanhf; + using ::atanhl; + + using ::cbrt; + using ::cbrtf; + using ::cbrtl; + + using ::copysign; + using ::copysignf; + using ::copysignl; + + using ::erf; + using ::erff; + using ::erfl; + + using ::erfc; + using ::erfcf; + using ::erfcl; + + using ::exp2; + using ::exp2f; + using ::exp2l; + + using ::expm1; + using ::expm1f; + using ::expm1l; + + using ::fdim; + using ::fdimf; + using ::fdiml; + + using ::fma; + using ::fmaf; + using ::fmal; + + using ::fmax; + using ::fmaxf; + using ::fmaxl; + + using ::fmin; + using ::fminf; + using ::fminl; + + using ::hypot; + using ::hypotf; + using ::hypotl; + + using ::ilogb; + using ::ilogbf; + using ::ilogbl; + + using ::lgamma; + using ::lgammaf; + using ::lgammal; + + + using ::llrint; + using ::llrintf; + using ::llrintl; + + using ::llround; + using ::llroundf; + using ::llroundl; + + + using ::log1p; + using ::log1pf; + using ::log1pl; + + using ::log2; + using ::log2f; + using ::log2l; + + using ::logb; + using ::logbf; + using ::logbl; + + using ::lrint; + using ::lrintf; + using ::lrintl; + + using ::lround; + using ::lroundf; + using ::lroundl; + + using ::nan; + using ::nanf; + using ::nanl; + + using ::nearbyint; + using ::nearbyintf; + using ::nearbyintl; + + using ::nextafter; + using ::nextafterf; + using ::nextafterl; + + using ::nexttoward; + using ::nexttowardf; + using ::nexttowardl; + + using ::remainder; + using ::remainderf; + using ::remainderl; + + using ::remquo; + using ::remquof; + using ::remquol; + + using ::rint; + using ::rintf; + using ::rintl; + + using ::round; + using ::roundf; + using ::roundl; + + using ::scalbln; + using ::scalblnf; + using ::scalblnl; + + using ::scalbn; + using ::scalbnf; + using ::scalbnl; + + using ::tgamma; + using ::tgammaf; + using ::tgammal; + + using ::trunc; + using ::truncf; + using ::truncl; + + + + constexpr float + acosh(float __x) + { return __builtin_acoshf(__x); } + + constexpr long double + acosh(long double __x) + { return __builtin_acoshl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + acosh(_Tp __x) + { return __builtin_acosh(__x); } + + + + constexpr float + asinh(float __x) + { return __builtin_asinhf(__x); } + + constexpr long double + asinh(long double __x) + { return __builtin_asinhl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + asinh(_Tp __x) + { return __builtin_asinh(__x); } + + + + constexpr float + atanh(float __x) + { return __builtin_atanhf(__x); } + + constexpr long double + atanh(long double __x) + { return __builtin_atanhl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + atanh(_Tp __x) + { return __builtin_atanh(__x); } + + + + constexpr float + cbrt(float __x) + { return __builtin_cbrtf(__x); } + + constexpr long double + cbrt(long double __x) + { return __builtin_cbrtl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cbrt(_Tp __x) + { return __builtin_cbrt(__x); } + + + + constexpr float + copysign(float __x, float __y) + { return __builtin_copysignf(__x, __y); } + + constexpr long double + copysign(long double __x, long double __y) + { return __builtin_copysignl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + copysign(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return copysign(__type(__x), __type(__y)); + } + + + + constexpr float + erf(float __x) + { return __builtin_erff(__x); } + + constexpr long double + erf(long double __x) + { return __builtin_erfl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + erf(_Tp __x) + { return __builtin_erf(__x); } + + + + constexpr float + erfc(float __x) + { return __builtin_erfcf(__x); } + + constexpr long double + erfc(long double __x) + { return __builtin_erfcl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + erfc(_Tp __x) + { return __builtin_erfc(__x); } + + + + constexpr float + exp2(float __x) + { return __builtin_exp2f(__x); } + + constexpr long double + exp2(long double __x) + { return __builtin_exp2l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + exp2(_Tp __x) + { return __builtin_exp2(__x); } + + + + constexpr float + expm1(float __x) + { return __builtin_expm1f(__x); } + + constexpr long double + expm1(long double __x) + { return __builtin_expm1l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + expm1(_Tp __x) + { return __builtin_expm1(__x); } + + + + constexpr float + fdim(float __x, float __y) + { return __builtin_fdimf(__x, __y); } + + constexpr long double + fdim(long double __x, long double __y) + { return __builtin_fdiml(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fdim(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fdim(__type(__x), __type(__y)); + } + + + + constexpr float + fma(float __x, float __y, float __z) + { return __builtin_fmaf(__x, __y, __z); } + + constexpr long double + fma(long double __x, long double __y, long double __z) + { return __builtin_fmal(__x, __y, __z); } + + + + template + constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type + fma(_Tp __x, _Up __y, _Vp __z) + { + typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type; + return fma(__type(__x), __type(__y), __type(__z)); + } + + + + constexpr float + fmax(float __x, float __y) + { return __builtin_fmaxf(__x, __y); } + + constexpr long double + fmax(long double __x, long double __y) + { return __builtin_fmaxl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmax(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmax(__type(__x), __type(__y)); + } + + + + constexpr float + fmin(float __x, float __y) + { return __builtin_fminf(__x, __y); } + + constexpr long double + fmin(long double __x, long double __y) + { return __builtin_fminl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmin(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmin(__type(__x), __type(__y)); + } + + + + constexpr float + hypot(float __x, float __y) + { return __builtin_hypotf(__x, __y); } + + constexpr long double + hypot(long double __x, long double __y) + { return __builtin_hypotl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + hypot(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return hypot(__type(__x), __type(__y)); + } + + + + constexpr int + ilogb(float __x) + { return __builtin_ilogbf(__x); } + + constexpr int + ilogb(long double __x) + { return __builtin_ilogbl(__x); } + + + + template + constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + int>::__type + ilogb(_Tp __x) + { return __builtin_ilogb(__x); } + + + + constexpr float + lgamma(float __x) + { return __builtin_lgammaf(__x); } + + constexpr long double + lgamma(long double __x) + { return __builtin_lgammal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + lgamma(_Tp __x) + { return __builtin_lgamma(__x); } + + + + constexpr long long + llrint(float __x) + { return __builtin_llrintf(__x); } + + constexpr long long + llrint(long double __x) + { return __builtin_llrintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long long>::__type + llrint(_Tp __x) + { return __builtin_llrint(__x); } + + + + constexpr long long + llround(float __x) + { return __builtin_llroundf(__x); } + + constexpr long long + llround(long double __x) + { return __builtin_llroundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long long>::__type + llround(_Tp __x) + { return __builtin_llround(__x); } + + + + constexpr float + log1p(float __x) + { return __builtin_log1pf(__x); } + + constexpr long double + log1p(long double __x) + { return __builtin_log1pl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log1p(_Tp __x) + { return __builtin_log1p(__x); } + + + + + constexpr float + log2(float __x) + { return __builtin_log2f(__x); } + + constexpr long double + log2(long double __x) + { return __builtin_log2l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log2(_Tp __x) + { return __builtin_log2(__x); } + + + + constexpr float + logb(float __x) + { return __builtin_logbf(__x); } + + constexpr long double + logb(long double __x) + { return __builtin_logbl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + logb(_Tp __x) + { return __builtin_logb(__x); } + + + + constexpr long + lrint(float __x) + { return __builtin_lrintf(__x); } + + constexpr long + lrint(long double __x) + { return __builtin_lrintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long>::__type + lrint(_Tp __x) + { return __builtin_lrint(__x); } + + + + constexpr long + lround(float __x) + { return __builtin_lroundf(__x); } + + constexpr long + lround(long double __x) + { return __builtin_lroundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long>::__type + lround(_Tp __x) + { return __builtin_lround(__x); } + + + + constexpr float + nearbyint(float __x) + { return __builtin_nearbyintf(__x); } + + constexpr long double + nearbyint(long double __x) + { return __builtin_nearbyintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + nearbyint(_Tp __x) + { return __builtin_nearbyint(__x); } + + + + constexpr float + nextafter(float __x, float __y) + { return __builtin_nextafterf(__x, __y); } + + constexpr long double + nextafter(long double __x, long double __y) + { return __builtin_nextafterl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + nextafter(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return nextafter(__type(__x), __type(__y)); + } + + + + constexpr float + nexttoward(float __x, long double __y) + { return __builtin_nexttowardf(__x, __y); } + + constexpr long double + nexttoward(long double __x, long double __y) + { return __builtin_nexttowardl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + nexttoward(_Tp __x, long double __y) + { return __builtin_nexttoward(__x, __y); } + + + + constexpr float + remainder(float __x, float __y) + { return __builtin_remainderf(__x, __y); } + + constexpr long double + remainder(long double __x, long double __y) + { return __builtin_remainderl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + remainder(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return remainder(__type(__x), __type(__y)); + } + + + + inline float + remquo(float __x, float __y, int* __pquo) + { return __builtin_remquof(__x, __y, __pquo); } + + inline long double + remquo(long double __x, long double __y, int* __pquo) + { return __builtin_remquol(__x, __y, __pquo); } + + + + template + inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + remquo(_Tp __x, _Up __y, int* __pquo) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return remquo(__type(__x), __type(__y), __pquo); + } + + + + constexpr float + rint(float __x) + { return __builtin_rintf(__x); } + + constexpr long double + rint(long double __x) + { return __builtin_rintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + rint(_Tp __x) + { return __builtin_rint(__x); } + + + + constexpr float + round(float __x) + { return __builtin_roundf(__x); } + + constexpr long double + round(long double __x) + { return __builtin_roundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + round(_Tp __x) + { return __builtin_round(__x); } + + + + constexpr float + scalbln(float __x, long __ex) + { return __builtin_scalblnf(__x, __ex); } + + constexpr long double + scalbln(long double __x, long __ex) + { return __builtin_scalblnl(__x, __ex); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + scalbln(_Tp __x, long __ex) + { return __builtin_scalbln(__x, __ex); } + + + + constexpr float + scalbn(float __x, int __ex) + { return __builtin_scalbnf(__x, __ex); } + + constexpr long double + scalbn(long double __x, int __ex) + { return __builtin_scalbnl(__x, __ex); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + scalbn(_Tp __x, int __ex) + { return __builtin_scalbn(__x, __ex); } + + + + constexpr float + tgamma(float __x) + { return __builtin_tgammaf(__x); } + + constexpr long double + tgamma(long double __x) + { return __builtin_tgammal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tgamma(_Tp __x) + { return __builtin_tgamma(__x); } + + + + constexpr float + trunc(float __x) + { return __builtin_truncf(__x); } + + constexpr long double + trunc(long double __x) + { return __builtin_truncl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + trunc(_Tp __x) + { return __builtin_trunc(__x); } +# 1852 "/usr/include/c++/11/cmath" 3 + template + inline _Tp + __hypot3(_Tp __x, _Tp __y, _Tp __z) + { + __x = std::abs(__x); + __y = std::abs(__y); + __z = std::abs(__z); + if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x) + return __a * std::sqrt((__x / __a) * (__x / __a) + + (__y / __a) * (__y / __a) + + (__z / __a) * (__z / __a)); + else + return {}; + } + + inline float + hypot(float __x, float __y, float __z) + { return std::__hypot3(__x, __y, __z); } + + inline double + hypot(double __x, double __y, double __z) + { return std::__hypot3(__x, __y, __z); } + + inline long double + hypot(long double __x, long double __y, long double __z) + { return std::__hypot3(__x, __y, __z); } + + template + __gnu_cxx::__promoted_t<_Tp, _Up, _Vp> + hypot(_Tp __x, _Up __y, _Vp __z) + { + using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>; + return std::__hypot3<__type>(__x, __y, __z); + } +# 1931 "/usr/include/c++/11/cmath" 3 + +} + + +# 1 "/usr/include/c++/11/bits/specfun.h" 1 3 +# 33 "/usr/include/c++/11/bits/specfun.h" 3 +#pragma GCC visibility push(default) +# 45 "/usr/include/c++/11/bits/specfun.h" 3 +# 1 "/usr/include/c++/11/bits/stl_algobase.h" 1 3 +# 60 "/usr/include/c++/11/bits/stl_algobase.h" 3 +# 1 "/usr/include/c++/11/bits/functexcept.h" 1 3 +# 40 "/usr/include/c++/11/bits/functexcept.h" 3 +# 1 "/usr/include/c++/11/bits/exception_defines.h" 1 3 +# 41 "/usr/include/c++/11/bits/functexcept.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + void + __throw_bad_exception(void) __attribute__((__noreturn__)); + + + void + __throw_bad_alloc(void) __attribute__((__noreturn__)); + + void + __throw_bad_array_new_length(void) __attribute__((__noreturn__)); + + + void + __throw_bad_cast(void) __attribute__((__noreturn__)); + + void + __throw_bad_typeid(void) __attribute__((__noreturn__)); + + + void + __throw_logic_error(const char*) __attribute__((__noreturn__)); + + void + __throw_domain_error(const char*) __attribute__((__noreturn__)); + + void + __throw_invalid_argument(const char*) __attribute__((__noreturn__)); + + void + __throw_length_error(const char*) __attribute__((__noreturn__)); + + void + __throw_out_of_range(const char*) __attribute__((__noreturn__)); + + void + __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__)) + __attribute__((__format__(__gnu_printf__, 1, 2))); + + void + __throw_runtime_error(const char*) __attribute__((__noreturn__)); + + void + __throw_range_error(const char*) __attribute__((__noreturn__)); + + void + __throw_overflow_error(const char*) __attribute__((__noreturn__)); + + void + __throw_underflow_error(const char*) __attribute__((__noreturn__)); + + + void + __throw_ios_failure(const char*) __attribute__((__noreturn__)); + + void + __throw_ios_failure(const char*, int) __attribute__((__noreturn__)); + + + void + __throw_system_error(int) __attribute__((__noreturn__)); + + + void + __throw_future_error(int) __attribute__((__noreturn__)); + + + void + __throw_bad_function_call() __attribute__((__noreturn__)); + + +} +# 61 "/usr/include/c++/11/bits/stl_algobase.h" 2 3 + + +# 1 "/usr/include/c++/11/ext/numeric_traits.h" 1 3 +# 32 "/usr/include/c++/11/ext/numeric_traits.h" 3 + +# 33 "/usr/include/c++/11/ext/numeric_traits.h" 3 + + + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 50 "/usr/include/c++/11/ext/numeric_traits.h" 3 + template + struct __is_integer_nonstrict + : public std::__is_integer<_Tp> + { + using std::__is_integer<_Tp>::__value; + + + enum { __width = __value ? sizeof(_Tp) * 8 : 0 }; + }; + + template + struct __numeric_traits_integer + { + + static_assert(__is_integer_nonstrict<_Value>::__value, + "invalid specialization"); + + + + + static const bool __is_signed = (_Value)(-1) < 0; + static const int __digits + = __is_integer_nonstrict<_Value>::__width - __is_signed; + + + static const _Value __max = __is_signed + ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1) + : ~(_Value)0; + static const _Value __min = __is_signed ? -__max - 1 : (_Value)0; + }; + + template + const _Value __numeric_traits_integer<_Value>::__min; + + template + const _Value __numeric_traits_integer<_Value>::__max; + + template + const bool __numeric_traits_integer<_Value>::__is_signed; + + template + const int __numeric_traits_integer<_Value>::__digits; +# 135 "/usr/include/c++/11/ext/numeric_traits.h" 3 + template + using __int_traits = __numeric_traits_integer<_Tp>; +# 155 "/usr/include/c++/11/ext/numeric_traits.h" 3 + template + struct __numeric_traits_floating + { + + static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136); + + + static const bool __is_signed = true; + static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18); + static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932); + }; + + template + const int __numeric_traits_floating<_Value>::__max_digits10; + + template + const bool __numeric_traits_floating<_Value>::__is_signed; + + template + const int __numeric_traits_floating<_Value>::__digits10; + + template + const int __numeric_traits_floating<_Value>::__max_exponent10; + + + + + + + template + struct __numeric_traits + : public __numeric_traits_integer<_Value> + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; +# 236 "/usr/include/c++/11/ext/numeric_traits.h" 3 + +} +# 64 "/usr/include/c++/11/bits/stl_algobase.h" 2 3 +# 1 "/usr/include/c++/11/bits/stl_pair.h" 1 3 +# 59 "/usr/include/c++/11/bits/stl_pair.h" 3 +# 1 "/usr/include/c++/11/bits/move.h" 1 3 +# 38 "/usr/include/c++/11/bits/move.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + inline constexpr _Tp* + __addressof(_Tp& __r) noexcept + { return __builtin_addressof(__r); } + + + + +} + +# 1 "/usr/include/c++/11/type_traits" 1 3 +# 32 "/usr/include/c++/11/type_traits" 3 + +# 33 "/usr/include/c++/11/type_traits" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + class tuple; + + template + class reference_wrapper; +# 64 "/usr/include/c++/11/type_traits" 3 + template + struct integral_constant + { + static constexpr _Tp value = __v; + typedef _Tp value_type; + typedef integral_constant<_Tp, __v> type; + constexpr operator value_type() const noexcept { return value; } + + + + + constexpr value_type operator()() const noexcept { return value; } + + }; + + template + constexpr _Tp integral_constant<_Tp, __v>::value; + + + using true_type = integral_constant; + + + using false_type = integral_constant; + + + + template + using __bool_constant = integral_constant; + + + + + + + template + using bool_constant = integral_constant; + + + + + template + struct conditional; + + + template + struct __type_identity + { using type = _Type; }; + + template + using __type_identity_t = typename __type_identity<_Tp>::type; + + template + struct __or_; + + template<> + struct __or_<> + : public false_type + { }; + + template + struct __or_<_B1> + : public _B1 + { }; + + template + struct __or_<_B1, _B2> + : public conditional<_B1::value, _B1, _B2>::type + { }; + + template + struct __or_<_B1, _B2, _B3, _Bn...> + : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type + { }; + + template + struct __and_; + + template<> + struct __and_<> + : public true_type + { }; + + template + struct __and_<_B1> + : public _B1 + { }; + + template + struct __and_<_B1, _B2> + : public conditional<_B1::value, _B2, _B1>::type + { }; + + template + struct __and_<_B1, _B2, _B3, _Bn...> + : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type + { }; + + template + struct __not_ + : public __bool_constant + { }; + + + + + + template + inline constexpr bool __or_v = __or_<_Bn...>::value; + template + inline constexpr bool __and_v = __and_<_Bn...>::value; + + + + + template + struct conjunction + : __and_<_Bn...> + { }; + + template + struct disjunction + : __or_<_Bn...> + { }; + + template + struct negation + : __not_<_Pp> + { }; + + + + + template + inline constexpr bool conjunction_v = conjunction<_Bn...>::value; + + template + inline constexpr bool disjunction_v = disjunction<_Bn...>::value; + + template + inline constexpr bool negation_v = negation<_Pp>::value; + + + + + + template + struct is_reference; + template + struct is_function; + template + struct is_void; + template + struct remove_cv; + template + struct is_const; + + + template + struct __is_array_unknown_bounds; + + + + + template + constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>) + { return {}; } + + template + constexpr typename __or_< + is_reference<_NestedType>, + is_function<_NestedType>, + is_void<_NestedType>, + __is_array_unknown_bounds<_NestedType> + >::type __is_complete_or_unbounded(_TypeIdentity) + { return {}; } + + + + + + + template + struct __success_type + { typedef _Tp type; }; + + struct __failure_type + { }; + + + template + using __remove_cv_t = typename remove_cv<_Tp>::type; + + + + template + struct __is_void_helper + : public false_type { }; + + template<> + struct __is_void_helper + : public true_type { }; + + + + template + struct is_void + : public __is_void_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct __is_integral_helper + : public false_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + + template<> + struct __is_integral_helper + : public true_type { }; +# 310 "/usr/include/c++/11/type_traits" 3 + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + template<> + struct __is_integral_helper<__int128> + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; +# 391 "/usr/include/c++/11/type_traits" 3 + template + struct is_integral + : public __is_integral_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct __is_floating_point_helper + : public false_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; +# 421 "/usr/include/c++/11/type_traits" 3 + template + struct is_floating_point + : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_array + : public false_type { }; + + template + struct is_array<_Tp[_Size]> + : public true_type { }; + + template + struct is_array<_Tp[]> + : public true_type { }; + + template + struct __is_pointer_helper + : public false_type { }; + + template + struct __is_pointer_helper<_Tp*> + : public true_type { }; + + + template + struct is_pointer + : public __is_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_lvalue_reference + : public false_type { }; + + template + struct is_lvalue_reference<_Tp&> + : public true_type { }; + + + template + struct is_rvalue_reference + : public false_type { }; + + template + struct is_rvalue_reference<_Tp&&> + : public true_type { }; + + template + struct __is_member_object_pointer_helper + : public false_type { }; + + template + struct __is_member_object_pointer_helper<_Tp _Cp::*> + : public __not_>::type { }; + + + template + struct is_member_object_pointer + : public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + template + struct __is_member_function_pointer_helper + : public false_type { }; + + template + struct __is_member_function_pointer_helper<_Tp _Cp::*> + : public is_function<_Tp>::type { }; + + + template + struct is_member_function_pointer + : public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_enum + : public integral_constant + { }; + + + template + struct is_union + : public integral_constant + { }; + + + template + struct is_class + : public integral_constant + { }; + + + template + struct is_function + : public __bool_constant::value> { }; + + template + struct is_function<_Tp&> + : public false_type { }; + + template + struct is_function<_Tp&&> + : public false_type { }; + + + + template + struct __is_null_pointer_helper + : public false_type { }; + + template<> + struct __is_null_pointer_helper + : public true_type { }; + + + template + struct is_null_pointer + : public __is_null_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + + template + struct __is_nullptr_t + : public is_null_pointer<_Tp> + { } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead"))); + + + + + template + struct is_reference + : public __or_, + is_rvalue_reference<_Tp>>::type + { }; + + + template + struct is_arithmetic + : public __or_, is_floating_point<_Tp>>::type + { }; + + + template + struct is_fundamental + : public __or_, is_void<_Tp>, + is_null_pointer<_Tp>>::type + { }; + + + template + struct is_object + : public __not_<__or_, is_reference<_Tp>, + is_void<_Tp>>>::type + { }; + + template + struct is_member_pointer; + + + template + struct is_scalar + : public __or_, is_enum<_Tp>, is_pointer<_Tp>, + is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type + { }; + + + template + struct is_compound + : public __not_>::type { }; + + + template + struct __is_member_pointer_helper + : public false_type { }; + + template + struct __is_member_pointer_helper<_Tp _Cp::*> + : public true_type { }; + + + + template + struct is_member_pointer + : public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + template + struct is_same; + + + template + using __is_one_of = __or_...>; + + + template + using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>, + signed char, signed short, signed int, signed long, + signed long long + + , signed __int128 +# 637 "/usr/include/c++/11/type_traits" 3 + >; + + + template + using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>, + unsigned char, unsigned short, unsigned int, unsigned long, + unsigned long long + + , unsigned __int128 +# 656 "/usr/include/c++/11/type_traits" 3 + >; + + + template + using __is_standard_integer + = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>; + + + template using __void_t = void; + + + + template + struct __is_referenceable + : public false_type + { }; + + template + struct __is_referenceable<_Tp, __void_t<_Tp&>> + : public true_type + { }; + + + + + + template + struct is_const + : public false_type { }; + + template + struct is_const<_Tp const> + : public true_type { }; + + + template + struct is_volatile + : public false_type { }; + + template + struct is_volatile<_Tp volatile> + : public true_type { }; + + + template + struct is_trivial + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_copyable + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_standard_layout + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct + + is_pod + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + template + struct + [[__deprecated__]] + is_literal_type + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_empty + : public integral_constant + { }; + + + template + struct is_polymorphic + : public integral_constant + { }; + + + + + + template + struct is_final + : public integral_constant + { }; + + + + template + struct is_abstract + : public integral_constant + { }; + + + template::value> + struct __is_signed_helper + : public false_type { }; + + template + struct __is_signed_helper<_Tp, true> + : public integral_constant + { }; + + + + template + struct is_signed + : public __is_signed_helper<_Tp>::type + { }; + + + template + struct is_unsigned + : public __and_, __not_>> + { }; + + + template + _Up + __declval(int); + + template + _Tp + __declval(long); + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)); + + template + struct extent; + + template + struct remove_all_extents; + + + template + struct __is_array_known_bounds + : public integral_constant::value > 0)> + { }; + + template + struct __is_array_unknown_bounds + : public __and_, __not_>> + { }; +# 842 "/usr/include/c++/11/type_traits" 3 + struct __do_is_destructible_impl + { + template().~_Tp())> + static true_type __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_destructible_impl + : public __do_is_destructible_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_destructible_safe; + + template + struct __is_destructible_safe<_Tp, false, false> + : public __is_destructible_impl::type>::type + { }; + + template + struct __is_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + struct is_destructible + : public __is_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + + + struct __do_is_nt_destructible_impl + { + template + static __bool_constant().~_Tp())> + __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_nt_destructible_impl + : public __do_is_nt_destructible_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_nt_destructible_safe; + + template + struct __is_nt_destructible_safe<_Tp, false, false> + : public __is_nt_destructible_impl::type>::type + { }; + + template + struct __is_nt_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_nt_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + struct is_nothrow_destructible + : public __is_nt_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct __is_constructible_impl + : public __bool_constant<__is_constructible(_Tp, _Args...)> + { }; + + + + template + struct is_constructible + : public __is_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_default_constructible + : public __is_constructible_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template::value> + struct __is_copy_constructible_impl; + + template + struct __is_copy_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_copy_constructible_impl<_Tp, true> + : public __is_constructible_impl<_Tp, const _Tp&> + { }; + + + + template + struct is_copy_constructible + : public __is_copy_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template::value> + struct __is_move_constructible_impl; + + template + struct __is_move_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_move_constructible_impl<_Tp, true> + : public __is_constructible_impl<_Tp, _Tp&&> + { }; + + + + template + struct is_move_constructible + : public __is_move_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_constructible_impl + = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>; + + + + template + struct is_nothrow_constructible + : public __is_nothrow_constructible_impl<_Tp, _Args...>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_default_constructible + : public __bool_constant<__is_nothrow_constructible(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template::value> + struct __is_nothrow_copy_constructible_impl; + + template + struct __is_nothrow_copy_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_nothrow_copy_constructible_impl<_Tp, true> + : public __is_nothrow_constructible_impl<_Tp, const _Tp&> + { }; + + + + template + struct is_nothrow_copy_constructible + : public __is_nothrow_copy_constructible_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template::value> + struct __is_nothrow_move_constructible_impl; + + template + struct __is_nothrow_move_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_nothrow_move_constructible_impl<_Tp, true> + : public __is_nothrow_constructible_impl<_Tp, _Tp&&> + { }; + + + + template + struct is_nothrow_move_constructible + : public __is_nothrow_move_constructible_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_assignable + : public __bool_constant<__is_assignable(_Tp, _Up)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + template::value> + struct __is_copy_assignable_impl; + + template + struct __is_copy_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_copy_assignable_impl<_Tp, true> + : public __bool_constant<__is_assignable(_Tp&, const _Tp&)> + { }; + + + template + struct is_copy_assignable + : public __is_copy_assignable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + template::value> + struct __is_move_assignable_impl; + + template + struct __is_move_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_move_assignable_impl<_Tp, true> + : public __bool_constant<__is_assignable(_Tp&, _Tp&&)> + { }; + + + template + struct is_move_assignable + : public __is_move_assignable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + template + using __is_nothrow_assignable_impl + = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>; + + + template + struct is_nothrow_assignable + : public __is_nothrow_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + template::value> + struct __is_nt_copy_assignable_impl; + + template + struct __is_nt_copy_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_nt_copy_assignable_impl<_Tp, true> + : public __is_nothrow_assignable_impl<_Tp&, const _Tp&> + { }; + + + template + struct is_nothrow_copy_assignable + : public __is_nt_copy_assignable_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + template::value> + struct __is_nt_move_assignable_impl; + + template + struct __is_nt_move_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_nt_move_assignable_impl<_Tp, true> + : public __is_nothrow_assignable_impl<_Tp&, _Tp&&> + { }; + + + template + struct is_nothrow_move_assignable + : public __is_nt_move_assignable_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_constructible + : public __bool_constant<__is_trivially_constructible(_Tp, _Args...)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_default_constructible + : public __bool_constant<__is_trivially_constructible(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + struct __do_is_implicitly_default_constructible_impl + { + template + static void __helper(const _Tp&); + + template + static true_type __test(const _Tp&, + decltype(__helper({}))* = 0); + + static false_type __test(...); + }; + + template + struct __is_implicitly_default_constructible_impl + : public __do_is_implicitly_default_constructible_impl + { + typedef decltype(__test(declval<_Tp>())) type; + }; + + template + struct __is_implicitly_default_constructible_safe + : public __is_implicitly_default_constructible_impl<_Tp>::type + { }; + + template + struct __is_implicitly_default_constructible + : public __and_<__is_constructible_impl<_Tp>, + __is_implicitly_default_constructible_safe<_Tp>> + { }; + + template::value> + struct __is_trivially_copy_constructible_impl; + + template + struct __is_trivially_copy_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_trivially_copy_constructible_impl<_Tp, true> + : public __and_<__is_copy_constructible_impl<_Tp>, + integral_constant> + { }; + + + template + struct is_trivially_copy_constructible + : public __is_trivially_copy_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + template::value> + struct __is_trivially_move_constructible_impl; + + template + struct __is_trivially_move_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_trivially_move_constructible_impl<_Tp, true> + : public __and_<__is_move_constructible_impl<_Tp>, + integral_constant> + { }; + + + template + struct is_trivially_move_constructible + : public __is_trivially_move_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_assignable + : public __bool_constant<__is_trivially_assignable(_Tp, _Up)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + template::value> + struct __is_trivially_copy_assignable_impl; + + template + struct __is_trivially_copy_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_trivially_copy_assignable_impl<_Tp, true> + : public __bool_constant<__is_trivially_assignable(_Tp&, const _Tp&)> + { }; + + + template + struct is_trivially_copy_assignable + : public __is_trivially_copy_assignable_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + template::value> + struct __is_trivially_move_assignable_impl; + + template + struct __is_trivially_move_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_trivially_move_assignable_impl<_Tp, true> + : public __bool_constant<__is_trivially_assignable(_Tp&, _Tp&&)> + { }; + + + template + struct is_trivially_move_assignable + : public __is_trivially_move_assignable_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_destructible + : public __and_<__is_destructible_safe<_Tp>, + __bool_constant<__has_trivial_destructor(_Tp)>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + struct has_virtual_destructor + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct alignment_of + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct rank + : public integral_constant { }; + + template + struct rank<_Tp[_Size]> + : public integral_constant::value> { }; + + template + struct rank<_Tp[]> + : public integral_constant::value> { }; + + + template + struct extent + : public integral_constant { }; + + template + struct extent<_Tp[_Size], _Uint> + : public integral_constant::value> + { }; + + template + struct extent<_Tp[], _Uint> + : public integral_constant::value> + { }; + + + + + + template + struct is_same + + : public integral_constant + + + + { }; +# 1420 "/usr/include/c++/11/type_traits" 3 + template + struct is_base_of + : public integral_constant + { }; + + template, is_function<_To>, + is_array<_To>>::value> + struct __is_convertible_helper + { + typedef typename is_void<_To>::type type; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + template + class __is_convertible_helper<_From, _To, false> + { + template + static void __test_aux(_To1) noexcept; + + template(std::declval<_From1>()))> + static true_type + __test(int); + + template + static false_type + __test(...); + + public: + typedef decltype(__test<_From, _To>(0)) type; + }; +#pragma GCC diagnostic pop + + + template + struct is_convertible + : public __is_convertible_helper<_From, _To>::type + { }; + + + template + using __is_array_convertible + = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>; + + template, is_function<_To>, + is_array<_To>>::value> + struct __is_nt_convertible_helper + : is_void<_To> + { }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + template + class __is_nt_convertible_helper<_From, _To, false> + { + template + static void __test_aux(_To1) noexcept; + + template + static + __bool_constant(std::declval<_From1>()))> + __test(int); + + template + static false_type + __test(...); + + public: + using type = decltype(__test<_From, _To>(0)); + }; +#pragma GCC diagnostic pop +# 1512 "/usr/include/c++/11/type_traits" 3 + template + struct remove_const + { typedef _Tp type; }; + + template + struct remove_const<_Tp const> + { typedef _Tp type; }; + + + template + struct remove_volatile + { typedef _Tp type; }; + + template + struct remove_volatile<_Tp volatile> + { typedef _Tp type; }; + + + template + struct remove_cv + { using type = _Tp; }; + + template + struct remove_cv + { using type = _Tp; }; + + template + struct remove_cv + { using type = _Tp; }; + + template + struct remove_cv + { using type = _Tp; }; + + + template + struct add_const + { typedef _Tp const type; }; + + + template + struct add_volatile + { typedef _Tp volatile type; }; + + + template + struct add_cv + { + typedef typename + add_const::type>::type type; + }; + + + + + + + template + using remove_const_t = typename remove_const<_Tp>::type; + + + template + using remove_volatile_t = typename remove_volatile<_Tp>::type; + + + template + using remove_cv_t = typename remove_cv<_Tp>::type; + + + template + using add_const_t = typename add_const<_Tp>::type; + + + template + using add_volatile_t = typename add_volatile<_Tp>::type; + + + template + using add_cv_t = typename add_cv<_Tp>::type; + + + + + + template + struct remove_reference + { typedef _Tp type; }; + + template + struct remove_reference<_Tp&> + { typedef _Tp type; }; + + template + struct remove_reference<_Tp&&> + { typedef _Tp type; }; + + template::value> + struct __add_lvalue_reference_helper + { typedef _Tp type; }; + + template + struct __add_lvalue_reference_helper<_Tp, true> + { typedef _Tp& type; }; + + + template + struct add_lvalue_reference + : public __add_lvalue_reference_helper<_Tp> + { }; + + template::value> + struct __add_rvalue_reference_helper + { typedef _Tp type; }; + + template + struct __add_rvalue_reference_helper<_Tp, true> + { typedef _Tp&& type; }; + + + template + struct add_rvalue_reference + : public __add_rvalue_reference_helper<_Tp> + { }; + + + + template + using remove_reference_t = typename remove_reference<_Tp>::type; + + + template + using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; + + + template + using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; + + + + + + + + template + struct __cv_selector; + + template + struct __cv_selector<_Unqualified, false, false> + { typedef _Unqualified __type; }; + + template + struct __cv_selector<_Unqualified, false, true> + { typedef volatile _Unqualified __type; }; + + template + struct __cv_selector<_Unqualified, true, false> + { typedef const _Unqualified __type; }; + + template + struct __cv_selector<_Unqualified, true, true> + { typedef const volatile _Unqualified __type; }; + + template::value, + bool _IsVol = is_volatile<_Qualified>::value> + class __match_cv_qualifiers + { + typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match; + + public: + typedef typename __match::__type __type; + }; + + + template + struct __make_unsigned + { typedef _Tp __type; }; + + template<> + struct __make_unsigned + { typedef unsigned char __type; }; + + template<> + struct __make_unsigned + { typedef unsigned char __type; }; + + template<> + struct __make_unsigned + { typedef unsigned short __type; }; + + template<> + struct __make_unsigned + { typedef unsigned int __type; }; + + template<> + struct __make_unsigned + { typedef unsigned long __type; }; + + template<> + struct __make_unsigned + { typedef unsigned long long __type; }; + + + template<> + struct __make_unsigned<__int128> + { typedef unsigned __int128 __type; }; +# 1736 "/usr/include/c++/11/type_traits" 3 + template::value, + bool _IsEnum = is_enum<_Tp>::value> + class __make_unsigned_selector; + + template + class __make_unsigned_selector<_Tp, true, false> + { + using __unsigned_type + = typename __make_unsigned<__remove_cv_t<_Tp>>::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; + }; + + class __make_unsigned_selector_base + { + protected: + template struct _List { }; + + template + struct _List<_Tp, _Up...> : _List<_Up...> + { static constexpr size_t __size = sizeof(_Tp); }; + + template + struct __select; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, true> + { using __type = _Uint; }; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, false> + : __select<_Sz, _List<_UInts...>> + { }; + }; + + + template + class __make_unsigned_selector<_Tp, false, true> + : __make_unsigned_selector_base + { + + using _UInts = _List; + + using __unsigned_type = typename __select::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; + }; + + + + + + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; +# 1812 "/usr/include/c++/11/type_traits" 3 + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + + + + + + template + struct make_unsigned + { typedef typename __make_unsigned_selector<_Tp>::__type type; }; + + + template<> + struct make_unsigned; + + + + + template + struct __make_signed + { typedef _Tp __type; }; + + template<> + struct __make_signed + { typedef signed char __type; }; + + template<> + struct __make_signed + { typedef signed char __type; }; + + template<> + struct __make_signed + { typedef signed short __type; }; + + template<> + struct __make_signed + { typedef signed int __type; }; + + template<> + struct __make_signed + { typedef signed long __type; }; + + template<> + struct __make_signed + { typedef signed long long __type; }; + + + template<> + struct __make_signed + { typedef __int128 __type; }; +# 1892 "/usr/include/c++/11/type_traits" 3 + template::value, + bool _IsEnum = is_enum<_Tp>::value> + class __make_signed_selector; + + template + class __make_signed_selector<_Tp, true, false> + { + using __signed_type + = typename __make_signed<__remove_cv_t<_Tp>>::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __signed_type>::__type; + }; + + + template + class __make_signed_selector<_Tp, false, true> + { + typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type; + + public: + typedef typename __make_signed_selector<__unsigned_type>::__type __type; + }; + + + + + + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; +# 1940 "/usr/include/c++/11/type_traits" 3 + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + + + + + + template + struct make_signed + { typedef typename __make_signed_selector<_Tp>::__type type; }; + + + template<> + struct make_signed; + + + + template + using make_signed_t = typename make_signed<_Tp>::type; + + + template + using make_unsigned_t = typename make_unsigned<_Tp>::type; + + + + + + template + struct remove_extent + { typedef _Tp type; }; + + template + struct remove_extent<_Tp[_Size]> + { typedef _Tp type; }; + + template + struct remove_extent<_Tp[]> + { typedef _Tp type; }; + + + template + struct remove_all_extents + { typedef _Tp type; }; + + template + struct remove_all_extents<_Tp[_Size]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + template + struct remove_all_extents<_Tp[]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + + + template + using remove_extent_t = typename remove_extent<_Tp>::type; + + + template + using remove_all_extents_t = typename remove_all_extents<_Tp>::type; + + + + + template + struct __remove_pointer_helper + { typedef _Tp type; }; + + template + struct __remove_pointer_helper<_Tp, _Up*> + { typedef _Up type; }; + + + template + struct remove_pointer + : public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>> + { }; + + template, + is_void<_Tp>>::value> + struct __add_pointer_helper + { typedef _Tp type; }; + + template + struct __add_pointer_helper<_Tp, true> + { typedef typename remove_reference<_Tp>::type* type; }; + + + template + struct add_pointer + : public __add_pointer_helper<_Tp> + { }; + + + + template + using remove_pointer_t = typename remove_pointer<_Tp>::type; + + + template + using add_pointer_t = typename add_pointer<_Tp>::type; + + + template + struct __aligned_storage_msa + { + union __type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__)) { } __align; + }; + }; +# 2076 "/usr/include/c++/11/type_traits" 3 + template::__type)> + struct aligned_storage + { + union type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__((_Align)))) { } __align; + }; + }; + + template + struct __strictest_alignment + { + static const size_t _S_alignment = 0; + static const size_t _S_size = 0; + }; + + template + struct __strictest_alignment<_Tp, _Types...> + { + static const size_t _S_alignment = + alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment + ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment; + static const size_t _S_size = + sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size + ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size; + }; +# 2115 "/usr/include/c++/11/type_traits" 3 + template + struct aligned_union + { + private: + static_assert(sizeof...(_Types) != 0, "At least one type is required"); + + using __strictest = __strictest_alignment<_Types...>; + static const size_t _S_len = _Len > __strictest::_S_size + ? _Len : __strictest::_S_size; + public: + + static const size_t alignment_value = __strictest::_S_alignment; + + typedef typename aligned_storage<_S_len, alignment_value>::type type; + }; + + template + const size_t aligned_union<_Len, _Types...>::alignment_value; + + + + + + template::value, + bool _IsFunction = is_function<_Up>::value> + struct __decay_selector; + + + template + struct __decay_selector<_Up, false, false> + { typedef __remove_cv_t<_Up> __type; }; + + template + struct __decay_selector<_Up, true, false> + { typedef typename remove_extent<_Up>::type* __type; }; + + template + struct __decay_selector<_Up, false, true> + { typedef typename add_pointer<_Up>::type __type; }; + + + + template + class decay + { + typedef typename remove_reference<_Tp>::type __remove_type; + + public: + typedef typename __decay_selector<__remove_type>::__type type; + }; + + + + + template + struct __strip_reference_wrapper + { + typedef _Tp __type; + }; + + template + struct __strip_reference_wrapper > + { + typedef _Tp& __type; + }; + + + template + using __decay_t = typename decay<_Tp>::type; + + template + using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>; + + + + + template + struct enable_if + { }; + + + template + struct enable_if + { typedef _Tp type; }; + + + + + template + using __enable_if_t = typename enable_if<_Cond, _Tp>::type; + + + template + using _Require = __enable_if_t<__and_<_Cond...>::value>; + + + template + using __remove_cvref_t + = typename remove_cv::type>::type; + + + + + template + struct conditional + { typedef _Iftrue type; }; + + + template + struct conditional + { typedef _Iffalse type; }; + + + template + struct common_type; + + + + + struct __do_common_type_impl + { + template + using __cond_t + = decltype(true ? std::declval<_Tp>() : std::declval<_Up>()); + + + + template + static __success_type<__decay_t<__cond_t<_Tp, _Up>>> + _S_test(int); +# 2255 "/usr/include/c++/11/type_traits" 3 + template + static __failure_type + _S_test_2(...); + + template + static decltype(_S_test_2<_Tp, _Up>(0)) + _S_test(...); + }; + + + template<> + struct common_type<> + { }; + + + template + struct common_type<_Tp0> + : public common_type<_Tp0, _Tp0> + { }; + + + template, typename _Dp2 = __decay_t<_Tp2>> + struct __common_type_impl + { + + + using type = common_type<_Dp1, _Dp2>; + }; + + template + struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2> + : private __do_common_type_impl + { + + + using type = decltype(_S_test<_Tp1, _Tp2>(0)); + }; + + + template + struct common_type<_Tp1, _Tp2> + : public __common_type_impl<_Tp1, _Tp2>::type + { }; + + template + struct __common_type_pack + { }; + + template + struct __common_type_fold; + + + template + struct common_type<_Tp1, _Tp2, _Rp...> + : public __common_type_fold, + __common_type_pack<_Rp...>> + { }; + + + + + template + struct __common_type_fold<_CTp, __common_type_pack<_Rp...>, + __void_t> + : public common_type + { }; + + + template + struct __common_type_fold<_CTp, _Rp, void> + { }; + + template::value> + struct __underlying_type_impl + { + using type = __underlying_type(_Tp); + }; + + template + struct __underlying_type_impl<_Tp, false> + { }; + + + + template + struct underlying_type + : public __underlying_type_impl<_Tp> + { }; + + + template + struct __declval_protector + { + static const bool __stop = false; + }; + + + + + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)) + { + static_assert(__declval_protector<_Tp>::__stop, + "declval() must not be used!"); + return __declval<_Tp>(0); + } + + + template + struct result_of; + + + + + + + struct __invoke_memfun_ref { }; + struct __invoke_memfun_deref { }; + struct __invoke_memobj_ref { }; + struct __invoke_memobj_deref { }; + struct __invoke_other { }; + + + template + struct __result_of_success : __success_type<_Tp> + { using __invoke_type = _Tag; }; + + + struct __result_of_memfun_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_ref + : private __result_of_memfun_ref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; + }; + + + struct __result_of_memfun_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_deref + : private __result_of_memfun_deref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; + }; + + + struct __result_of_memobj_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>() + ), __invoke_memobj_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_ref + : private __result_of_memobj_ref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; + }; + + + struct __result_of_memobj_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>() + ), __invoke_memobj_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_deref + : private __result_of_memobj_deref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; + }; + + template + struct __result_of_memobj; + + template + struct __result_of_memobj<_Res _Class::*, _Arg> + { + typedef __remove_cvref_t<_Arg> _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename conditional<__or_, + is_base_of<_Class, _Argval>>::value, + __result_of_memobj_ref<_MemPtr, _Arg>, + __result_of_memobj_deref<_MemPtr, _Arg> + >::type::type type; + }; + + template + struct __result_of_memfun; + + template + struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> + { + typedef typename remove_reference<_Arg>::type _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename conditional::value, + __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, + __result_of_memfun_deref<_MemPtr, _Arg, _Args...> + >::type::type type; + }; + + + + + + + template> + struct __inv_unwrap + { + using type = _Tp; + }; + + template + struct __inv_unwrap<_Tp, reference_wrapper<_Up>> + { + using type = _Up&; + }; + + template + struct __result_of_impl + { + typedef __failure_type type; + }; + + template + struct __result_of_impl + : public __result_of_memobj<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type> + { }; + + template + struct __result_of_impl + : public __result_of_memfun<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type, _Args...> + { }; + + + struct __result_of_other_impl + { + template + static __result_of_success()(std::declval<_Args>()...) + ), __invoke_other> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_impl + : private __result_of_other_impl + { + typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type; + }; + + + template + struct __invoke_result + : public __result_of_impl< + is_member_object_pointer< + typename remove_reference<_Functor>::type + >::value, + is_member_function_pointer< + typename remove_reference<_Functor>::type + >::value, + _Functor, _ArgTypes... + >::type + { }; + + + template + struct result_of<_Functor(_ArgTypes...)> + : public __invoke_result<_Functor, _ArgTypes...> + { }; + + + + template::__type)> + using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; + + template + using aligned_union_t = typename aligned_union<_Len, _Types...>::type; + + + template + using decay_t = typename decay<_Tp>::type; + + + template + using enable_if_t = typename enable_if<_Cond, _Tp>::type; + + + template + using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type; + + + template + using common_type_t = typename common_type<_Tp...>::type; + + + template + using underlying_type_t = typename underlying_type<_Tp>::type; + + + template + using result_of_t = typename result_of<_Tp>::type; + + + + + + template using void_t = void; + + + + + + template class _Op, typename... _Args> + struct __detector + { + using value_t = false_type; + using type = _Default; + }; + + + template class _Op, + typename... _Args> + struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> + { + using value_t = true_type; + using type = _Op<_Args...>; + }; + + + template class _Op, + typename... _Args> + using __detected_or = __detector<_Default, void, _Op, _Args...>; + + + template class _Op, + typename... _Args> + using __detected_or_t + = typename __detected_or<_Default, _Op, _Args...>::type; +# 2649 "/usr/include/c++/11/type_traits" 3 + template + struct __is_swappable; + + template + struct __is_nothrow_swappable; + + template + struct __is_tuple_like_impl : false_type + { }; + + template + struct __is_tuple_like_impl> : true_type + { }; + + + template + struct __is_tuple_like + : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type + { }; + + + template + + inline + _Require<__not_<__is_tuple_like<_Tp>>, + is_move_constructible<_Tp>, + is_move_assignable<_Tp>> + swap(_Tp&, _Tp&) + noexcept(__and_, + is_nothrow_move_assignable<_Tp>>::value); + + template + + inline + __enable_if_t<__is_swappable<_Tp>::value> + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + noexcept(__is_nothrow_swappable<_Tp>::value); + + + namespace __swappable_details { + using std::swap; + + struct __do_is_swappable_impl + { + template(), std::declval<_Tp&>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_impl + : public __swappable_details::__do_is_swappable_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template + struct __is_nothrow_swappable_impl + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template + struct __is_swappable + : public __is_swappable_impl<_Tp>::type + { }; + + template + struct __is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { }; + + + + + + + + template + struct is_swappable + : public __is_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_v = + is_swappable<_Tp>::value; + + + template + inline constexpr bool is_nothrow_swappable_v = + is_nothrow_swappable<_Tp>::value; + + + + namespace __swappable_with_details { + using std::swap; + + struct __do_is_swappable_with_impl + { + template(), std::declval<_Up>())), + typename + = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_with_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) + && + noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_with_impl + : public __swappable_with_details::__do_is_swappable_with_impl + { + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + + template + struct __is_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + template + struct __is_nothrow_swappable_with_impl + : public __swappable_with_details::__do_is_nothrow_swappable_with_impl + { + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + + template + struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + + + template + struct is_swappable_with + : public __is_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable_with + : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_with_v = + is_swappable_with<_Tp, _Up>::value; + + + template + inline constexpr bool is_nothrow_swappable_with_v = + is_nothrow_swappable_with<_Tp, _Up>::value; +# 2876 "/usr/include/c++/11/type_traits" 3 + template::value, typename = void> + struct __is_invocable_impl + : false_type + { + using __nothrow_type = false_type; + }; + + + template + struct __is_invocable_impl<_Result, _Ret, + true, + __void_t> + : true_type + { + using __nothrow_type = true_type; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + + template + struct __is_invocable_impl<_Result, _Ret, + false, + __void_t> + { + private: + + + + static typename _Result::type _S_get() noexcept; + + template + static void _S_conv(_Tp) noexcept; + + + template(_S_get())), + bool _Noex = noexcept(_S_conv<_Tp>(_S_get()))> + static __bool_constant<_Check_Noex ? _Noex : true> + _S_test(int); + + template + static false_type + _S_test(...); + + public: + + using type = decltype(_S_test<_Ret>(1)); + + + using __nothrow_type = decltype(_S_test<_Ret, true>(1)); + }; +#pragma GCC diagnostic pop + + template + struct __is_invocable + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type + { }; + + template + constexpr bool __call_is_nt(__invoke_memfun_ref) + { + using _Up = typename __inv_unwrap<_Tp>::type; + return noexcept((std::declval<_Up>().*std::declval<_Fn>())( + std::declval<_Args>()...)); + } + + template + constexpr bool __call_is_nt(__invoke_memfun_deref) + { + return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())( + std::declval<_Args>()...)); + } + + template + constexpr bool __call_is_nt(__invoke_memobj_ref) + { + using _Up = typename __inv_unwrap<_Tp>::type; + return noexcept(std::declval<_Up>().*std::declval<_Fn>()); + } + + template + constexpr bool __call_is_nt(__invoke_memobj_deref) + { + return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>()); + } + + template + constexpr bool __call_is_nt(__invoke_other) + { + return noexcept(std::declval<_Fn>()(std::declval<_Args>()...)); + } + + template + struct __call_is_nothrow + : __bool_constant< + std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{}) + > + { }; + + template + using __call_is_nothrow_ + = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>; + + + template + struct __is_nothrow_invocable + : __and_<__is_invocable<_Fn, _Args...>, + __call_is_nothrow_<_Fn, _Args...>>::type + { }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + struct __nonesuchbase {}; + struct __nonesuch : private __nonesuchbase { + ~__nonesuch() = delete; + __nonesuch(__nonesuch const&) = delete; + void operator=(__nonesuch const&) = delete; + }; +#pragma GCC diagnostic pop + + + + + + + template + struct invoke_result + : public __invoke_result<_Functor, _ArgTypes...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Functor>{}), + "_Functor must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; + + + template + struct is_invocable + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + struct is_invocable_r + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), + "_Ret must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_invocable + : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>, + __call_is_nothrow_<_Fn, _ArgTypes...>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + using __is_nt_invocable_impl + = typename __is_invocable_impl<_Result, _Ret>::__nothrow_type; + + + + template + struct is_nothrow_invocable_r + : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>, + __call_is_nothrow_<_Fn, _ArgTypes...>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), + "_Ret must be a complete class or an unbounded array"); + }; +# 3094 "/usr/include/c++/11/type_traits" 3 +template + inline constexpr bool is_void_v = is_void<_Tp>::value; +template + inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; +template + inline constexpr bool is_integral_v = is_integral<_Tp>::value; +template + inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; +template + inline constexpr bool is_array_v = is_array<_Tp>::value; +template + inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; +template + inline constexpr bool is_lvalue_reference_v = + is_lvalue_reference<_Tp>::value; +template + inline constexpr bool is_rvalue_reference_v = + is_rvalue_reference<_Tp>::value; +template + inline constexpr bool is_member_object_pointer_v = + is_member_object_pointer<_Tp>::value; +template + inline constexpr bool is_member_function_pointer_v = + is_member_function_pointer<_Tp>::value; +template + inline constexpr bool is_enum_v = is_enum<_Tp>::value; +template + inline constexpr bool is_union_v = is_union<_Tp>::value; +template + inline constexpr bool is_class_v = is_class<_Tp>::value; +template + inline constexpr bool is_function_v = is_function<_Tp>::value; +template + inline constexpr bool is_reference_v = is_reference<_Tp>::value; +template + inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; +template + inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; +template + inline constexpr bool is_object_v = is_object<_Tp>::value; +template + inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; +template + inline constexpr bool is_compound_v = is_compound<_Tp>::value; +template + inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value; +template + inline constexpr bool is_const_v = is_const<_Tp>::value; +template + inline constexpr bool is_volatile_v = is_volatile<_Tp>::value; +template + inline constexpr bool is_trivial_v = is_trivial<_Tp>::value; +template + inline constexpr bool is_trivially_copyable_v = + is_trivially_copyable<_Tp>::value; +template + inline constexpr bool is_standard_layout_v = is_standard_layout<_Tp>::value; +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +template + + inline constexpr bool is_pod_v = is_pod<_Tp>::value; +template + [[__deprecated__]] + inline constexpr bool is_literal_type_v = is_literal_type<_Tp>::value; +#pragma GCC diagnostic pop + template + inline constexpr bool is_empty_v = is_empty<_Tp>::value; +template + inline constexpr bool is_polymorphic_v = is_polymorphic<_Tp>::value; +template + inline constexpr bool is_abstract_v = is_abstract<_Tp>::value; +template + inline constexpr bool is_final_v = is_final<_Tp>::value; +template + inline constexpr bool is_signed_v = is_signed<_Tp>::value; +template + inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; +template + inline constexpr bool is_constructible_v = + is_constructible<_Tp, _Args...>::value; +template + inline constexpr bool is_default_constructible_v = + is_default_constructible<_Tp>::value; +template + inline constexpr bool is_copy_constructible_v = + is_copy_constructible<_Tp>::value; +template + inline constexpr bool is_move_constructible_v = + is_move_constructible<_Tp>::value; +template + inline constexpr bool is_assignable_v = is_assignable<_Tp, _Up>::value; +template + inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value; +template + inline constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value; +template + inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; +template + inline constexpr bool is_trivially_constructible_v = + is_trivially_constructible<_Tp, _Args...>::value; +template + inline constexpr bool is_trivially_default_constructible_v = + is_trivially_default_constructible<_Tp>::value; +template + inline constexpr bool is_trivially_copy_constructible_v = + is_trivially_copy_constructible<_Tp>::value; +template + inline constexpr bool is_trivially_move_constructible_v = + is_trivially_move_constructible<_Tp>::value; +template + inline constexpr bool is_trivially_assignable_v = + is_trivially_assignable<_Tp, _Up>::value; +template + inline constexpr bool is_trivially_copy_assignable_v = + is_trivially_copy_assignable<_Tp>::value; +template + inline constexpr bool is_trivially_move_assignable_v = + is_trivially_move_assignable<_Tp>::value; +template + inline constexpr bool is_trivially_destructible_v = + is_trivially_destructible<_Tp>::value; +template + inline constexpr bool is_nothrow_constructible_v = + is_nothrow_constructible<_Tp, _Args...>::value; +template + inline constexpr bool is_nothrow_default_constructible_v = + is_nothrow_default_constructible<_Tp>::value; +template + inline constexpr bool is_nothrow_copy_constructible_v = + is_nothrow_copy_constructible<_Tp>::value; +template + inline constexpr bool is_nothrow_move_constructible_v = + is_nothrow_move_constructible<_Tp>::value; +template + inline constexpr bool is_nothrow_assignable_v = + is_nothrow_assignable<_Tp, _Up>::value; +template + inline constexpr bool is_nothrow_copy_assignable_v = + is_nothrow_copy_assignable<_Tp>::value; +template + inline constexpr bool is_nothrow_move_assignable_v = + is_nothrow_move_assignable<_Tp>::value; +template + inline constexpr bool is_nothrow_destructible_v = + is_nothrow_destructible<_Tp>::value; +template + inline constexpr bool has_virtual_destructor_v = + has_virtual_destructor<_Tp>::value; +template + inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; +template + inline constexpr size_t rank_v = rank<_Tp>::value; +template + inline constexpr size_t extent_v = extent<_Tp, _Idx>::value; + +template + inline constexpr bool is_same_v = __is_same(_Tp, _Up); + + + + +template + inline constexpr bool is_base_of_v = is_base_of<_Base, _Derived>::value; +template + inline constexpr bool is_convertible_v = is_convertible<_From, _To>::value; +template + inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_v + = is_nothrow_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_invocable_r_v + = is_invocable_r<_Ret, _Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_r_v + = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value; + + + + + + template + struct has_unique_object_representations + : bool_constant<__has_unique_object_representations( + remove_cv_t> + )> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + inline constexpr bool has_unique_object_representations_v + = has_unique_object_representations<_Tp>::value; + + + + + + template + struct is_aggregate + : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> + { }; + + + template + inline constexpr bool is_aggregate_v = is_aggregate<_Tp>::value; +# 3598 "/usr/include/c++/11/type_traits" 3 + +} +# 58 "/usr/include/c++/11/bits/move.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 74 "/usr/include/c++/11/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type& __t) noexcept + { return static_cast<_Tp&&>(__t); } + + + + + + + + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type&& __t) noexcept + { + static_assert(!std::is_lvalue_reference<_Tp>::value, + "std::forward must not be used to convert an rvalue to an lvalue"); + return static_cast<_Tp&&>(__t); + } + + + + + + + template + [[__nodiscard__]] + constexpr typename std::remove_reference<_Tp>::type&& + move(_Tp&& __t) noexcept + { return static_cast::type&&>(__t); } + + + template + struct __move_if_noexcept_cond + : public __and_<__not_>, + is_copy_constructible<_Tp>>::type { }; +# 121 "/usr/include/c++/11/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr typename + conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type + move_if_noexcept(_Tp& __x) noexcept + { return std::move(__x); } +# 142 "/usr/include/c++/11/bits/move.h" 3 + template + [[__nodiscard__]] + inline constexpr _Tp* + addressof(_Tp& __r) noexcept + { return std::__addressof(__r); } + + + + template + const _Tp* addressof(const _Tp&&) = delete; + + + template + + inline _Tp + __exchange(_Tp& __obj, _Up&& __new_val) + { + _Tp __old_val = std::move(__obj); + __obj = std::forward<_Up>(__new_val); + return __old_val; + } +# 186 "/usr/include/c++/11/bits/move.h" 3 + template + + inline + + typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>, + is_move_constructible<_Tp>, + is_move_assignable<_Tp>>::value>::type + + + + swap(_Tp& __a, _Tp& __b) + noexcept(__and_, is_nothrow_move_assignable<_Tp>>::value) + + { + + + + + _Tp __tmp = std::move(__a); + __a = std::move(__b); + __b = std::move(__tmp); + } + + + + + template + + inline + + typename enable_if<__is_swappable<_Tp>::value>::type + + + + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + noexcept(__is_nothrow_swappable<_Tp>::value) + { + for (size_t __n = 0; __n < _Nm; ++__n) + swap(__a[__n], __b[__n]); + } + + + +} +# 60 "/usr/include/c++/11/bits/stl_pair.h" 2 3 +# 69 "/usr/include/c++/11/bits/stl_pair.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 80 "/usr/include/c++/11/bits/stl_pair.h" 3 + struct piecewise_construct_t { explicit piecewise_construct_t() = default; }; + + + inline constexpr piecewise_construct_t piecewise_construct = + piecewise_construct_t(); + + + + + template + class tuple; + + template + struct _Index_tuple; + + + + + + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return __and_, + is_constructible<_T2, const _U2&>>::value; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return __and_, + is_convertible>::value; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return __and_, + is_constructible<_T2, _U2&&>>::value; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return __and_, + is_convertible<_U2&&, _T2>>::value; + } + + template + static constexpr bool _CopyMovePair() + { + using __do_converts = __and_, + is_convertible<_U2&&, _T2>>; + using __converts = typename conditional<__implicit, + __do_converts, + __not_<__do_converts>>::type; + return __and_, + is_constructible<_T2, _U2&&>, + __converts + >::value; + } + + template + static constexpr bool _MoveCopyPair() + { + using __do_converts = __and_, + is_convertible>; + using __converts = typename conditional<__implicit, + __do_converts, + __not_<__do_converts>>::type; + return __and_, + is_constructible<_T2, const _U2&&>, + __converts + >::value; + } + }; + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return false; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return false; + } + }; + + + template class __pair_base + { + + template friend struct pair; + __pair_base() = default; + ~__pair_base() = default; + __pair_base(const __pair_base&) = default; + __pair_base& operator=(const __pair_base&) = delete; + + }; +# 210 "/usr/include/c++/11/bits/stl_pair.h" 3 + template + struct pair + : private __pair_base<_T1, _T2> + { + typedef _T1 first_type; + typedef _T2 second_type; + + _T1 first; + _T2 second; + + + + + + + template , + __is_implicitly_default_constructible<_U2>> + ::value, bool>::type = true> + + constexpr pair() + : first(), second() { } + + + template , + is_default_constructible<_U2>, + __not_< + __and_<__is_implicitly_default_constructible<_U1>, + __is_implicitly_default_constructible<_U2>>>> + ::value, bool>::type = false> + explicit constexpr pair() + : first(), second() { } +# 256 "/usr/include/c++/11/bits/stl_pair.h" 3 + using _PCCP = _PCC; + + + + template() + && _PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + template() + && !_PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } +# 288 "/usr/include/c++/11/bits/stl_pair.h" 3 + template + using _PCCFP = _PCC::value + || !is_same<_T2, _U2>::value, + _T1, _T2>; + + + template::template + _ConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) { } + + template::template + _ConstructiblePair<_U1, _U2>() + && !_PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) { } + + + + constexpr pair(const pair&) = default; + constexpr pair(pair&&) = default; + + + template(), + bool>::type=true> + constexpr pair(_U1&& __x, const _T2& __y) + : first(std::forward<_U1>(__x)), second(__y) { } + + template(), + bool>::type=false> + explicit constexpr pair(_U1&& __x, const _T2& __y) + : first(std::forward<_U1>(__x)), second(__y) { } + + template(), + bool>::type=true> + constexpr pair(const _T1& __x, _U2&& __y) + : first(__x), second(std::forward<_U2>(__y)) { } + + template(), + bool>::type=false> + explicit pair(const _T1& __x, _U2&& __y) + : first(__x), second(std::forward<_U2>(__y)) { } + + template() + && _PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { } + + template() + && !_PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { } + + + template::template + _MoveConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) { } + + template::template + _MoveConstructiblePair<_U1, _U2>() + && !_PCCFP<_U1, _U2>::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) { } + + template + + pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); + + pair& + operator=(typename conditional< + __and_, + is_copy_assignable<_T2>>::value, + const pair&, const __nonesuch&>::type __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + pair& + operator=(typename conditional< + __and_, + is_move_assignable<_T2>>::value, + pair&&, __nonesuch&&>::type __p) + noexcept(__and_, + is_nothrow_move_assignable<_T2>>::value) + { + first = std::forward(__p.first); + second = std::forward(__p.second); + return *this; + } + + template + + typename enable_if<__and_, + is_assignable<_T2&, const _U2&>>::value, + pair&>::type + operator=(const pair<_U1, _U2>& __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + template + + typename enable_if<__and_, + is_assignable<_T2&, _U2&&>>::value, + pair&>::type + operator=(pair<_U1, _U2>&& __p) + { + first = std::forward<_U1>(__p.first); + second = std::forward<_U2>(__p.second); + return *this; + } + + + void + swap(pair& __p) + noexcept(__and_<__is_nothrow_swappable<_T1>, + __is_nothrow_swappable<_T2>>::value) + { + using std::swap; + swap(first, __p.first); + swap(second, __p.second); + } + + private: + template + + pair(tuple<_Args1...>&, tuple<_Args2...>&, + _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); + + }; + + + + + template pair(_T1, _T2) -> pair<_T1, _T2>; + + + + template + inline constexpr bool + operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first == __y.first && __x.second == __y.second; } +# 487 "/usr/include/c++/11/bits/stl_pair.h" 3 + template + inline constexpr bool + operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first < __y.first + || (!(__y.first < __x.first) && __x.second < __y.second); } + + + template + inline constexpr bool + operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x == __y); } + + + template + inline constexpr bool + operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __y < __x; } + + + template + inline constexpr bool + operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__y < __x); } + + + template + inline constexpr bool + operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x < __y); } +# 524 "/usr/include/c++/11/bits/stl_pair.h" 3 + template + inline + + + typename enable_if<__and_<__is_swappable<_T1>, + __is_swappable<_T2>>::value>::type + + + + swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } + + + template + typename enable_if, + __is_swappable<_T2>>::value>::type + swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete; +# 564 "/usr/include/c++/11/bits/stl_pair.h" 3 + template + constexpr pair::__type, + typename __decay_and_strip<_T2>::__type> + make_pair(_T1&& __x, _T2&& __y) + { + typedef typename __decay_and_strip<_T1>::__type __ds_type1; + typedef typename __decay_and_strip<_T2>::__type __ds_type2; + typedef pair<__ds_type1, __ds_type2> __pair_type; + return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y)); + } +# 583 "/usr/include/c++/11/bits/stl_pair.h" 3 + +} +# 65 "/usr/include/c++/11/bits/stl_algobase.h" 2 3 +# 1 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 1 3 +# 62 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 3 + +# 63 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 3 +# 74 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 93 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 3 + struct input_iterator_tag { }; + + + struct output_iterator_tag { }; + + + struct forward_iterator_tag : public input_iterator_tag { }; + + + + struct bidirectional_iterator_tag : public forward_iterator_tag { }; + + + + struct random_access_iterator_tag : public bidirectional_iterator_tag { }; +# 125 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 3 + template + struct iterator + { + + typedef _Category iterator_category; + + typedef _Tp value_type; + + typedef _Distance difference_type; + + typedef _Pointer pointer; + + typedef _Reference reference; + }; +# 149 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits; + + + + + template> + struct __iterator_traits { }; + + + + template + struct __iterator_traits<_Iterator, + __void_t> + { + typedef typename _Iterator::iterator_category iterator_category; + typedef typename _Iterator::value_type value_type; + typedef typename _Iterator::difference_type difference_type; + typedef typename _Iterator::pointer pointer; + typedef typename _Iterator::reference reference; + }; + + + template + struct iterator_traits + : public __iterator_traits<_Iterator> { }; +# 209 "/usr/include/c++/11/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits<_Tp*> + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef _Tp* pointer; + typedef _Tp& reference; + }; + + + template + struct iterator_traits + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef const _Tp* pointer; + typedef const _Tp& reference; + }; + + + + + + + template + inline constexpr + typename iterator_traits<_Iter>::iterator_category + __iterator_category(const _Iter&) + { return typename iterator_traits<_Iter>::iterator_category(); } + + + + + template + using __iterator_category_t + = typename iterator_traits<_Iter>::iterator_category; + + template + using _RequireInputIter = + __enable_if_t, + input_iterator_tag>::value>; + + template> + struct __is_random_access_iter + : is_base_of + { + typedef is_base_of _Base; + enum { __value = _Base::value }; + }; + + + + + + + + +} +# 66 "/usr/include/c++/11/bits/stl_algobase.h" 2 3 +# 1 "/usr/include/c++/11/bits/stl_iterator_base_funcs.h" 1 3 +# 62 "/usr/include/c++/11/bits/stl_iterator_base_funcs.h" 3 + +# 63 "/usr/include/c++/11/bits/stl_iterator_base_funcs.h" 3 + +# 1 "/usr/include/c++/11/bits/concept_check.h" 1 3 +# 33 "/usr/include/c++/11/bits/concept_check.h" 3 + +# 34 "/usr/include/c++/11/bits/concept_check.h" 3 +# 65 "/usr/include/c++/11/bits/stl_iterator_base_funcs.h" 2 3 +# 1 "/usr/include/c++/11/debug/assertions.h" 1 3 +# 66 "/usr/include/c++/11/bits/stl_iterator_base_funcs.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template struct _List_iterator; + template struct _List_const_iterator; + + + template + inline constexpr + typename iterator_traits<_InputIterator>::difference_type + __distance(_InputIterator __first, _InputIterator __last, + input_iterator_tag) + { + + + + typename iterator_traits<_InputIterator>::difference_type __n = 0; + while (__first != __last) + { + ++__first; + ++__n; + } + return __n; + } + + template + inline constexpr + typename iterator_traits<_RandomAccessIterator>::difference_type + __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, + random_access_iterator_tag) + { + + + + return __last - __first; + } + + + + template + ptrdiff_t + __distance(std::_List_iterator<_Tp>, + std::_List_iterator<_Tp>, + input_iterator_tag); + + template + ptrdiff_t + __distance(std::_List_const_iterator<_Tp>, + std::_List_const_iterator<_Tp>, + input_iterator_tag); +# 135 "/usr/include/c++/11/bits/stl_iterator_base_funcs.h" 3 + template + inline constexpr + typename iterator_traits<_InputIterator>::difference_type + distance(_InputIterator __first, _InputIterator __last) + { + + return std::__distance(__first, __last, + std::__iterator_category(__first)); + } + + template + inline constexpr void + __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) + { + + + do { if (__builtin_is_constant_evaluated() && !bool(__n >= 0)) __builtin_unreachable(); } while (false); + while (__n--) + ++__i; + } + + template + inline constexpr void + __advance(_BidirectionalIterator& __i, _Distance __n, + bidirectional_iterator_tag) + { + + + + if (__n > 0) + while (__n--) + ++__i; + else + while (__n++) + --__i; + } + + template + inline constexpr void + __advance(_RandomAccessIterator& __i, _Distance __n, + random_access_iterator_tag) + { + + + + if (__builtin_constant_p(__n) && __n == 1) + ++__i; + else if (__builtin_constant_p(__n) && __n == -1) + --__i; + else + __i += __n; + } +# 200 "/usr/include/c++/11/bits/stl_iterator_base_funcs.h" 3 + template + inline constexpr void + advance(_InputIterator& __i, _Distance __n) + { + + typename iterator_traits<_InputIterator>::difference_type __d = __n; + std::__advance(__i, __d, std::__iterator_category(__i)); + } + + + + template + inline constexpr _InputIterator + next(_InputIterator __x, typename + iterator_traits<_InputIterator>::difference_type __n = 1) + { + + + std::advance(__x, __n); + return __x; + } + + template + inline constexpr _BidirectionalIterator + prev(_BidirectionalIterator __x, typename + iterator_traits<_BidirectionalIterator>::difference_type __n = 1) + { + + + + std::advance(__x, -__n); + return __x; + } + + + + +} +# 67 "/usr/include/c++/11/bits/stl_algobase.h" 2 3 +# 1 "/usr/include/c++/11/bits/stl_iterator.h" 1 3 +# 67 "/usr/include/c++/11/bits/stl_iterator.h" 3 +# 1 "/usr/include/c++/11/bits/ptr_traits.h" 1 3 +# 42 "/usr/include/c++/11/bits/ptr_traits.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + class __undefined; + + + template + struct __replace_first_arg + { }; + + template class _Template, typename _Up, + typename _Tp, typename... _Types> + struct __replace_first_arg<_Template<_Tp, _Types...>, _Up> + { using type = _Template<_Up, _Types...>; }; + + template + using __replace_first_arg_t = typename __replace_first_arg<_Tp, _Up>::type; + + template + using __make_not_void + = typename conditional::value, __undefined, _Tp>::type; + + template + struct __ptr_traits_elem_1 + { }; + + template class _SomePointer, typename _Tp, + typename... _Args> + struct __ptr_traits_elem_1<_SomePointer<_Tp, _Args...>> + { + using element_type = _Tp; + using pointer = _SomePointer<_Tp, _Args...>; + + static pointer + pointer_to(__make_not_void& __e) + { return pointer::pointer_to(__e); } + }; + + template + struct __ptr_traits_elem : __ptr_traits_elem_1<_Ptr> + { }; + + template + struct __ptr_traits_elem<_Ptr, __void_t> + { + using element_type = typename _Ptr::element_type; + + static _Ptr + pointer_to(__make_not_void& __e) + { return _Ptr::pointer_to(__e); } + }; + + + + + + template + struct pointer_traits : __ptr_traits_elem<_Ptr> + { + private: + template + using __difference_type = typename _Tp::difference_type; + + template + struct __rebind : __replace_first_arg<_Tp, _Up> { }; + + template + struct __rebind<_Tp, _Up, __void_t>> + { using type = typename _Tp::template rebind<_Up>; }; + + public: + + using pointer = _Ptr; + + + using difference_type + = __detected_or_t; + + + template + using rebind = typename __rebind<_Ptr, _Up>::type; + }; + + + + + + template + struct pointer_traits<_Tp*> + { + + typedef _Tp* pointer; + + typedef _Tp element_type; + + typedef ptrdiff_t difference_type; + + template + using rebind = _Up*; + + + + + + + static pointer + pointer_to(__make_not_void& __r) noexcept + { return std::addressof(__r); } + }; + + + template + using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>; + + template + constexpr _Tp* + __to_address(_Tp* __ptr) noexcept + { + static_assert(!std::is_function<_Tp>::value, "not a function pointer"); + return __ptr; + } + + + template + constexpr typename std::pointer_traits<_Ptr>::element_type* + __to_address(const _Ptr& __ptr) + { return std::__to_address(__ptr.operator->()); } +# 214 "/usr/include/c++/11/bits/ptr_traits.h" 3 + +} +# 68 "/usr/include/c++/11/bits/stl_iterator.h" 2 3 +# 88 "/usr/include/c++/11/bits/stl_iterator.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 127 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + class reverse_iterator + : public iterator::iterator_category, + typename iterator_traits<_Iterator>::value_type, + typename iterator_traits<_Iterator>::difference_type, + typename iterator_traits<_Iterator>::pointer, + typename iterator_traits<_Iterator>::reference> + { + template + friend class reverse_iterator; +# 146 "/usr/include/c++/11/bits/stl_iterator.h" 3 + protected: + _Iterator current; + + typedef iterator_traits<_Iterator> __traits_type; + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::pointer pointer; + + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; +# 177 "/usr/include/c++/11/bits/stl_iterator.h" 3 + constexpr + reverse_iterator() : current() { } + + + + + explicit constexpr + reverse_iterator(iterator_type __x) : current(__x) { } + + + + + constexpr + reverse_iterator(const reverse_iterator& __x) + : current(__x.current) { } + + + reverse_iterator& operator=(const reverse_iterator&) = default; + + + + + + + template + + + + constexpr + reverse_iterator(const reverse_iterator<_Iter>& __x) + : current(__x.current) { } + + + template + + + + + constexpr + reverse_iterator& + operator=(const reverse_iterator<_Iter>& __x) + { + current = __x.current; + return *this; + } + + + + + + constexpr iterator_type + base() const + { return current; } +# 241 "/usr/include/c++/11/bits/stl_iterator.h" 3 + constexpr reference + operator*() const + { + _Iterator __tmp = current; + return *--__tmp; + } + + + + + + + constexpr pointer + operator->() const + + + + + { + + + _Iterator __tmp = current; + --__tmp; + return _S_to_pointer(__tmp); + } + + + + + + + constexpr reverse_iterator& + operator++() + { + --current; + return *this; + } + + + + + + + constexpr reverse_iterator + operator++(int) + { + reverse_iterator __tmp = *this; + --current; + return __tmp; + } + + + + + + + constexpr reverse_iterator& + operator--() + { + ++current; + return *this; + } + + + + + + + constexpr reverse_iterator + operator--(int) + { + reverse_iterator __tmp = *this; + ++current; + return __tmp; + } + + + + + + + constexpr reverse_iterator + operator+(difference_type __n) const + { return reverse_iterator(current - __n); } + + + + + + + + constexpr reverse_iterator& + operator+=(difference_type __n) + { + current -= __n; + return *this; + } + + + + + + + constexpr reverse_iterator + operator-(difference_type __n) const + { return reverse_iterator(current + __n); } + + + + + + + + constexpr reverse_iterator& + operator-=(difference_type __n) + { + current += __n; + return *this; + } + + + + + + + constexpr reference + operator[](difference_type __n) const + { return *(*this + __n); } +# 395 "/usr/include/c++/11/bits/stl_iterator.h" 3 + private: + template + static constexpr _Tp* + _S_to_pointer(_Tp* __p) + { return __p; } + + template + static constexpr pointer + _S_to_pointer(_Tp __t) + { return __t.operator->(); } + }; +# 418 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + inline constexpr bool + operator==(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } + + template + inline constexpr bool + operator<(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y.base() < __x.base(); } + + template + inline constexpr bool + operator!=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + inline constexpr bool + operator>(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y < __x; } + + template + inline constexpr bool + operator<=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + inline constexpr bool + operator>=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + + template + inline constexpr bool + operator==(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() == __y.base(); } + + template + inline constexpr bool + operator<(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() > __y.base(); } + + template + inline constexpr bool + operator!=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() != __y.base(); } + + template + inline constexpr bool + operator>(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() < __y.base(); } + + template + inline constexpr bool + operator<=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() >= __y.base(); } + + template + inline constexpr bool + operator>=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() <= __y.base(); } +# 575 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + inline constexpr auto + operator-(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + -> decltype(__y.base() - __x.base()) + { return __y.base() - __x.base(); } + + + template + inline constexpr reverse_iterator<_Iterator> + operator+(typename reverse_iterator<_Iterator>::difference_type __n, + const reverse_iterator<_Iterator>& __x) + { return reverse_iterator<_Iterator>(__x.base() - __n); } + + + + template + inline constexpr reverse_iterator<_Iterator> + __make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } + + + + + + + + template + inline constexpr reverse_iterator<_Iterator> + make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } +# 616 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + + auto + __niter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__niter_base(__it.base()))) + { return __make_reverse_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + : __is_move_iterator<_Iterator> + { }; + + template + + auto + __miter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__miter_base(__it.base()))) + { return __make_reverse_iterator(__miter_base(__it.base())); } +# 647 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + class back_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + + + + + + explicit + back_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 687 "/usr/include/c++/11/bits/stl_iterator.h" 3 + + back_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_back(__value); + return *this; + } + + + back_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_back(std::move(__value)); + return *this; + } + + + + + back_insert_iterator& + operator*() + { return *this; } + + + + back_insert_iterator& + operator++() + { return *this; } + + + + back_insert_iterator + operator++(int) + { return *this; } + }; +# 734 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + + inline back_insert_iterator<_Container> + back_inserter(_Container& __x) + { return back_insert_iterator<_Container>(__x); } +# 750 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + class front_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + + + + + + explicit + front_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 790 "/usr/include/c++/11/bits/stl_iterator.h" 3 + + front_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_front(__value); + return *this; + } + + + front_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_front(std::move(__value)); + return *this; + } + + + + + front_insert_iterator& + operator*() + { return *this; } + + + + front_insert_iterator& + operator++() + { return *this; } + + + + front_insert_iterator + operator++(int) + { return *this; } + }; +# 837 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + + inline front_insert_iterator<_Container> + front_inserter(_Container& __x) + { return front_insert_iterator<_Container>(__x); } +# 857 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + class insert_iterator + : public iterator + { + + + + + + + + typedef typename _Container::iterator _Iter; + + protected: + _Container* container; + _Iter iter; + + + public: + + typedef _Container container_type; +# 889 "/usr/include/c++/11/bits/stl_iterator.h" 3 + + insert_iterator(_Container& __x, _Iter __i) + : container(std::__addressof(__x)), iter(__i) {} +# 925 "/usr/include/c++/11/bits/stl_iterator.h" 3 + + insert_iterator& + operator=(const typename _Container::value_type& __value) + { + iter = container->insert(iter, __value); + ++iter; + return *this; + } + + + insert_iterator& + operator=(typename _Container::value_type&& __value) + { + iter = container->insert(iter, std::move(__value)); + ++iter; + return *this; + } + + + + + insert_iterator& + operator*() + { return *this; } + + + + insert_iterator& + operator++() + { return *this; } + + + + insert_iterator& + operator++(int) + { return *this; } + }; +# 981 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + inline insert_iterator<_Container> + inserter(_Container& __x, typename _Container::iterator __i) + { return insert_iterator<_Container>(__x, __i); } + + + + + +} + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 1003 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + class __normal_iterator + { + protected: + _Iterator _M_current; + + typedef std::iterator_traits<_Iterator> __traits_type; + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; + typedef typename __traits_type::pointer pointer; + + + + + + constexpr __normal_iterator() noexcept + : _M_current(_Iterator()) { } + + explicit + __normal_iterator(const _Iterator& __i) noexcept + : _M_current(__i) { } + + + template + + __normal_iterator(const __normal_iterator<_Iter, + typename __enable_if< + (std::__are_same<_Iter, typename _Container::pointer>::__value), + _Container>::__type>& __i) noexcept + : _M_current(__i.base()) { } + + + + reference + operator*() const noexcept + { return *_M_current; } + + + pointer + operator->() const noexcept + { return _M_current; } + + + __normal_iterator& + operator++() noexcept + { + ++_M_current; + return *this; + } + + + __normal_iterator + operator++(int) noexcept + { return __normal_iterator(_M_current++); } + + + + __normal_iterator& + operator--() noexcept + { + --_M_current; + return *this; + } + + + __normal_iterator + operator--(int) noexcept + { return __normal_iterator(_M_current--); } + + + + reference + operator[](difference_type __n) const noexcept + { return _M_current[__n]; } + + + __normal_iterator& + operator+=(difference_type __n) noexcept + { _M_current += __n; return *this; } + + + __normal_iterator + operator+(difference_type __n) const noexcept + { return __normal_iterator(_M_current + __n); } + + + __normal_iterator& + operator-=(difference_type __n) noexcept + { _M_current -= __n; return *this; } + + + __normal_iterator + operator-(difference_type __n) const noexcept + { return __normal_iterator(_M_current - __n); } + + + const _Iterator& + base() const noexcept + { return _M_current; } + }; +# 1152 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + + inline bool + operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + + inline bool + operator==(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + + inline bool + operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + template + + inline bool + operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + + template + inline bool + operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + + inline bool + operator<(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + inline bool + operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + + inline bool + operator>(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + inline bool + operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + + inline bool + operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + inline bool + operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + template + + inline bool + operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + + + + + + template + + + + inline auto + operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept + -> decltype(__lhs.base() - __rhs.base()) + + + + + + { return __lhs.base() - __rhs.base(); } + + template + + inline typename __normal_iterator<_Iterator, _Container>::difference_type + operator-(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() - __rhs.base(); } + + template + + inline __normal_iterator<_Iterator, _Container> + operator+(typename __normal_iterator<_Iterator, _Container>::difference_type + __n, const __normal_iterator<_Iterator, _Container>& __i) + noexcept + { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); } + + +} + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + + _Iterator + __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it.base(); } +# 1342 "/usr/include/c++/11/bits/stl_iterator.h" 3 + namespace __detail + { +# 1358 "/usr/include/c++/11/bits/stl_iterator.h" 3 + } +# 1369 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + class move_iterator + + + + { + _Iterator _M_current; + + using __traits_type = iterator_traits<_Iterator>; + + using __base_ref = typename __traits_type::reference; + + + template + friend class move_iterator; +# 1408 "/usr/include/c++/11/bits/stl_iterator.h" 3 + public: + using iterator_type = _Iterator; +# 1422 "/usr/include/c++/11/bits/stl_iterator.h" 3 + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + + typedef _Iterator pointer; + + + typedef typename conditional::value, + typename remove_reference<__base_ref>::type&&, + __base_ref>::type reference; + + + constexpr + move_iterator() + : _M_current() { } + + explicit constexpr + move_iterator(iterator_type __i) + : _M_current(std::move(__i)) { } + + template + + + + constexpr + move_iterator(const move_iterator<_Iter>& __i) + : _M_current(__i._M_current) { } + + template + + + + + constexpr + move_iterator& operator=(const move_iterator<_Iter>& __i) + { + _M_current = __i._M_current; + return *this; + } + + + constexpr iterator_type + base() const + { return _M_current; } +# 1476 "/usr/include/c++/11/bits/stl_iterator.h" 3 + constexpr reference + operator*() const + + + + { return static_cast(*_M_current); } + + + constexpr pointer + operator->() const + { return _M_current; } + + constexpr move_iterator& + operator++() + { + ++_M_current; + return *this; + } + + constexpr move_iterator + operator++(int) + { + move_iterator __tmp = *this; + ++_M_current; + return __tmp; + } + + + + + + + + constexpr move_iterator& + operator--() + { + --_M_current; + return *this; + } + + constexpr move_iterator + operator--(int) + { + move_iterator __tmp = *this; + --_M_current; + return __tmp; + } + + constexpr move_iterator + operator+(difference_type __n) const + { return move_iterator(_M_current + __n); } + + constexpr move_iterator& + operator+=(difference_type __n) + { + _M_current += __n; + return *this; + } + + constexpr move_iterator + operator-(difference_type __n) const + { return move_iterator(_M_current - __n); } + + constexpr move_iterator& + operator-=(difference_type __n) + { + _M_current -= __n; + return *this; + } + + constexpr reference + operator[](difference_type __n) const + + + + { return std::move(_M_current[__n]); } +# 1581 "/usr/include/c++/11/bits/stl_iterator.h" 3 + }; + + template + inline constexpr bool + operator==(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() == __y.base(); } +# 1600 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + inline constexpr bool + operator!=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return !(__x == __y); } + + + template + inline constexpr bool + operator<(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() < __y.base(); } + + template + inline constexpr bool + operator<=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__y < __x); } + + template + inline constexpr bool + operator>(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __y < __x; } + + template + inline constexpr bool + operator>=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__x < __y); } + + + + + template + inline constexpr bool + operator==(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } +# 1659 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + inline constexpr bool + operator!=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + inline constexpr bool + operator<(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() < __y.base(); } + + template + inline constexpr bool + operator<=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + inline constexpr bool + operator>(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __y < __x; } + + template + inline constexpr bool + operator>=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + template + inline constexpr auto + operator-(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + -> decltype(__x.base() - __y.base()) + { return __x.base() - __y.base(); } + + template + inline constexpr move_iterator<_Iterator> + operator+(typename move_iterator<_Iterator>::difference_type __n, + const move_iterator<_Iterator>& __x) + { return __x + __n; } + + template + inline constexpr move_iterator<_Iterator> + make_move_iterator(_Iterator __i) + { return move_iterator<_Iterator>(std::move(__i)); } + + template::value_type>::value, + _Iterator, move_iterator<_Iterator>>::type> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Iterator __i) + { return _ReturnType(__i); } + + + + template::value, + const _Tp*, move_iterator<_Tp*>>::type> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Tp* __i) + { return _ReturnType(__i); } +# 2447 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + + auto + __niter_base(move_iterator<_Iterator> __it) + -> decltype(make_move_iterator(__niter_base(__it.base()))) + { return make_move_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template + + auto + __miter_base(move_iterator<_Iterator> __it) + -> decltype(__miter_base(__it.base())) + { return __miter_base(__it.base()); } +# 2479 "/usr/include/c++/11/bits/stl_iterator.h" 3 + template + using __iter_key_t = remove_const_t< + typename iterator_traits<_InputIterator>::value_type::first_type>; + + template + using __iter_val_t = + typename iterator_traits<_InputIterator>::value_type::second_type; + + template + struct pair; + + template + using __iter_to_alloc_t = + pair>, + __iter_val_t<_InputIterator>>; + + + +} +# 68 "/usr/include/c++/11/bits/stl_algobase.h" 2 3 + +# 1 "/usr/include/c++/11/debug/debug.h" 1 3 +# 48 "/usr/include/c++/11/debug/debug.h" 3 +namespace std +{ + namespace __debug { } +} + + + + +namespace __gnu_debug +{ + using namespace std::__debug; + + template + struct _Safe_iterator; +} +# 70 "/usr/include/c++/11/bits/stl_algobase.h" 2 3 + +# 1 "/usr/include/c++/11/bits/predefined_ops.h" 1 3 +# 35 "/usr/include/c++/11/bits/predefined_ops.h" 3 +namespace __gnu_cxx +{ +namespace __ops +{ + struct _Iter_less_iter + { + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 < *__it2; } + }; + + constexpr + inline _Iter_less_iter + __iter_less_iter() + { return _Iter_less_iter(); } + + struct _Iter_less_val + { + + constexpr _Iter_less_val() = default; + + + + + + explicit + _Iter_less_val(_Iter_less_iter) { } + + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it < __val; } + }; + + + inline _Iter_less_val + __iter_less_val() + { return _Iter_less_val(); } + + + inline _Iter_less_val + __iter_comp_val(_Iter_less_iter) + { return _Iter_less_val(); } + + struct _Val_less_iter + { + + constexpr _Val_less_iter() = default; + + + + + + explicit + _Val_less_iter(_Iter_less_iter) { } + + template + + bool + operator()(_Value& __val, _Iterator __it) const + { return __val < *__it; } + }; + + + inline _Val_less_iter + __val_less_iter() + { return _Val_less_iter(); } + + + inline _Val_less_iter + __val_comp_iter(_Iter_less_iter) + { return _Val_less_iter(); } + + struct _Iter_equal_to_iter + { + template + + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 == *__it2; } + }; + + + inline _Iter_equal_to_iter + __iter_equal_to_iter() + { return _Iter_equal_to_iter(); } + + struct _Iter_equal_to_val + { + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it == __val; } + }; + + + inline _Iter_equal_to_val + __iter_equal_to_val() + { return _Iter_equal_to_val(); } + + + inline _Iter_equal_to_val + __iter_comp_val(_Iter_equal_to_iter) + { return _Iter_equal_to_val(); } + + template + struct _Iter_comp_iter + { + _Compare _M_comp; + + explicit constexpr + _Iter_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) + { return bool(_M_comp(*__it1, *__it2)); } + }; + + template + constexpr + inline _Iter_comp_iter<_Compare> + __iter_comp_iter(_Compare __comp) + { return _Iter_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_comp_val + { + _Compare _M_comp; + + + explicit + _Iter_comp_val(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Iterator __it, _Value& __val) + { return bool(_M_comp(*__it, __val)); } + }; + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Compare __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Iter_comp_iter<_Compare> __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + struct _Val_comp_iter + { + _Compare _M_comp; + + + explicit + _Val_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Value& __val, _Iterator __it) + { return bool(_M_comp(__val, *__it)); } + }; + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Compare __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Iter_comp_iter<_Compare> __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_equals_val + { + _Value& _M_value; + + + explicit + _Iter_equals_val(_Value& __value) + : _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return *__it == _M_value; } + }; + + template + + inline _Iter_equals_val<_Value> + __iter_equals_val(_Value& __val) + { return _Iter_equals_val<_Value>(__val); } + + template + struct _Iter_equals_iter + { + _Iterator1 _M_it1; + + + explicit + _Iter_equals_iter(_Iterator1 __it1) + : _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return *__it2 == *_M_it1; } + }; + + template + + inline _Iter_equals_iter<_Iterator> + __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) + { return _Iter_equals_iter<_Iterator>(__it); } + + template + struct _Iter_pred + { + _Predicate _M_pred; + + + explicit + _Iter_pred(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_pred<_Predicate> + __pred_iter(_Predicate __pred) + { return _Iter_pred<_Predicate>(std::move(__pred)); } + + template + struct _Iter_comp_to_val + { + _Compare _M_comp; + _Value& _M_value; + + + _Iter_comp_to_val(_Compare __comp, _Value& __value) + : _M_comp(std::move(__comp)), _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_comp(*__it, _M_value)); } + }; + + template + _Iter_comp_to_val<_Compare, _Value> + + __iter_comp_val(_Compare __comp, _Value &__val) + { + return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val); + } + + template + struct _Iter_comp_to_iter + { + _Compare _M_comp; + _Iterator1 _M_it1; + + + _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) + : _M_comp(std::move(__comp)), _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return bool(_M_comp(*__it2, *_M_it1)); } + }; + + template + + inline _Iter_comp_to_iter<_Compare, _Iterator> + __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) + { + return _Iter_comp_to_iter<_Compare, _Iterator>( + std::move(__comp._M_comp), __it); + } + + template + struct _Iter_negate + { + _Predicate _M_pred; + + + explicit + _Iter_negate(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return !bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_negate<_Predicate> + __negate(_Iter_pred<_Predicate> __pred) + { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); } + +} +} +# 72 "/usr/include/c++/11/bits/stl_algobase.h" 2 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + template + constexpr + inline int + __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num) + { + + static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp"); +# 105 "/usr/include/c++/11/bits/stl_algobase.h" 3 + return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); + } +# 149 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline void + iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) + { + + + + +# 182 "/usr/include/c++/11/bits/stl_algobase.h" 3 + swap(*__a, *__b); + + } +# 198 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + _ForwardIterator2 + swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + std::iter_swap(__first1, __first2); + return __first2; + } +# 227 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b) + { + + + + if (__b < __a) + return __b; + return __a; + } +# 251 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b) + { + + + + if (__a < __b) + return __b; + return __a; + } +# 275 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__b, __a)) + return __b; + return __a; + } +# 297 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__a, __b)) + return __b; + return __a; + } + + + + template + + inline _Iterator + __niter_base(_Iterator __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it; } + + template + _Ite + __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, + std::random_access_iterator_tag>&); + + + + + template + + inline _From + __niter_wrap(_From __from, _To __res) + { return __from + (__res - std::__niter_base(__from)); } + + + template + + inline _Iterator + __niter_wrap(const _Iterator&, _Iterator __res) + { return __res; } + + + + + + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = *__first; + return __result; + } + }; + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = std::move(*__first); + return __result; + } + }; + + + template<> + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = *__first; + ++__first; + ++__result; + } + return __result; + } + }; + + + template<> + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = std::move(*__first); + ++__first; + ++__result; + } + return __result; + } + }; + + + template + struct __copy_move<_IsMove, true, random_access_iterator_tag> + { + template + + static _Tp* + __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result) + { + + using __assignable = conditional<_IsMove, + is_move_assignable<_Tp>, + is_copy_assignable<_Tp>>; + + static_assert( __assignable::type::value, "type is not assignable" ); + + const ptrdiff_t _Num = __last - __first; + if (_Num) + __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); + return __result + _Num; + } + }; + + + + template + struct _Deque_iterator; + + struct _Bit_iterator; + + + + + + template + struct char_traits; + + template + class istreambuf_iterator; + + template + class ostreambuf_iterator; + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(_CharT*, _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(const _CharT*, const _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + _CharT*>::__type + __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*); + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, + std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type + __copy_move_a2( + istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, + std::_Deque_iterator<_CharT, _CharT&, _CharT*>); + + template + + inline _OI + __copy_move_a2(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::iterator_category _Category; + + + + + + return std::__copy_move<_IsMove, __memcpyable<_OI, _II>::__value, + _Category>::__copy_m(__first, __last, __result); + } + + template + _OI + __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _OI); + + template + std::_Deque_iterator<_OTp, _OTp&, _OTp*> + __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_OTp, _OTp&, _OTp*>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, + std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __copy_move_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + + inline _OI + __copy_move_a1(_II __first, _II __last, _OI __result) + { return std::__copy_move_a2<_IsMove>(__first, __last, __result); } + + template + + inline _OI + __copy_move_a(_II __first, _II __last, _OI __result) + { + return std::__niter_wrap(__result, + std::__copy_move_a1<_IsMove>(std::__niter_base(__first), + std::__niter_base(__last), + std::__niter_base(__result))); + } + + template + _OI + __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + _OI); + + template + __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __copy_move_a(_II, _II, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); + + template + ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> + __copy_move_a(const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); + + template + + _OutputIterator + __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result, + bool) + { + if (__n > 0) + { + while (true) + { + *__result = *__first; + ++__result; + if (--__n > 0) + ++__first; + else + break; + } + } + return __result; + } + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, _CharT*>::__type + __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, + _Size, _CharT*, bool); + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, + std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type + __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, _Size, + std::_Deque_iterator<_CharT, _CharT&, _CharT*>, + bool); +# 608 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline _OI + copy(_II __first, _II __last, _OI __result) + { + + + + + ; + + return std::__copy_move_a<__is_move_iterator<_II>::__value> + (std::__miter_base(__first), std::__miter_base(__last), __result); + } +# 641 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline _OI + move(_II __first, _II __last, _OI __result) + { + + + + + ; + + return std::__copy_move_a(std::__miter_base(__first), + std::__miter_base(__last), __result); + } + + + + + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = *--__last; + return __result; + } + }; + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = std::move(*--__last); + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type + __n = __last - __first; + for (; __n > 0; --__n) + *--__result = *--__last; + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type + __n = __last - __first; + for (; __n > 0; --__n) + *--__result = std::move(*--__last); + return __result; + } + }; + + + template + struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> + { + template + + static _Tp* + __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result) + { + + using __assignable = conditional<_IsMove, + is_move_assignable<_Tp>, + is_copy_assignable<_Tp>>; + + static_assert( __assignable::type::value, "type is not assignable" ); + + const ptrdiff_t _Num = __last - __first; + if (_Num) + __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); + return __result - _Num; + } + }; + + template + + inline _BI2 + __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) + { + typedef typename iterator_traits<_BI1>::iterator_category _Category; + + + + + + return std::__copy_move_backward<_IsMove, + __memcpyable<_BI2, _BI1>::__value, + _Category>::__copy_move_b(__first, + __last, + __result); + } + + template + + inline _BI2 + __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) + { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); } + + template + _OI + __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _OI); + + template + std::_Deque_iterator<_OTp, _OTp&, _OTp*> + __copy_move_backward_a1( + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_OTp, _OTp&, _OTp*>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, + std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __copy_move_backward_a1(_II, _II, + std::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + + inline _OI + __copy_move_backward_a(_II __first, _II __last, _OI __result) + { + return std::__niter_wrap(__result, + std::__copy_move_backward_a1<_IsMove> + (std::__niter_base(__first), std::__niter_base(__last), + std::__niter_base(__result))); + } + + template + _OI + __copy_move_backward_a( + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + _OI); + + template + __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __copy_move_backward_a(_II, _II, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); + + template + ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> + __copy_move_backward_a( + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); +# 845 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline _BI2 + copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + + ; + + return std::__copy_move_backward_a<__is_move_iterator<_BI1>::__value> + (std::__miter_base(__first), std::__miter_base(__last), __result); + } +# 881 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline _BI2 + move_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + + ; + + return std::__copy_move_backward_a(std::__miter_base(__first), + std::__miter_base(__last), + __result); + } + + + + + + + template + + inline typename + __gnu_cxx::__enable_if::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + for (; __first != __last; ++__first) + *__first = __value; + } + + template + + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + const _Tp __tmp = __value; + for (; __first != __last; ++__first) + *__first = __tmp; + } + + + template + + inline typename + __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type + __fill_a1(_Tp* __first, _Tp* __last, const _Tp& __c) + { + const _Tp __tmp = __c; +# 943 "/usr/include/c++/11/bits/stl_algobase.h" 3 + if (const size_t __len = __last - __first) + __builtin_memset(__first, static_cast(__tmp), __len); + } + + template + + inline void + __fill_a1(::__gnu_cxx::__normal_iterator<_Ite, _Cont> __first, + ::__gnu_cxx::__normal_iterator<_Ite, _Cont> __last, + const _Tp& __value) + { std::__fill_a1(__first.base(), __last.base(), __value); } + + template + void + __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const _VTp&); + + void + __fill_a1(std::_Bit_iterator, std::_Bit_iterator, + const bool&); + + template + + inline void + __fill_a(_FIte __first, _FIte __last, const _Tp& __value) + { std::__fill_a1(__first, __last, __value); } + + template + void + __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const _Tp&); +# 989 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline void + fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) + { + + + + ; + + std::__fill_a(__first, __last, __value); + } + + + inline constexpr int + __size_to_integer(int __n) { return __n; } + inline constexpr unsigned + __size_to_integer(unsigned __n) { return __n; } + inline constexpr long + __size_to_integer(long __n) { return __n; } + inline constexpr unsigned long + __size_to_integer(unsigned long __n) { return __n; } + inline constexpr long long + __size_to_integer(long long __n) { return __n; } + inline constexpr unsigned long long + __size_to_integer(unsigned long long __n) { return __n; } + + + inline constexpr __int128 + __size_to_integer(__int128 __n) { return __n; } + inline constexpr unsigned __int128 + __size_to_integer(unsigned __int128 __n) { return __n; } +# 1041 "/usr/include/c++/11/bits/stl_algobase.h" 3 + inline constexpr long long + __size_to_integer(float __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(double __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(long double __n) { return (long long)__n; } + + + + + + template + + inline typename + __gnu_cxx::__enable_if::__value, _OutputIterator>::__type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + for (; __n > 0; --__n, (void) ++__first) + *__first = __value; + return __first; + } + + template + + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + const _Tp __tmp = __value; + for (; __n > 0; --__n, (void) ++__first) + *__first = __tmp; + return __first; + } + + template + ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __first, + _Size __n, const _Tp& __value, + std::input_iterator_tag); + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::output_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + return __fill_n_a1(__first, __n, __value); + } + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::input_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + return __fill_n_a1(__first, __n, __value); + } + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::random_access_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + if (__n <= 0) + return __first; + + ; + + std::__fill_a(__first, __first + __n, __value); + return __first + __n; + } +# 1141 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline _OI + fill_n(_OI __first, _Size __n, const _Tp& __value) + { + + + + return std::__fill_n_a(__first, std::__size_to_integer(__n), __value, + std::__iterator_category(__first)); + } + + template + struct __equal + { + template + + static bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + for (; __first1 != __last1; ++__first1, (void) ++__first2) + if (!(*__first1 == *__first2)) + return false; + return true; + } + }; + + template<> + struct __equal + { + template + + static bool + equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2) + { + if (const size_t __len = (__last1 - __first1)) + return !std::__memcmp(__first1, __first2, __len); + return true; + } + }; + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, bool>::__type + __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _II); + + template + bool + __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, bool>::__type + __equal_aux1(_II, _II, + std::_Deque_iterator<_Tp, _Ref, _Ptr>); + + template + + inline bool + __equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + const bool __simple = ((__is_integer<_ValueType1>::__value + || __is_pointer<_ValueType1>::__value) + && __memcmpable<_II1, _II2>::__value); + return std::__equal<__simple>::equal(__first1, __last1, __first2); + } + + template + + inline bool + __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) + { + return std::__equal_aux1(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2)); + } + + template + bool + __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + _II2); + + template + bool + __equal_aux(_II1, _II1, + const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); + + template + bool + __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); + + template + struct __lc_rai + { + template + + static _II1 + __newlast1(_II1, _II1 __last1, _II2, _II2) + { return __last1; } + + template + + static bool + __cnd2(_II __first, _II __last) + { return __first != __last; } + }; + + template<> + struct __lc_rai + { + template + + static _RAI1 + __newlast1(_RAI1 __first1, _RAI1 __last1, + _RAI2 __first2, _RAI2 __last2) + { + const typename iterator_traits<_RAI1>::difference_type + __diff1 = __last1 - __first1; + const typename iterator_traits<_RAI2>::difference_type + __diff2 = __last2 - __first2; + return __diff2 < __diff1 ? __first1 + __diff2 : __last1; + } + + template + static bool + __cnd2(_RAI, _RAI) + { return true; } + }; + + template + + bool + __lexicographical_compare_impl(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, + _Compare __comp) + { + typedef typename iterator_traits<_II1>::iterator_category _Category1; + typedef typename iterator_traits<_II2>::iterator_category _Category2; + typedef std::__lc_rai<_Category1, _Category2> __rai_type; + + __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); + for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); + ++__first1, (void)++__first2) + { + if (__comp(__first1, __first2)) + return true; + if (__comp(__first2, __first1)) + return false; + } + return __first1 == __last1 && __first2 != __last2; + } + + template + struct __lexicographical_compare + { + template + + static bool + __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + using __gnu_cxx::__ops::__iter_less_iter; + return std::__lexicographical_compare_impl(__first1, __last1, + __first2, __last2, + __iter_less_iter()); + } + + template + + static int + __3way(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + while (__first1 != __last1) + { + if (__first2 == __last2) + return +1; + if (*__first1 < *__first2) + return -1; + if (*__first2 < *__first1) + return +1; + ++__first1; + ++__first2; + } + return int(__first2 == __last2) - 1; + } + }; + + template<> + struct __lexicographical_compare + { + template + + static bool + __lc(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { return __3way(__first1, __last1, __first2, __last2) < 0; } + + template + + static ptrdiff_t + __3way(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { + const size_t __len1 = __last1 - __first1; + const size_t __len2 = __last2 - __first2; + if (const size_t __len = std::min(__len1, __len2)) + if (int __result = std::__memcmp(__first1, __first2, __len)) + return __result; + return ptrdiff_t(__len1 - __len2); + } + }; + + template + + inline bool + __lexicographical_compare_aux1(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + typedef typename iterator_traits<_II2>::value_type _ValueType2; + const bool __simple = + (__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value + && __is_pointer<_II1>::__value + && __is_pointer<_II2>::__value + + + + + + + + ); + + return std::__lexicographical_compare<__simple>::__lc(__first1, __last1, + __first2, __last2); + } + + template + bool + __lexicographical_compare_aux1( + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + _Tp2*, _Tp2*); + + template + bool + __lexicographical_compare_aux1(_Tp1*, _Tp1*, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + bool + __lexicographical_compare_aux1( + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + + inline bool + __lexicographical_compare_aux(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + return std::__lexicographical_compare_aux1(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2), + std::__niter_base(__last2)); + } + + template + bool + __lexicographical_compare_aux( + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + _II2, _II2); + + template + bool + __lexicographical_compare_aux( + _II1, _II1, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); + + template + bool + __lexicographical_compare_aux( + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); + + template + + _ForwardIterator + __lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _DistanceType __len = std::distance(__first, __last); + + while (__len > 0) + { + _DistanceType __half = __len >> 1; + _ForwardIterator __middle = __first; + std::advance(__middle, __half); + if (__comp(__middle, __val)) + { + __first = __middle; + ++__first; + __len = __len - __half - 1; + } + else + __len = __half; + } + return __first; + } +# 1487 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline _ForwardIterator + lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + + + + + ; + + return std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val()); + } + + + + inline constexpr int + __lg(int __n) + { return (int)sizeof(int) * 8 - 1 - __builtin_clz(__n); } + + inline constexpr unsigned + __lg(unsigned __n) + { return (int)sizeof(int) * 8 - 1 - __builtin_clz(__n); } + + inline constexpr long + __lg(long __n) + { return (int)sizeof(long) * 8 - 1 - __builtin_clzl(__n); } + + inline constexpr unsigned long + __lg(unsigned long __n) + { return (int)sizeof(long) * 8 - 1 - __builtin_clzl(__n); } + + inline constexpr long long + __lg(long long __n) + { return (int)sizeof(long long) * 8 - 1 - __builtin_clzll(__n); } + + inline constexpr unsigned long long + __lg(unsigned long long __n) + { return (int)sizeof(long long) * 8 - 1 - __builtin_clzll(__n); } + + +# 1543 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + + + + + + + ; + + return std::__equal_aux(__first1, __last1, __first2); + } +# 1574 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _BinaryPredicate __binary_pred) + { + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return true; + } + + + + template + + inline bool + __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_II1>::iterator_category; + using _Cat2 = typename iterator_traits<_II2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if (_RAIters()) + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 != __d2) + return false; + return std::equal(__first1, __last1, __first2); + } + + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!(*__first1 == *__first2)) + return false; + return __first1 == __last1 && __first2 == __last2; + } + + + template + + inline bool + __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, + _BinaryPredicate __binary_pred) + { + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_II1>::iterator_category; + using _Cat2 = typename iterator_traits<_II2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if (_RAIters()) + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 != __d2) + return false; + return std::equal(__first1, __last1, __first2, + __binary_pred); + } + + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return __first1 == __last1 && __first2 == __last2; + } +# 1664 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + + + + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2); + } +# 1697 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2, + __binary_pred); + } +# 1729 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + + + + + + + + + + ; + ; + + return std::__lexicographical_compare_aux(__first1, __last1, + __first2, __last2); + } +# 1764 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, _Compare __comp) + { + + + + ; + ; + + return std::__lexicographical_compare_impl + (__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 1877 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 1905 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2) + { + + + + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 1939 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + template + + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __first2 != __last2 + && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 1988 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2) + { + + + + + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 2024 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + + + template + + inline _InputIterator + __find_if(_InputIterator __first, _InputIterator __last, + _Predicate __pred, input_iterator_tag) + { + while (__first != __last && !__pred(__first)) + ++__first; + return __first; + } + + + template + + _RandomAccessIterator + __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Predicate __pred, random_access_iterator_tag) + { + typename iterator_traits<_RandomAccessIterator>::difference_type + __trip_count = (__last - __first) >> 2; + + for (; __trip_count > 0; --__trip_count) + { + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + } + + switch (__last - __first) + { + case 3: + if (__pred(__first)) + return __first; + ++__first; + + case 2: + if (__pred(__first)) + return __first; + ++__first; + + case 1: + if (__pred(__first)) + return __first; + ++__first; + + case 0: + default: + return __last; + } + } + + template + + inline _Iterator + __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) + { + return __find_if(__first, __last, __pred, + std::__iterator_category(__first)); + } + + template + + typename iterator_traits<_InputIterator>::difference_type + __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { + typename iterator_traits<_InputIterator>::difference_type __n = 0; + for (; __first != __last; ++__first) + if (__pred(__first)) + ++__n; + return __n; + } + + + template + + bool + __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _BinaryPredicate __pred) + { + + + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!__pred(__first1, __first2)) + break; + + if (__first1 == __last1) + return true; + + + + _ForwardIterator2 __last2 = __first2; + std::advance(__last2, std::distance(__first1, __last1)); + for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) + { + if (__scan != std::__find_if(__first1, __scan, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) + continue; + + auto __matches + = std::__count_if(__first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); + if (0 == __matches || + std::__count_if(__scan, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) + != __matches) + return false; + } + return true; + } +# 2181 "/usr/include/c++/11/bits/stl_algobase.h" 3 + template + + inline bool + is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + + ; + + return std::__is_permutation(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } + + + +} +# 46 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/limits" 1 3 +# 40 "/usr/include/c++/11/limits" 3 + +# 41 "/usr/include/c++/11/limits" 3 +# 158 "/usr/include/c++/11/limits" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + enum float_round_style + { + round_indeterminate = -1, + round_toward_zero = 0, + round_to_nearest = 1, + round_toward_infinity = 2, + round_toward_neg_infinity = 3 + }; + + + + + + + + enum float_denorm_style + { + + denorm_indeterminate = -1, + + denorm_absent = 0, + + denorm_present = 1 + }; +# 202 "/usr/include/c++/11/limits" 3 + struct __numeric_limits_base + { + + + static constexpr bool is_specialized = false; + + + + + static constexpr int digits = 0; + + + static constexpr int digits10 = 0; + + + + + static constexpr int max_digits10 = 0; + + + + static constexpr bool is_signed = false; + + + static constexpr bool is_integer = false; + + + + + static constexpr bool is_exact = false; + + + + static constexpr int radix = 0; + + + + static constexpr int min_exponent = 0; + + + + static constexpr int min_exponent10 = 0; + + + + + static constexpr int max_exponent = 0; + + + + static constexpr int max_exponent10 = 0; + + + static constexpr bool has_infinity = false; + + + + static constexpr bool has_quiet_NaN = false; + + + + static constexpr bool has_signaling_NaN = false; + + + static constexpr float_denorm_style has_denorm = denorm_absent; + + + + static constexpr bool has_denorm_loss = false; + + + + static constexpr bool is_iec559 = false; + + + + + static constexpr bool is_bounded = false; +# 288 "/usr/include/c++/11/limits" 3 + static constexpr bool is_modulo = false; + + + static constexpr bool traps = false; + + + static constexpr bool tinyness_before = false; + + + + + static constexpr float_round_style round_style = + round_toward_zero; + }; +# 311 "/usr/include/c++/11/limits" 3 + template + struct numeric_limits : public __numeric_limits_base + { + + + static constexpr _Tp + min() noexcept { return _Tp(); } + + + static constexpr _Tp + max() noexcept { return _Tp(); } + + + + + static constexpr _Tp + lowest() noexcept { return _Tp(); } + + + + + static constexpr _Tp + epsilon() noexcept { return _Tp(); } + + + static constexpr _Tp + round_error() noexcept { return _Tp(); } + + + static constexpr _Tp + infinity() noexcept { return _Tp(); } + + + + static constexpr _Tp + quiet_NaN() noexcept { return _Tp(); } + + + + static constexpr _Tp + signaling_NaN() noexcept { return _Tp(); } + + + + + static constexpr _Tp + denorm_min() noexcept { return _Tp(); } + }; + + + + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; +# 383 "/usr/include/c++/11/limits" 3 + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr bool + min() noexcept { return false; } + + static constexpr bool + max() noexcept { return true; } + + + static constexpr bool + lowest() noexcept { return min(); } + + static constexpr int digits = 1; + static constexpr int digits10 = 0; + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr bool + epsilon() noexcept { return false; } + + static constexpr bool + round_error() noexcept { return false; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr bool + infinity() noexcept { return false; } + + static constexpr bool + quiet_NaN() noexcept { return false; } + + static constexpr bool + signaling_NaN() noexcept { return false; } + + static constexpr bool + denorm_min() noexcept { return false; } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + + + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr char + min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); } + + static constexpr char + max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); } + + + static constexpr char + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0)); + static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = ((char)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr char + epsilon() noexcept { return 0; } + + static constexpr char + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr + char infinity() noexcept { return char(); } + + static constexpr char + quiet_NaN() noexcept { return char(); } + + static constexpr char + signaling_NaN() noexcept { return char(); } + + static constexpr char + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr signed char + min() noexcept { return -0x7f - 1; } + + static constexpr signed char + max() noexcept { return 0x7f; } + + + static constexpr signed char + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr signed char + epsilon() noexcept { return 0; } + + static constexpr signed char + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr signed char + infinity() noexcept { return static_cast(0); } + + static constexpr signed char + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr signed char + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr signed char + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned char + min() noexcept { return 0; } + + static constexpr unsigned char + max() noexcept { return 0x7f * 2U + 1; } + + + static constexpr unsigned char + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned char + epsilon() noexcept { return 0; } + + static constexpr unsigned char + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned char + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned char + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned char + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned char + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr wchar_t + min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); } + + static constexpr wchar_t + max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); } + + + static constexpr wchar_t + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = ((wchar_t)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr wchar_t + epsilon() noexcept { return 0; } + + static constexpr wchar_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr wchar_t + infinity() noexcept { return wchar_t(); } + + static constexpr wchar_t + quiet_NaN() noexcept { return wchar_t(); } + + static constexpr wchar_t + signaling_NaN() noexcept { return wchar_t(); } + + static constexpr wchar_t + denorm_min() noexcept { return wchar_t(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; +# 796 "/usr/include/c++/11/limits" 3 + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr char16_t + min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); } + + static constexpr char16_t + max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); } + + static constexpr char16_t + lowest() noexcept { return min(); } + + static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)); + static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136); + static constexpr int max_digits10 = 0; + static constexpr bool is_signed = ((char16_t)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr char16_t + epsilon() noexcept { return 0; } + + static constexpr char16_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr char16_t + infinity() noexcept { return char16_t(); } + + static constexpr char16_t + quiet_NaN() noexcept { return char16_t(); } + + static constexpr char16_t + signaling_NaN() noexcept { return char16_t(); } + + static constexpr char16_t + denorm_min() noexcept { return char16_t(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr char32_t + min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); } + + static constexpr char32_t + max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); } + + static constexpr char32_t + lowest() noexcept { return min(); } + + static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)); + static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136); + static constexpr int max_digits10 = 0; + static constexpr bool is_signed = ((char32_t)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr char32_t + epsilon() noexcept { return 0; } + + static constexpr char32_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr char32_t + infinity() noexcept { return char32_t(); } + + static constexpr char32_t + quiet_NaN() noexcept { return char32_t(); } + + static constexpr char32_t + signaling_NaN() noexcept { return char32_t(); } + + static constexpr char32_t + denorm_min() noexcept { return char32_t(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style = round_toward_zero; + }; + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr short + min() noexcept { return -0x7fff - 1; } + + static constexpr short + max() noexcept { return 0x7fff; } + + + static constexpr short + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0)); + static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr short + epsilon() noexcept { return 0; } + + static constexpr short + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr short + infinity() noexcept { return short(); } + + static constexpr short + quiet_NaN() noexcept { return short(); } + + static constexpr short + signaling_NaN() noexcept { return short(); } + + static constexpr short + denorm_min() noexcept { return short(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned short + min() noexcept { return 0; } + + static constexpr unsigned short + max() noexcept { return 0x7fff * 2U + 1; } + + + static constexpr unsigned short + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned short + epsilon() noexcept { return 0; } + + static constexpr unsigned short + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned short + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned short + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned short + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned short + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr int + min() noexcept { return -0x7fffffff - 1; } + + static constexpr int + max() noexcept { return 0x7fffffff; } + + + static constexpr int + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0)); + static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr int + epsilon() noexcept { return 0; } + + static constexpr int + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr int + infinity() noexcept { return static_cast(0); } + + static constexpr int + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr int + signaling_NaN() noexcept { return static_cast(0); } + + static constexpr int + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned int + min() noexcept { return 0; } + + static constexpr unsigned int + max() noexcept { return 0x7fffffff * 2U + 1; } + + + static constexpr unsigned int + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned int + epsilon() noexcept { return 0; } + + static constexpr unsigned int + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned int + infinity() noexcept { return static_cast(0); } + + static constexpr unsigned int + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned int + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned int + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr long + min() noexcept { return -0x7fffffffffffffffL - 1; } + + static constexpr long + max() noexcept { return 0x7fffffffffffffffL; } + + + static constexpr long + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0)); + static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr long + epsilon() noexcept { return 0; } + + static constexpr long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr long + infinity() noexcept { return static_cast(0); } + + static constexpr long + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr long + signaling_NaN() noexcept { return static_cast(0); } + + static constexpr long + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned long + min() noexcept { return 0; } + + static constexpr unsigned long + max() noexcept { return 0x7fffffffffffffffL * 2UL + 1; } + + + static constexpr unsigned long + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned long + epsilon() noexcept { return 0; } + + static constexpr unsigned long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned long + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned long + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr long long + min() noexcept { return -0x7fffffffffffffffLL - 1; } + + static constexpr long long + max() noexcept { return 0x7fffffffffffffffLL; } + + + static constexpr long long + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(long long) * 8 - ((long long)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr long long + epsilon() noexcept { return 0; } + + static constexpr long long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr long long + infinity() noexcept { return static_cast(0); } + + static constexpr long long + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr long long + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr long long + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned long long + min() noexcept { return 0; } + + static constexpr unsigned long long + max() noexcept { return 0x7fffffffffffffffLL * 2ULL + 1; } + + + static constexpr unsigned long long + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned long long + epsilon() noexcept { return 0; } + + static constexpr unsigned long long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned long long + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned long long + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long long + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long long + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; +# 1635 "/usr/include/c++/11/limits" 3 + template<> struct numeric_limits<__int128> { static constexpr bool is_specialized = true; static constexpr __int128 min() noexcept { return (((__int128)(-1) < 0) ? -(((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0) - 1 : (__int128)0); } static constexpr __int128 max() noexcept { return (((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0); } static constexpr int digits = 128 - 1; static constexpr int digits10 = (128 - 1) * 643L / 2136; static constexpr bool is_signed = true; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr __int128 epsilon() noexcept { return 0; } static constexpr __int128 round_error() noexcept { return 0; } static constexpr __int128 lowest() noexcept { return min(); } static constexpr int max_digits10 = 0; static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr __int128 infinity() noexcept { return static_cast<__int128>(0); } static constexpr __int128 quiet_NaN() noexcept { return static_cast<__int128>(0); } static constexpr __int128 signaling_NaN() noexcept { return static_cast<__int128>(0); } static constexpr __int128 denorm_min() noexcept { return static_cast<__int128>(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr unsigned __int128 min() noexcept { return 0; } static constexpr unsigned __int128 max() noexcept { return (((unsigned __int128)(-1) < 0) ? (((((unsigned __int128)1 << ((128 - ((unsigned __int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(unsigned __int128)0); } static constexpr unsigned __int128 lowest() noexcept { return min(); } static constexpr int max_digits10 = 0; static constexpr int digits = 128; static constexpr int digits10 = 128 * 643L / 2136; static constexpr bool is_signed = false; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr unsigned __int128 epsilon() noexcept { return 0; } static constexpr unsigned __int128 round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr unsigned __int128 infinity() noexcept { return static_cast(0); } static constexpr unsigned __int128 quiet_NaN() noexcept { return static_cast(0); } static constexpr unsigned __int128 signaling_NaN() noexcept { return static_cast(0); } static constexpr unsigned __int128 denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = true; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; +# 1667 "/usr/include/c++/11/limits" 3 + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr float + min() noexcept { return 1.17549435082228750796873653722224568e-38F; } + + static constexpr float + max() noexcept { return 3.40282346638528859811704183484516925e+38F; } + + + static constexpr float + lowest() noexcept { return -3.40282346638528859811704183484516925e+38F; } + + + static constexpr int digits = 24; + static constexpr int digits10 = 6; + + static constexpr int max_digits10 + = (2 + (24) * 643L / 2136); + + static constexpr bool is_signed = true; + static constexpr bool is_integer = false; + static constexpr bool is_exact = false; + static constexpr int radix = 2; + + static constexpr float + epsilon() noexcept { return 1.19209289550781250000000000000000000e-7F; } + + static constexpr float + round_error() noexcept { return 0.5F; } + + static constexpr int min_exponent = (-125); + static constexpr int min_exponent10 = (-37); + static constexpr int max_exponent = 128; + static constexpr int max_exponent10 = 38; + + static constexpr bool has_infinity = 1; + static constexpr bool has_quiet_NaN = 1; + static constexpr bool has_signaling_NaN = has_quiet_NaN; + static constexpr float_denorm_style has_denorm + = bool(1) ? denorm_present : denorm_absent; + static constexpr bool has_denorm_loss + = false; + + static constexpr float + infinity() noexcept { return __builtin_huge_valf(); } + + static constexpr float + quiet_NaN() noexcept { return __builtin_nanf(""); } + + static constexpr float + signaling_NaN() noexcept { return __builtin_nansf(""); } + + static constexpr float + denorm_min() noexcept { return 1.40129846432481707092372958328991613e-45F; } + + static constexpr bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = false; + static constexpr bool tinyness_before + = false; + static constexpr float_round_style round_style + = round_to_nearest; + }; + + + + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr double + min() noexcept { return double(2.22507385850720138309023271733240406e-308L); } + + static constexpr double + max() noexcept { return double(1.79769313486231570814527423731704357e+308L); } + + + static constexpr double + lowest() noexcept { return -double(1.79769313486231570814527423731704357e+308L); } + + + static constexpr int digits = 53; + static constexpr int digits10 = 15; + + static constexpr int max_digits10 + = (2 + (53) * 643L / 2136); + + static constexpr bool is_signed = true; + static constexpr bool is_integer = false; + static constexpr bool is_exact = false; + static constexpr int radix = 2; + + static constexpr double + epsilon() noexcept { return double(2.22044604925031308084726333618164062e-16L); } + + static constexpr double + round_error() noexcept { return 0.5; } + + static constexpr int min_exponent = (-1021); + static constexpr int min_exponent10 = (-307); + static constexpr int max_exponent = 1024; + static constexpr int max_exponent10 = 308; + + static constexpr bool has_infinity = 1; + static constexpr bool has_quiet_NaN = 1; + static constexpr bool has_signaling_NaN = has_quiet_NaN; + static constexpr float_denorm_style has_denorm + = bool(1) ? denorm_present : denorm_absent; + static constexpr bool has_denorm_loss + = false; + + static constexpr double + infinity() noexcept { return __builtin_huge_val(); } + + static constexpr double + quiet_NaN() noexcept { return __builtin_nan(""); } + + static constexpr double + signaling_NaN() noexcept { return __builtin_nans(""); } + + static constexpr double + denorm_min() noexcept { return double(4.94065645841246544176568792868221372e-324L); } + + static constexpr bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = false; + static constexpr bool tinyness_before + = false; + static constexpr float_round_style round_style + = round_to_nearest; + }; + + + + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr long double + min() noexcept { return 3.36210314311209350626267781732175260e-4932L; } + + static constexpr long double + max() noexcept { return 1.18973149535723176502126385303097021e+4932L; } + + + static constexpr long double + lowest() noexcept { return -1.18973149535723176502126385303097021e+4932L; } + + + static constexpr int digits = 64; + static constexpr int digits10 = 18; + + static constexpr int max_digits10 + = (2 + (64) * 643L / 2136); + + static constexpr bool is_signed = true; + static constexpr bool is_integer = false; + static constexpr bool is_exact = false; + static constexpr int radix = 2; + + static constexpr long double + epsilon() noexcept { return 1.08420217248550443400745280086994171e-19L; } + + static constexpr long double + round_error() noexcept { return 0.5L; } + + static constexpr int min_exponent = (-16381); + static constexpr int min_exponent10 = (-4931); + static constexpr int max_exponent = 16384; + static constexpr int max_exponent10 = 4932; + + static constexpr bool has_infinity = 1; + static constexpr bool has_quiet_NaN = 1; + static constexpr bool has_signaling_NaN = has_quiet_NaN; + static constexpr float_denorm_style has_denorm + = bool(1) ? denorm_present : denorm_absent; + static constexpr bool has_denorm_loss + = false; + + static constexpr long double + infinity() noexcept { return __builtin_huge_vall(); } + + static constexpr long double + quiet_NaN() noexcept { return __builtin_nanl(""); } + + static constexpr long double + signaling_NaN() noexcept { return __builtin_nansl(""); } + + static constexpr long double + denorm_min() noexcept { return 3.64519953188247460252840593361941982e-4951L; } + + static constexpr bool is_iec559 + = has_infinity && has_quiet_NaN && has_denorm == denorm_present; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = false; + static constexpr bool tinyness_before = + false; + static constexpr float_round_style round_style = + round_to_nearest; + }; + + + + + + +} +# 47 "/usr/include/c++/11/bits/specfun.h" 2 3 + + +# 1 "/usr/include/c++/11/tr1/gamma.tcc" 1 3 +# 49 "/usr/include/c++/11/tr1/gamma.tcc" 3 +# 1 "/usr/include/c++/11/tr1/special_function_util.h" 1 3 +# 39 "/usr/include/c++/11/tr1/special_function_util.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 50 "/usr/include/c++/11/tr1/special_function_util.h" 3 + namespace __detail + { + + + + template + struct __floating_point_constant + { + static const _Tp __value; + }; + + + + template + struct __numeric_constants + { + + static _Tp __pi() throw() + { return static_cast<_Tp>(3.1415926535897932384626433832795029L); } + + static _Tp __pi_2() throw() + { return static_cast<_Tp>(1.5707963267948966192313216916397514L); } + + static _Tp __pi_3() throw() + { return static_cast<_Tp>(1.0471975511965977461542144610931676L); } + + static _Tp __pi_4() throw() + { return static_cast<_Tp>(0.7853981633974483096156608458198757L); } + + static _Tp __1_pi() throw() + { return static_cast<_Tp>(0.3183098861837906715377675267450287L); } + + static _Tp __2_sqrtpi() throw() + { return static_cast<_Tp>(1.1283791670955125738961589031215452L); } + + static _Tp __sqrt2() throw() + { return static_cast<_Tp>(1.4142135623730950488016887242096981L); } + + static _Tp __sqrt3() throw() + { return static_cast<_Tp>(1.7320508075688772935274463415058723L); } + + static _Tp __sqrtpio2() throw() + { return static_cast<_Tp>(1.2533141373155002512078826424055226L); } + + static _Tp __sqrt1_2() throw() + { return static_cast<_Tp>(0.7071067811865475244008443621048490L); } + + static _Tp __lnpi() throw() + { return static_cast<_Tp>(1.1447298858494001741434273513530587L); } + + static _Tp __gamma_e() throw() + { return static_cast<_Tp>(0.5772156649015328606065120900824024L); } + + static _Tp __euler() throw() + { return static_cast<_Tp>(2.7182818284590452353602874713526625L); } + }; +# 114 "/usr/include/c++/11/tr1/special_function_util.h" 3 + template + inline bool __isnan(_Tp __x) + { return std::isnan(__x); } +# 133 "/usr/include/c++/11/tr1/special_function_util.h" 3 + } + + + + + +} +# 50 "/usr/include/c++/11/tr1/gamma.tcc" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/include/c++/11/tr1/gamma.tcc" 3 + namespace __detail + { +# 76 "/usr/include/c++/11/tr1/gamma.tcc" 3 + template + _Tp + __bernoulli_series(unsigned int __n) + { + + static const _Tp __num[28] = { + _Tp(1UL), -_Tp(1UL) / _Tp(2UL), + _Tp(1UL) / _Tp(6UL), _Tp(0UL), + -_Tp(1UL) / _Tp(30UL), _Tp(0UL), + _Tp(1UL) / _Tp(42UL), _Tp(0UL), + -_Tp(1UL) / _Tp(30UL), _Tp(0UL), + _Tp(5UL) / _Tp(66UL), _Tp(0UL), + -_Tp(691UL) / _Tp(2730UL), _Tp(0UL), + _Tp(7UL) / _Tp(6UL), _Tp(0UL), + -_Tp(3617UL) / _Tp(510UL), _Tp(0UL), + _Tp(43867UL) / _Tp(798UL), _Tp(0UL), + -_Tp(174611) / _Tp(330UL), _Tp(0UL), + _Tp(854513UL) / _Tp(138UL), _Tp(0UL), + -_Tp(236364091UL) / _Tp(2730UL), _Tp(0UL), + _Tp(8553103UL) / _Tp(6UL), _Tp(0UL) + }; + + if (__n == 0) + return _Tp(1); + + if (__n == 1) + return -_Tp(1) / _Tp(2); + + + if (__n % 2 == 1) + return _Tp(0); + + + if (__n < 28) + return __num[__n]; + + + _Tp __fact = _Tp(1); + if ((__n / 2) % 2 == 0) + __fact *= _Tp(-1); + for (unsigned int __k = 1; __k <= __n; ++__k) + __fact *= __k / (_Tp(2) * __numeric_constants<_Tp>::__pi()); + __fact *= _Tp(2); + + _Tp __sum = _Tp(0); + for (unsigned int __i = 1; __i < 1000; ++__i) + { + _Tp __term = std::pow(_Tp(__i), -_Tp(__n)); + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + __sum += __term; + } + + return __fact * __sum; + } +# 139 "/usr/include/c++/11/tr1/gamma.tcc" 3 + template + inline _Tp + __bernoulli(int __n) + { return __bernoulli_series<_Tp>(__n); } +# 153 "/usr/include/c++/11/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma_bernoulli(_Tp __x) + { + _Tp __lg = (__x - _Tp(0.5L)) * std::log(__x) - __x + + _Tp(0.5L) * std::log(_Tp(2) + * __numeric_constants<_Tp>::__pi()); + + const _Tp __xx = __x * __x; + _Tp __help = _Tp(1) / __x; + for ( unsigned int __i = 1; __i < 20; ++__i ) + { + const _Tp __2i = _Tp(2 * __i); + __help /= __2i * (__2i - _Tp(1)) * __xx; + __lg += __bernoulli<_Tp>(2 * __i) * __help; + } + + return __lg; + } +# 181 "/usr/include/c++/11/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma_lanczos(_Tp __x) + { + const _Tp __xm1 = __x - _Tp(1); + + static const _Tp __lanczos_cheb_7[9] = { + _Tp( 0.99999999999980993227684700473478L), + _Tp( 676.520368121885098567009190444019L), + _Tp(-1259.13921672240287047156078755283L), + _Tp( 771.3234287776530788486528258894L), + _Tp(-176.61502916214059906584551354L), + _Tp( 12.507343278686904814458936853L), + _Tp(-0.13857109526572011689554707L), + _Tp( 9.984369578019570859563e-6L), + _Tp( 1.50563273514931155834e-7L) + }; + + static const _Tp __LOGROOT2PI + = _Tp(0.9189385332046727417803297364056176L); + + _Tp __sum = __lanczos_cheb_7[0]; + for(unsigned int __k = 1; __k < 9; ++__k) + __sum += __lanczos_cheb_7[__k] / (__xm1 + __k); + + const _Tp __term1 = (__xm1 + _Tp(0.5L)) + * std::log((__xm1 + _Tp(7.5L)) + / __numeric_constants<_Tp>::__euler()); + const _Tp __term2 = __LOGROOT2PI + std::log(__sum); + const _Tp __result = __term1 + (__term2 - _Tp(7)); + + return __result; + } +# 225 "/usr/include/c++/11/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma(_Tp __x) + { + if (__x > _Tp(0.5L)) + return __log_gamma_lanczos(__x); + else + { + const _Tp __sin_fact + = std::abs(std::sin(__numeric_constants<_Tp>::__pi() * __x)); + if (__sin_fact == _Tp(0)) + std::__throw_domain_error(("Argument is nonpositive integer " "in __log_gamma") + ); + return __numeric_constants<_Tp>::__lnpi() + - std::log(__sin_fact) + - __log_gamma_lanczos(_Tp(1) - __x); + } + } +# 252 "/usr/include/c++/11/tr1/gamma.tcc" 3 + template + _Tp + __log_gamma_sign(_Tp __x) + { + if (__x > _Tp(0)) + return _Tp(1); + else + { + const _Tp __sin_fact + = std::sin(__numeric_constants<_Tp>::__pi() * __x); + if (__sin_fact > _Tp(0)) + return (1); + else if (__sin_fact < _Tp(0)) + return -_Tp(1); + else + return _Tp(0); + } + } +# 283 "/usr/include/c++/11/tr1/gamma.tcc" 3 + template + _Tp + __log_bincoef(unsigned int __n, unsigned int __k) + { + + static const _Tp __max_bincoeff + = std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + _Tp __coeff = ::std::lgamma(_Tp(1 + __n)) + - ::std::lgamma(_Tp(1 + __k)) + - ::std::lgamma(_Tp(1 + __n - __k)); + + + + + + } +# 314 "/usr/include/c++/11/tr1/gamma.tcc" 3 + template + _Tp + __bincoef(unsigned int __n, unsigned int __k) + { + + static const _Tp __max_bincoeff + = std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + const _Tp __log_coeff = __log_bincoef<_Tp>(__n, __k); + if (__log_coeff > __max_bincoeff) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return std::exp(__log_coeff); + } +# 337 "/usr/include/c++/11/tr1/gamma.tcc" 3 + template + inline _Tp + __gamma(_Tp __x) + { return std::exp(__log_gamma(__x)); } +# 356 "/usr/include/c++/11/tr1/gamma.tcc" 3 + template + _Tp + __psi_series(_Tp __x) + { + _Tp __sum = -__numeric_constants<_Tp>::__gamma_e() - _Tp(1) / __x; + const unsigned int __max_iter = 100000; + for (unsigned int __k = 1; __k < __max_iter; ++__k) + { + const _Tp __term = __x / (__k * (__k + __x)); + __sum += __term; + if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon()) + break; + } + return __sum; + } +# 386 "/usr/include/c++/11/tr1/gamma.tcc" 3 + template + _Tp + __psi_asymp(_Tp __x) + { + _Tp __sum = std::log(__x) - _Tp(0.5L) / __x; + const _Tp __xx = __x * __x; + _Tp __xp = __xx; + const unsigned int __max_iter = 100; + for (unsigned int __k = 1; __k < __max_iter; ++__k) + { + const _Tp __term = __bernoulli<_Tp>(2 * __k) / (2 * __k * __xp); + __sum -= __term; + if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon()) + break; + __xp *= __xx; + } + return __sum; + } +# 417 "/usr/include/c++/11/tr1/gamma.tcc" 3 + template + _Tp + __psi(_Tp __x) + { + const int __n = static_cast(__x + 0.5L); + const _Tp __eps = _Tp(4) * std::numeric_limits<_Tp>::epsilon(); + if (__n <= 0 && std::abs(__x - _Tp(__n)) < __eps) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x < _Tp(0)) + { + const _Tp __pi = __numeric_constants<_Tp>::__pi(); + return __psi(_Tp(1) - __x) + - __pi * std::cos(__pi * __x) / std::sin(__pi * __x); + } + else if (__x > _Tp(100)) + return __psi_asymp(__x); + else + return __psi_series(__x); + } +# 446 "/usr/include/c++/11/tr1/gamma.tcc" 3 + template + _Tp + __psi(unsigned int __n, _Tp __x) + { + if (__x <= _Tp(0)) + std::__throw_domain_error(("Argument out of range " "in __psi") + ); + else if (__n == 0) + return __psi(__x); + else + { + const _Tp __hzeta = __hurwitz_zeta(_Tp(__n + 1), __x); + + const _Tp __ln_nfact = ::std::lgamma(_Tp(__n + 1)); + + + + _Tp __result = std::exp(__ln_nfact) * __hzeta; + if (__n % 2 == 1) + __result = -__result; + return __result; + } + } + } + + + + + + +} +# 50 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/bessel_function.tcc" 1 3 +# 55 "/usr/include/c++/11/tr1/bessel_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 71 "/usr/include/c++/11/tr1/bessel_function.tcc" 3 + namespace __detail + { +# 98 "/usr/include/c++/11/tr1/bessel_function.tcc" 3 + template + void + __gamma_temme(_Tp __mu, + _Tp & __gam1, _Tp & __gam2, _Tp & __gampl, _Tp & __gammi) + { + + __gampl = _Tp(1) / ::std::tgamma(_Tp(1) + __mu); + __gammi = _Tp(1) / ::std::tgamma(_Tp(1) - __mu); + + + + + + if (std::abs(__mu) < std::numeric_limits<_Tp>::epsilon()) + __gam1 = -_Tp(__numeric_constants<_Tp>::__gamma_e()); + else + __gam1 = (__gammi - __gampl) / (_Tp(2) * __mu); + + __gam2 = (__gammi + __gampl) / (_Tp(2)); + + return; + } +# 136 "/usr/include/c++/11/tr1/bessel_function.tcc" 3 + template + void + __bessel_jn(_Tp __nu, _Tp __x, + _Tp & __Jnu, _Tp & __Nnu, _Tp & __Jpnu, _Tp & __Npnu) + { + if (__x == _Tp(0)) + { + if (__nu == _Tp(0)) + { + __Jnu = _Tp(1); + __Jpnu = _Tp(0); + } + else if (__nu == _Tp(1)) + { + __Jnu = _Tp(0); + __Jpnu = _Tp(0.5L); + } + else + { + __Jnu = _Tp(0); + __Jpnu = _Tp(0); + } + __Nnu = -std::numeric_limits<_Tp>::infinity(); + __Npnu = std::numeric_limits<_Tp>::infinity(); + return; + } + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + + + + const _Tp __fp_min = std::sqrt(std::numeric_limits<_Tp>::min()); + const int __max_iter = 15000; + const _Tp __x_min = _Tp(2); + + const int __nl = (__x < __x_min + ? static_cast(__nu + _Tp(0.5L)) + : std::max(0, static_cast(__nu - __x + _Tp(1.5L)))); + + const _Tp __mu = __nu - __nl; + const _Tp __mu2 = __mu * __mu; + const _Tp __xi = _Tp(1) / __x; + const _Tp __xi2 = _Tp(2) * __xi; + _Tp __w = __xi2 / __numeric_constants<_Tp>::__pi(); + int __isign = 1; + _Tp __h = __nu * __xi; + if (__h < __fp_min) + __h = __fp_min; + _Tp __b = __xi2 * __nu; + _Tp __d = _Tp(0); + _Tp __c = __h; + int __i; + for (__i = 1; __i <= __max_iter; ++__i) + { + __b += __xi2; + __d = __b - __d; + if (std::abs(__d) < __fp_min) + __d = __fp_min; + __c = __b - _Tp(1) / __c; + if (std::abs(__c) < __fp_min) + __c = __fp_min; + __d = _Tp(1) / __d; + const _Tp __del = __c * __d; + __h *= __del; + if (__d < _Tp(0)) + __isign = -__isign; + if (std::abs(__del - _Tp(1)) < __eps) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Argument x too large in __bessel_jn; " "try asymptotic expansion.") + ); + _Tp __Jnul = __isign * __fp_min; + _Tp __Jpnul = __h * __Jnul; + _Tp __Jnul1 = __Jnul; + _Tp __Jpnu1 = __Jpnul; + _Tp __fact = __nu * __xi; + for ( int __l = __nl; __l >= 1; --__l ) + { + const _Tp __Jnutemp = __fact * __Jnul + __Jpnul; + __fact -= __xi; + __Jpnul = __fact * __Jnutemp - __Jnul; + __Jnul = __Jnutemp; + } + if (__Jnul == _Tp(0)) + __Jnul = __eps; + _Tp __f= __Jpnul / __Jnul; + _Tp __Nmu, __Nnu1, __Npmu, __Jmu; + if (__x < __x_min) + { + const _Tp __x2 = __x / _Tp(2); + const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu; + _Tp __fact = (std::abs(__pimu) < __eps + ? _Tp(1) : __pimu / std::sin(__pimu)); + _Tp __d = -std::log(__x2); + _Tp __e = __mu * __d; + _Tp __fact2 = (std::abs(__e) < __eps + ? _Tp(1) : std::sinh(__e) / __e); + _Tp __gam1, __gam2, __gampl, __gammi; + __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi); + _Tp __ff = (_Tp(2) / __numeric_constants<_Tp>::__pi()) + * __fact * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d); + __e = std::exp(__e); + _Tp __p = __e / (__numeric_constants<_Tp>::__pi() * __gampl); + _Tp __q = _Tp(1) / (__e * __numeric_constants<_Tp>::__pi() * __gammi); + const _Tp __pimu2 = __pimu / _Tp(2); + _Tp __fact3 = (std::abs(__pimu2) < __eps + ? _Tp(1) : std::sin(__pimu2) / __pimu2 ); + _Tp __r = __numeric_constants<_Tp>::__pi() * __pimu2 * __fact3 * __fact3; + _Tp __c = _Tp(1); + __d = -__x2 * __x2; + _Tp __sum = __ff + __r * __q; + _Tp __sum1 = __p; + for (__i = 1; __i <= __max_iter; ++__i) + { + __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2); + __c *= __d / _Tp(__i); + __p /= _Tp(__i) - __mu; + __q /= _Tp(__i) + __mu; + const _Tp __del = __c * (__ff + __r * __q); + __sum += __del; + const _Tp __del1 = __c * __p - __i * __del; + __sum1 += __del1; + if ( std::abs(__del) < __eps * (_Tp(1) + std::abs(__sum)) ) + break; + } + if ( __i > __max_iter ) + std::__throw_runtime_error(("Bessel y series failed to converge " "in __bessel_jn.") + ); + __Nmu = -__sum; + __Nnu1 = -__sum1 * __xi2; + __Npmu = __mu * __xi * __Nmu - __Nnu1; + __Jmu = __w / (__Npmu - __f * __Nmu); + } + else + { + _Tp __a = _Tp(0.25L) - __mu2; + _Tp __q = _Tp(1); + _Tp __p = -__xi / _Tp(2); + _Tp __br = _Tp(2) * __x; + _Tp __bi = _Tp(2); + _Tp __fact = __a * __xi / (__p * __p + __q * __q); + _Tp __cr = __br + __q * __fact; + _Tp __ci = __bi + __p * __fact; + _Tp __den = __br * __br + __bi * __bi; + _Tp __dr = __br / __den; + _Tp __di = -__bi / __den; + _Tp __dlr = __cr * __dr - __ci * __di; + _Tp __dli = __cr * __di + __ci * __dr; + _Tp __temp = __p * __dlr - __q * __dli; + __q = __p * __dli + __q * __dlr; + __p = __temp; + int __i; + for (__i = 2; __i <= __max_iter; ++__i) + { + __a += _Tp(2 * (__i - 1)); + __bi += _Tp(2); + __dr = __a * __dr + __br; + __di = __a * __di + __bi; + if (std::abs(__dr) + std::abs(__di) < __fp_min) + __dr = __fp_min; + __fact = __a / (__cr * __cr + __ci * __ci); + __cr = __br + __cr * __fact; + __ci = __bi - __ci * __fact; + if (std::abs(__cr) + std::abs(__ci) < __fp_min) + __cr = __fp_min; + __den = __dr * __dr + __di * __di; + __dr /= __den; + __di /= -__den; + __dlr = __cr * __dr - __ci * __di; + __dli = __cr * __di + __ci * __dr; + __temp = __p * __dlr - __q * __dli; + __q = __p * __dli + __q * __dlr; + __p = __temp; + if (std::abs(__dlr - _Tp(1)) + std::abs(__dli) < __eps) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Lentz's method failed " "in __bessel_jn.") + ); + const _Tp __gam = (__p - __f) / __q; + __Jmu = std::sqrt(__w / ((__p - __f) * __gam + __q)); + + __Jmu = ::std::copysign(__Jmu, __Jnul); + + + + + __Nmu = __gam * __Jmu; + __Npmu = (__p + __q / __gam) * __Nmu; + __Nnu1 = __mu * __xi * __Nmu - __Npmu; + } + __fact = __Jmu / __Jnul; + __Jnu = __fact * __Jnul1; + __Jpnu = __fact * __Jpnu1; + for (__i = 1; __i <= __nl; ++__i) + { + const _Tp __Nnutemp = (__mu + __i) * __xi2 * __Nnu1 - __Nmu; + __Nmu = __Nnu1; + __Nnu1 = __Nnutemp; + } + __Nnu = __Nmu; + __Npnu = __nu * __xi * __Nmu - __Nnu1; + + return; + } +# 361 "/usr/include/c++/11/tr1/bessel_function.tcc" 3 + template + void + __cyl_bessel_jn_asymp(_Tp __nu, _Tp __x, _Tp & __Jnu, _Tp & __Nnu) + { + const _Tp __mu = _Tp(4) * __nu * __nu; + const _Tp __8x = _Tp(8) * __x; + + _Tp __P = _Tp(0); + _Tp __Q = _Tp(0); + + _Tp __k = _Tp(0); + _Tp __term = _Tp(1); + + int __epsP = 0; + int __epsQ = 0; + + _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + do + { + __term *= (__k == 0 + ? _Tp(1) + : -(__mu - (2 * __k - 1) * (2 * __k - 1)) / (__k * __8x)); + + __epsP = std::abs(__term) < __eps * std::abs(__P); + __P += __term; + + __k++; + + __term *= (__mu - (2 * __k - 1) * (2 * __k - 1)) / (__k * __8x); + __epsQ = std::abs(__term) < __eps * std::abs(__Q); + __Q += __term; + + if (__epsP && __epsQ && __k > (__nu / 2.)) + break; + + __k++; + } + while (__k < 1000); + + const _Tp __chi = __x - (__nu + _Tp(0.5L)) + * __numeric_constants<_Tp>::__pi_2(); + + const _Tp __c = std::cos(__chi); + const _Tp __s = std::sin(__chi); + + const _Tp __coef = std::sqrt(_Tp(2) + / (__numeric_constants<_Tp>::__pi() * __x)); + + __Jnu = __coef * (__c * __P - __s * __Q); + __Nnu = __coef * (__s * __P + __c * __Q); + + return; + } +# 444 "/usr/include/c++/11/tr1/bessel_function.tcc" 3 + template + _Tp + __cyl_bessel_ij_series(_Tp __nu, _Tp __x, _Tp __sgn, + unsigned int __max_iter) + { + if (__x == _Tp(0)) + return __nu == _Tp(0) ? _Tp(1) : _Tp(0); + + const _Tp __x2 = __x / _Tp(2); + _Tp __fact = __nu * std::log(__x2); + + __fact -= ::std::lgamma(__nu + _Tp(1)); + + + + __fact = std::exp(__fact); + const _Tp __xx4 = __sgn * __x2 * __x2; + _Tp __Jn = _Tp(1); + _Tp __term = _Tp(1); + + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + __term *= __xx4 / (_Tp(__i) * (__nu + _Tp(__i))); + __Jn += __term; + if (std::abs(__term / __Jn) < std::numeric_limits<_Tp>::epsilon()) + break; + } + + return __fact * __Jn; + } +# 490 "/usr/include/c++/11/tr1/bessel_function.tcc" 3 + template + _Tp + __cyl_bessel_j(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_j.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x * __x < _Tp(10) * (__nu + _Tp(1))) + return __cyl_bessel_ij_series(__nu, __x, -_Tp(1), 200); + else if (__x > _Tp(1000)) + { + _Tp __J_nu, __N_nu; + __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); + return __J_nu; + } + else + { + _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; + __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); + return __J_nu; + } + } +# 532 "/usr/include/c++/11/tr1/bessel_function.tcc" 3 + template + _Tp + __cyl_neumann_n(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_neumann_n.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x > _Tp(1000)) + { + _Tp __J_nu, __N_nu; + __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); + return __N_nu; + } + else + { + _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; + __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); + return __N_nu; + } + } +# 569 "/usr/include/c++/11/tr1/bessel_function.tcc" 3 + template + void + __sph_bessel_jn(unsigned int __n, _Tp __x, + _Tp & __j_n, _Tp & __n_n, _Tp & __jp_n, _Tp & __np_n) + { + const _Tp __nu = _Tp(__n) + _Tp(0.5L); + + _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; + __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); + + const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2() + / std::sqrt(__x); + + __j_n = __factor * __J_nu; + __n_n = __factor * __N_nu; + __jp_n = __factor * __Jp_nu - __j_n / (_Tp(2) * __x); + __np_n = __factor * __Np_nu - __n_n / (_Tp(2) * __x); + + return; + } +# 604 "/usr/include/c++/11/tr1/bessel_function.tcc" 3 + template + _Tp + __sph_bessel(unsigned int __n, _Tp __x) + { + if (__x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __sph_bessel.") + ); + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x == _Tp(0)) + { + if (__n == 0) + return _Tp(1); + else + return _Tp(0); + } + else + { + _Tp __j_n, __n_n, __jp_n, __np_n; + __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n); + return __j_n; + } + } +# 642 "/usr/include/c++/11/tr1/bessel_function.tcc" 3 + template + _Tp + __sph_neumann(unsigned int __n, _Tp __x) + { + if (__x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __sph_neumann.") + ); + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x == _Tp(0)) + return -std::numeric_limits<_Tp>::infinity(); + else + { + _Tp __j_n, __n_n, __jp_n, __np_n; + __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n); + return __n_n; + } + } + } + + + + + + +} +# 51 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/beta_function.tcc" 1 3 +# 49 "/usr/include/c++/11/tr1/beta_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/include/c++/11/tr1/beta_function.tcc" 3 + namespace __detail + { +# 79 "/usr/include/c++/11/tr1/beta_function.tcc" 3 + template + _Tp + __beta_gamma(_Tp __x, _Tp __y) + { + + _Tp __bet; + + if (__x > __y) + { + __bet = ::std::tgamma(__x) + / ::std::tgamma(__x + __y); + __bet *= ::std::tgamma(__y); + } + else + { + __bet = ::std::tgamma(__y) + / ::std::tgamma(__x + __y); + __bet *= ::std::tgamma(__x); + } +# 111 "/usr/include/c++/11/tr1/beta_function.tcc" 3 + return __bet; + } +# 127 "/usr/include/c++/11/tr1/beta_function.tcc" 3 + template + _Tp + __beta_lgamma(_Tp __x, _Tp __y) + { + + _Tp __bet = ::std::lgamma(__x) + + ::std::lgamma(__y) + - ::std::lgamma(__x + __y); + + + + + + __bet = std::exp(__bet); + return __bet; + } +# 158 "/usr/include/c++/11/tr1/beta_function.tcc" 3 + template + _Tp + __beta_product(_Tp __x, _Tp __y) + { + + _Tp __bet = (__x + __y) / (__x * __y); + + unsigned int __max_iter = 1000000; + for (unsigned int __k = 1; __k < __max_iter; ++__k) + { + _Tp __term = (_Tp(1) + (__x + __y) / __k) + / ((_Tp(1) + __x / __k) * (_Tp(1) + __y / __k)); + __bet *= __term; + } + + return __bet; + } +# 189 "/usr/include/c++/11/tr1/beta_function.tcc" 3 + template + inline _Tp + __beta(_Tp __x, _Tp __y) + { + if (__isnan(__x) || __isnan(__y)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __beta_lgamma(__x, __y); + } + } + + + + + + +} +# 52 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/ell_integral.tcc" 1 3 +# 45 "/usr/include/c++/11/tr1/ell_integral.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 59 "/usr/include/c++/11/tr1/ell_integral.tcc" 3 + namespace __detail + { +# 76 "/usr/include/c++/11/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rf(_Tp __x, _Tp __y, _Tp __z) + { + const _Tp __min = std::numeric_limits<_Tp>::min(); + const _Tp __lolim = _Tp(5) * __min; + + if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0)) + std::__throw_domain_error(("Argument less than zero " "in __ellint_rf.") + ); + else if (__x + __y < __lolim || __x + __z < __lolim + || __y + __z < __lolim) + std::__throw_domain_error(("Argument too small in __ellint_rf")); + else + { + const _Tp __c0 = _Tp(1) / _Tp(4); + const _Tp __c1 = _Tp(1) / _Tp(24); + const _Tp __c2 = _Tp(1) / _Tp(10); + const _Tp __c3 = _Tp(3) / _Tp(44); + const _Tp __c4 = _Tp(1) / _Tp(14); + + _Tp __xn = __x; + _Tp __yn = __y; + _Tp __zn = __z; + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol = std::pow(__eps, _Tp(1) / _Tp(6)); + _Tp __mu; + _Tp __xndev, __yndev, __zndev; + + const unsigned int __max_iter = 100; + for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) + { + __mu = (__xn + __yn + __zn) / _Tp(3); + __xndev = 2 - (__mu + __xn) / __mu; + __yndev = 2 - (__mu + __yn) / __mu; + __zndev = 2 - (__mu + __zn) / __mu; + _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); + __epsilon = std::max(__epsilon, std::abs(__zndev)); + if (__epsilon < __errtol) + break; + const _Tp __xnroot = std::sqrt(__xn); + const _Tp __ynroot = std::sqrt(__yn); + const _Tp __znroot = std::sqrt(__zn); + const _Tp __lambda = __xnroot * (__ynroot + __znroot) + + __ynroot * __znroot; + __xn = __c0 * (__xn + __lambda); + __yn = __c0 * (__yn + __lambda); + __zn = __c0 * (__zn + __lambda); + } + + const _Tp __e2 = __xndev * __yndev - __zndev * __zndev; + const _Tp __e3 = __xndev * __yndev * __zndev; + const _Tp __s = _Tp(1) + (__c1 * __e2 - __c2 - __c3 * __e3) * __e2 + + __c4 * __e3; + + return __s / std::sqrt(__mu); + } + } +# 153 "/usr/include/c++/11/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_1_series(_Tp __k) + { + + const _Tp __kk = __k * __k; + + _Tp __term = __kk / _Tp(4); + _Tp __sum = _Tp(1) + __term; + + const unsigned int __max_iter = 1000; + for (unsigned int __i = 2; __i < __max_iter; ++__i) + { + __term *= (2 * __i - 1) * __kk / (2 * __i); + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + __sum += __term; + } + + return __numeric_constants<_Tp>::__pi_2() * __sum; + } +# 191 "/usr/include/c++/11/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_1(_Tp __k) + { + + if (__isnan(__k)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) >= _Tp(1)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __ellint_rf(_Tp(0), _Tp(1) - __k * __k, _Tp(1)); + } +# 219 "/usr/include/c++/11/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_1(_Tp __k, _Tp __phi) + { + + if (__isnan(__k) || __isnan(__phi)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __ellint_1.")); + else + { + + const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi() + + _Tp(0.5L)); + const _Tp __phi_red = __phi + - __n * __numeric_constants<_Tp>::__pi(); + + const _Tp __s = std::sin(__phi_red); + const _Tp __c = std::cos(__phi_red); + + const _Tp __F = __s + * __ellint_rf(__c * __c, + _Tp(1) - __k * __k * __s * __s, _Tp(1)); + + if (__n == 0) + return __F; + else + return __F + _Tp(2) * __n * __comp_ellint_1(__k); + } + } +# 266 "/usr/include/c++/11/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_2_series(_Tp __k) + { + + const _Tp __kk = __k * __k; + + _Tp __term = __kk; + _Tp __sum = __term; + + const unsigned int __max_iter = 1000; + for (unsigned int __i = 2; __i < __max_iter; ++__i) + { + const _Tp __i2m = 2 * __i - 1; + const _Tp __i2 = 2 * __i; + __term *= __i2m * __i2m * __kk / (__i2 * __i2); + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + __sum += __term / __i2m; + } + + return __numeric_constants<_Tp>::__pi_2() * (_Tp(1) - __sum); + } +# 314 "/usr/include/c++/11/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rd(_Tp __x, _Tp __y, _Tp __z) + { + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6)); + const _Tp __max = std::numeric_limits<_Tp>::max(); + const _Tp __lolim = _Tp(2) / std::pow(__max, _Tp(2) / _Tp(3)); + + if (__x < _Tp(0) || __y < _Tp(0)) + std::__throw_domain_error(("Argument less than zero " "in __ellint_rd.") + ); + else if (__x + __y < __lolim || __z < __lolim) + std::__throw_domain_error(("Argument too small " "in __ellint_rd.") + ); + else + { + const _Tp __c0 = _Tp(1) / _Tp(4); + const _Tp __c1 = _Tp(3) / _Tp(14); + const _Tp __c2 = _Tp(1) / _Tp(6); + const _Tp __c3 = _Tp(9) / _Tp(22); + const _Tp __c4 = _Tp(3) / _Tp(26); + + _Tp __xn = __x; + _Tp __yn = __y; + _Tp __zn = __z; + _Tp __sigma = _Tp(0); + _Tp __power4 = _Tp(1); + + _Tp __mu; + _Tp __xndev, __yndev, __zndev; + + const unsigned int __max_iter = 100; + for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) + { + __mu = (__xn + __yn + _Tp(3) * __zn) / _Tp(5); + __xndev = (__mu - __xn) / __mu; + __yndev = (__mu - __yn) / __mu; + __zndev = (__mu - __zn) / __mu; + _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); + __epsilon = std::max(__epsilon, std::abs(__zndev)); + if (__epsilon < __errtol) + break; + _Tp __xnroot = std::sqrt(__xn); + _Tp __ynroot = std::sqrt(__yn); + _Tp __znroot = std::sqrt(__zn); + _Tp __lambda = __xnroot * (__ynroot + __znroot) + + __ynroot * __znroot; + __sigma += __power4 / (__znroot * (__zn + __lambda)); + __power4 *= __c0; + __xn = __c0 * (__xn + __lambda); + __yn = __c0 * (__yn + __lambda); + __zn = __c0 * (__zn + __lambda); + } + + _Tp __ea = __xndev * __yndev; + _Tp __eb = __zndev * __zndev; + _Tp __ec = __ea - __eb; + _Tp __ed = __ea - _Tp(6) * __eb; + _Tp __ef = __ed + __ec + __ec; + _Tp __s1 = __ed * (-__c1 + __c3 * __ed + / _Tp(3) - _Tp(3) * __c4 * __zndev * __ef + / _Tp(2)); + _Tp __s2 = __zndev + * (__c2 * __ef + + __zndev * (-__c3 * __ec - __zndev * __c4 - __ea)); + + return _Tp(3) * __sigma + __power4 * (_Tp(1) + __s1 + __s2) + / (__mu * std::sqrt(__mu)); + } + } +# 399 "/usr/include/c++/11/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_2(_Tp __k) + { + + if (__isnan(__k)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) == 1) + return _Tp(1); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __comp_ellint_2.")); + else + { + const _Tp __kk = __k * __k; + + return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1)) + - __kk * __ellint_rd(_Tp(0), _Tp(1) - __kk, _Tp(1)) / _Tp(3); + } + } +# 433 "/usr/include/c++/11/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_2(_Tp __k, _Tp __phi) + { + + if (__isnan(__k) || __isnan(__phi)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __ellint_2.")); + else + { + + const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi() + + _Tp(0.5L)); + const _Tp __phi_red = __phi + - __n * __numeric_constants<_Tp>::__pi(); + + const _Tp __kk = __k * __k; + const _Tp __s = std::sin(__phi_red); + const _Tp __ss = __s * __s; + const _Tp __sss = __ss * __s; + const _Tp __c = std::cos(__phi_red); + const _Tp __cc = __c * __c; + + const _Tp __E = __s + * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1)) + - __kk * __sss + * __ellint_rd(__cc, _Tp(1) - __kk * __ss, _Tp(1)) + / _Tp(3); + + if (__n == 0) + return __E; + else + return __E + _Tp(2) * __n * __comp_ellint_2(__k); + } + } +# 492 "/usr/include/c++/11/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rc(_Tp __x, _Tp __y) + { + const _Tp __min = std::numeric_limits<_Tp>::min(); + const _Tp __lolim = _Tp(5) * __min; + + if (__x < _Tp(0) || __y < _Tp(0) || __x + __y < __lolim) + std::__throw_domain_error(("Argument less than zero " "in __ellint_rc.") + ); + else + { + const _Tp __c0 = _Tp(1) / _Tp(4); + const _Tp __c1 = _Tp(1) / _Tp(7); + const _Tp __c2 = _Tp(9) / _Tp(22); + const _Tp __c3 = _Tp(3) / _Tp(10); + const _Tp __c4 = _Tp(3) / _Tp(8); + + _Tp __xn = __x; + _Tp __yn = __y; + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol = std::pow(__eps / _Tp(30), _Tp(1) / _Tp(6)); + _Tp __mu; + _Tp __sn; + + const unsigned int __max_iter = 100; + for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) + { + __mu = (__xn + _Tp(2) * __yn) / _Tp(3); + __sn = (__yn + __mu) / __mu - _Tp(2); + if (std::abs(__sn) < __errtol) + break; + const _Tp __lambda = _Tp(2) * std::sqrt(__xn) * std::sqrt(__yn) + + __yn; + __xn = __c0 * (__xn + __lambda); + __yn = __c0 * (__yn + __lambda); + } + + _Tp __s = __sn * __sn + * (__c3 + __sn*(__c1 + __sn * (__c4 + __sn * __c2))); + + return (_Tp(1) + __s) / std::sqrt(__mu); + } + } +# 561 "/usr/include/c++/11/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_rj(_Tp __x, _Tp __y, _Tp __z, _Tp __p) + { + const _Tp __min = std::numeric_limits<_Tp>::min(); + const _Tp __lolim = std::pow(_Tp(5) * __min, _Tp(1)/_Tp(3)); + + if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0)) + std::__throw_domain_error(("Argument less than zero " "in __ellint_rj.") + ); + else if (__x + __y < __lolim || __x + __z < __lolim + || __y + __z < __lolim || __p < __lolim) + std::__throw_domain_error(("Argument too small " "in __ellint_rj") + ); + else + { + const _Tp __c0 = _Tp(1) / _Tp(4); + const _Tp __c1 = _Tp(3) / _Tp(14); + const _Tp __c2 = _Tp(1) / _Tp(3); + const _Tp __c3 = _Tp(3) / _Tp(22); + const _Tp __c4 = _Tp(3) / _Tp(26); + + _Tp __xn = __x; + _Tp __yn = __y; + _Tp __zn = __z; + _Tp __pn = __p; + _Tp __sigma = _Tp(0); + _Tp __power4 = _Tp(1); + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6)); + + _Tp __mu; + _Tp __xndev, __yndev, __zndev, __pndev; + + const unsigned int __max_iter = 100; + for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) + { + __mu = (__xn + __yn + __zn + _Tp(2) * __pn) / _Tp(5); + __xndev = (__mu - __xn) / __mu; + __yndev = (__mu - __yn) / __mu; + __zndev = (__mu - __zn) / __mu; + __pndev = (__mu - __pn) / __mu; + _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); + __epsilon = std::max(__epsilon, std::abs(__zndev)); + __epsilon = std::max(__epsilon, std::abs(__pndev)); + if (__epsilon < __errtol) + break; + const _Tp __xnroot = std::sqrt(__xn); + const _Tp __ynroot = std::sqrt(__yn); + const _Tp __znroot = std::sqrt(__zn); + const _Tp __lambda = __xnroot * (__ynroot + __znroot) + + __ynroot * __znroot; + const _Tp __alpha1 = __pn * (__xnroot + __ynroot + __znroot) + + __xnroot * __ynroot * __znroot; + const _Tp __alpha2 = __alpha1 * __alpha1; + const _Tp __beta = __pn * (__pn + __lambda) + * (__pn + __lambda); + __sigma += __power4 * __ellint_rc(__alpha2, __beta); + __power4 *= __c0; + __xn = __c0 * (__xn + __lambda); + __yn = __c0 * (__yn + __lambda); + __zn = __c0 * (__zn + __lambda); + __pn = __c0 * (__pn + __lambda); + } + + _Tp __ea = __xndev * (__yndev + __zndev) + __yndev * __zndev; + _Tp __eb = __xndev * __yndev * __zndev; + _Tp __ec = __pndev * __pndev; + _Tp __e2 = __ea - _Tp(3) * __ec; + _Tp __e3 = __eb + _Tp(2) * __pndev * (__ea - __ec); + _Tp __s1 = _Tp(1) + __e2 * (-__c1 + _Tp(3) * __c3 * __e2 / _Tp(4) + - _Tp(3) * __c4 * __e3 / _Tp(2)); + _Tp __s2 = __eb * (__c2 / _Tp(2) + + __pndev * (-__c3 - __c3 + __pndev * __c4)); + _Tp __s3 = __pndev * __ea * (__c2 - __pndev * __c3) + - __c2 * __pndev * __ec; + + return _Tp(3) * __sigma + __power4 * (__s1 + __s2 + __s3) + / (__mu * std::sqrt(__mu)); + } + } +# 661 "/usr/include/c++/11/tr1/ell_integral.tcc" 3 + template + _Tp + __comp_ellint_3(_Tp __k, _Tp __nu) + { + + if (__isnan(__k) || __isnan(__nu)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__nu == _Tp(1)) + return std::numeric_limits<_Tp>::infinity(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __comp_ellint_3.")); + else + { + const _Tp __kk = __k * __k; + + return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1)) + + __nu + * __ellint_rj(_Tp(0), _Tp(1) - __kk, _Tp(1), _Tp(1) - __nu) + / _Tp(3); + } + } +# 701 "/usr/include/c++/11/tr1/ell_integral.tcc" 3 + template + _Tp + __ellint_3(_Tp __k, _Tp __nu, _Tp __phi) + { + + if (__isnan(__k) || __isnan(__nu) || __isnan(__phi)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (std::abs(__k) > _Tp(1)) + std::__throw_domain_error(("Bad argument in __ellint_3.")); + else + { + + const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi() + + _Tp(0.5L)); + const _Tp __phi_red = __phi + - __n * __numeric_constants<_Tp>::__pi(); + + const _Tp __kk = __k * __k; + const _Tp __s = std::sin(__phi_red); + const _Tp __ss = __s * __s; + const _Tp __sss = __ss * __s; + const _Tp __c = std::cos(__phi_red); + const _Tp __cc = __c * __c; + + const _Tp __Pi = __s + * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1)) + + __nu * __sss + * __ellint_rj(__cc, _Tp(1) - __kk * __ss, _Tp(1), + _Tp(1) - __nu * __ss) / _Tp(3); + + if (__n == 0) + return __Pi; + else + return __Pi + _Tp(2) * __n * __comp_ellint_3(__k, __nu); + } + } + } + + + + + +} +# 53 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/exp_integral.tcc" 1 3 +# 50 "/usr/include/c++/11/tr1/exp_integral.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 64 "/usr/include/c++/11/tr1/exp_integral.tcc" 3 + namespace __detail + { + template _Tp __expint_E1(_Tp); +# 81 "/usr/include/c++/11/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_E1_series(_Tp __x) + { + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + _Tp __term = _Tp(1); + _Tp __esum = _Tp(0); + _Tp __osum = _Tp(0); + const unsigned int __max_iter = 1000; + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + __term *= - __x / __i; + if (std::abs(__term) < __eps) + break; + if (__term >= _Tp(0)) + __esum += __term / __i; + else + __osum += __term / __i; + } + + return - __esum - __osum + - __numeric_constants<_Tp>::__gamma_e() - std::log(__x); + } +# 118 "/usr/include/c++/11/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_E1_asymp(_Tp __x) + { + _Tp __term = _Tp(1); + _Tp __esum = _Tp(1); + _Tp __osum = _Tp(0); + const unsigned int __max_iter = 1000; + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + _Tp __prev = __term; + __term *= - __i / __x; + if (std::abs(__term) > std::abs(__prev)) + break; + if (__term >= _Tp(0)) + __esum += __term; + else + __osum += __term; + } + + return std::exp(- __x) * (__esum + __osum) / __x; + } +# 155 "/usr/include/c++/11/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_En_series(unsigned int __n, _Tp __x) + { + const unsigned int __max_iter = 1000; + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const int __nm1 = __n - 1; + _Tp __ans = (__nm1 != 0 + ? _Tp(1) / __nm1 : -std::log(__x) + - __numeric_constants<_Tp>::__gamma_e()); + _Tp __fact = _Tp(1); + for (int __i = 1; __i <= __max_iter; ++__i) + { + __fact *= -__x / _Tp(__i); + _Tp __del; + if ( __i != __nm1 ) + __del = -__fact / _Tp(__i - __nm1); + else + { + _Tp __psi = -__numeric_constants<_Tp>::gamma_e(); + for (int __ii = 1; __ii <= __nm1; ++__ii) + __psi += _Tp(1) / _Tp(__ii); + __del = __fact * (__psi - std::log(__x)); + } + __ans += __del; + if (std::abs(__del) < __eps * std::abs(__ans)) + return __ans; + } + std::__throw_runtime_error(("Series summation failed " "in __expint_En_series.") + ); + } +# 201 "/usr/include/c++/11/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_En_cont_frac(unsigned int __n, _Tp __x) + { + const unsigned int __max_iter = 1000; + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __fp_min = std::numeric_limits<_Tp>::min(); + const int __nm1 = __n - 1; + _Tp __b = __x + _Tp(__n); + _Tp __c = _Tp(1) / __fp_min; + _Tp __d = _Tp(1) / __b; + _Tp __h = __d; + for ( unsigned int __i = 1; __i <= __max_iter; ++__i ) + { + _Tp __a = -_Tp(__i * (__nm1 + __i)); + __b += _Tp(2); + __d = _Tp(1) / (__a * __d + __b); + __c = __b + __a / __c; + const _Tp __del = __c * __d; + __h *= __del; + if (std::abs(__del - _Tp(1)) < __eps) + { + const _Tp __ans = __h * std::exp(-__x); + return __ans; + } + } + std::__throw_runtime_error(("Continued fraction failed " "in __expint_En_cont_frac.") + ); + } +# 246 "/usr/include/c++/11/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_En_recursion(unsigned int __n, _Tp __x) + { + _Tp __En; + _Tp __E1 = __expint_E1(__x); + if (__x < _Tp(__n)) + { + + __En = __E1; + for (unsigned int __j = 2; __j < __n; ++__j) + __En = (std::exp(-__x) - __x * __En) / _Tp(__j - 1); + } + else + { + + __En = _Tp(1); + const int __N = __n + 20; + _Tp __save = _Tp(0); + for (int __j = __N; __j > 0; --__j) + { + __En = (std::exp(-__x) - __j * __En) / __x; + if (__j == __n) + __save = __En; + } + _Tp __norm = __En / __E1; + __En /= __norm; + } + + return __En; + } +# 290 "/usr/include/c++/11/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_Ei_series(_Tp __x) + { + _Tp __term = _Tp(1); + _Tp __sum = _Tp(0); + const unsigned int __max_iter = 1000; + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + __term *= __x / __i; + __sum += __term / __i; + if (__term < std::numeric_limits<_Tp>::epsilon() * __sum) + break; + } + + return __numeric_constants<_Tp>::__gamma_e() + __sum + std::log(__x); + } +# 321 "/usr/include/c++/11/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_Ei_asymp(_Tp __x) + { + _Tp __term = _Tp(1); + _Tp __sum = _Tp(1); + const unsigned int __max_iter = 1000; + for (unsigned int __i = 1; __i < __max_iter; ++__i) + { + _Tp __prev = __term; + __term *= __i / __x; + if (__term < std::numeric_limits<_Tp>::epsilon()) + break; + if (__term >= __prev) + break; + __sum += __term; + } + + return std::exp(__x) * __sum / __x; + } +# 354 "/usr/include/c++/11/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_Ei(_Tp __x) + { + if (__x < _Tp(0)) + return -__expint_E1(-__x); + else if (__x < -std::log(std::numeric_limits<_Tp>::epsilon())) + return __expint_Ei_series(__x); + else + return __expint_Ei_asymp(__x); + } +# 378 "/usr/include/c++/11/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_E1(_Tp __x) + { + if (__x < _Tp(0)) + return -__expint_Ei(-__x); + else if (__x < _Tp(1)) + return __expint_E1_series(__x); + else if (__x < _Tp(100)) + return __expint_En_cont_frac(1, __x); + else + return __expint_E1_asymp(__x); + } +# 408 "/usr/include/c++/11/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_asymp(unsigned int __n, _Tp __x) + { + _Tp __term = _Tp(1); + _Tp __sum = _Tp(1); + for (unsigned int __i = 1; __i <= __n; ++__i) + { + _Tp __prev = __term; + __term *= -(__n - __i + 1) / __x; + if (std::abs(__term) > std::abs(__prev)) + break; + __sum += __term; + } + + return std::exp(-__x) * __sum / __x; + } +# 442 "/usr/include/c++/11/tr1/exp_integral.tcc" 3 + template + _Tp + __expint_large_n(unsigned int __n, _Tp __x) + { + const _Tp __xpn = __x + __n; + const _Tp __xpn2 = __xpn * __xpn; + _Tp __term = _Tp(1); + _Tp __sum = _Tp(1); + for (unsigned int __i = 1; __i <= __n; ++__i) + { + _Tp __prev = __term; + __term *= (__n - 2 * (__i - 1) * __x) / __xpn2; + if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon()) + break; + __sum += __term; + } + + return std::exp(-__x) * __sum / __xpn; + } +# 476 "/usr/include/c++/11/tr1/exp_integral.tcc" 3 + template + _Tp + __expint(unsigned int __n, _Tp __x) + { + + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__n <= 1 && __x == _Tp(0)) + return std::numeric_limits<_Tp>::infinity(); + else + { + _Tp __E0 = std::exp(__x) / __x; + if (__n == 0) + return __E0; + + _Tp __E1 = __expint_E1(__x); + if (__n == 1) + return __E1; + + if (__x == _Tp(0)) + return _Tp(1) / static_cast<_Tp>(__n - 1); + + _Tp __En = __expint_En_recursion(__n, __x); + + return __En; + } + } +# 516 "/usr/include/c++/11/tr1/exp_integral.tcc" 3 + template + inline _Tp + __expint(_Tp __x) + { + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __expint_Ei(__x); + } + } + + + + + +} +# 54 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/hypergeometric.tcc" 1 3 +# 44 "/usr/include/c++/11/tr1/hypergeometric.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 60 "/usr/include/c++/11/tr1/hypergeometric.tcc" 3 + namespace __detail + { +# 83 "/usr/include/c++/11/tr1/hypergeometric.tcc" 3 + template + _Tp + __conf_hyperg_series(_Tp __a, _Tp __c, _Tp __x) + { + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + _Tp __term = _Tp(1); + _Tp __Fac = _Tp(1); + const unsigned int __max_iter = 100000; + unsigned int __i; + for (__i = 0; __i < __max_iter; ++__i) + { + __term *= (__a + _Tp(__i)) * __x + / ((__c + _Tp(__i)) * _Tp(1 + __i)); + if (std::abs(__term) < __eps) + { + break; + } + __Fac += __term; + } + if (__i == __max_iter) + std::__throw_runtime_error(("Series failed to converge " "in __conf_hyperg_series.") + ); + + return __Fac; + } +# 120 "/usr/include/c++/11/tr1/hypergeometric.tcc" 3 + template + _Tp + __conf_hyperg_luke(_Tp __a, _Tp __c, _Tp __xin) + { + const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L)); + const int __nmax = 20000; + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __x = -__xin; + const _Tp __x3 = __x * __x * __x; + const _Tp __t0 = __a / __c; + const _Tp __t1 = (__a + _Tp(1)) / (_Tp(2) * __c); + const _Tp __t2 = (__a + _Tp(2)) / (_Tp(2) * (__c + _Tp(1))); + _Tp __F = _Tp(1); + _Tp __prec; + + _Tp __Bnm3 = _Tp(1); + _Tp __Bnm2 = _Tp(1) + __t1 * __x; + _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x); + + _Tp __Anm3 = _Tp(1); + _Tp __Anm2 = __Bnm2 - __t0 * __x; + _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x + + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x; + + int __n = 3; + while(1) + { + _Tp __npam1 = _Tp(__n - 1) + __a; + _Tp __npcm1 = _Tp(__n - 1) + __c; + _Tp __npam2 = _Tp(__n - 2) + __a; + _Tp __npcm2 = _Tp(__n - 2) + __c; + _Tp __tnm1 = _Tp(2 * __n - 1); + _Tp __tnm3 = _Tp(2 * __n - 3); + _Tp __tnm5 = _Tp(2 * __n - 5); + _Tp __F1 = (_Tp(__n - 2) - __a) / (_Tp(2) * __tnm3 * __npcm1); + _Tp __F2 = (_Tp(__n) + __a) * __npam1 + / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1); + _Tp __F3 = -__npam2 * __npam1 * (_Tp(__n - 2) - __a) + / (_Tp(8) * __tnm3 * __tnm3 * __tnm5 + * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1); + _Tp __E = -__npam1 * (_Tp(__n - 1) - __c) + / (_Tp(2) * __tnm3 * __npcm2 * __npcm1); + + _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1 + + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3; + _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1 + + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3; + _Tp __r = __An / __Bn; + + __prec = std::abs((__F - __r) / __F); + __F = __r; + + if (__prec < __eps || __n > __nmax) + break; + + if (std::abs(__An) > __big || std::abs(__Bn) > __big) + { + __An /= __big; + __Bn /= __big; + __Anm1 /= __big; + __Bnm1 /= __big; + __Anm2 /= __big; + __Bnm2 /= __big; + __Anm3 /= __big; + __Bnm3 /= __big; + } + else if (std::abs(__An) < _Tp(1) / __big + || std::abs(__Bn) < _Tp(1) / __big) + { + __An *= __big; + __Bn *= __big; + __Anm1 *= __big; + __Bnm1 *= __big; + __Anm2 *= __big; + __Bnm2 *= __big; + __Anm3 *= __big; + __Bnm3 *= __big; + } + + ++__n; + __Bnm3 = __Bnm2; + __Bnm2 = __Bnm1; + __Bnm1 = __Bn; + __Anm3 = __Anm2; + __Anm2 = __Anm1; + __Anm1 = __An; + } + + if (__n >= __nmax) + std::__throw_runtime_error(("Iteration failed to converge " "in __conf_hyperg_luke.") + ); + + return __F; + } +# 227 "/usr/include/c++/11/tr1/hypergeometric.tcc" 3 + template + _Tp + __conf_hyperg(_Tp __a, _Tp __c, _Tp __x) + { + + const _Tp __c_nint = ::std::nearbyint(__c); + + + + if (__isnan(__a) || __isnan(__c) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__c_nint == __c && __c_nint <= 0) + return std::numeric_limits<_Tp>::infinity(); + else if (__a == _Tp(0)) + return _Tp(1); + else if (__c == __a) + return std::exp(__x); + else if (__x < _Tp(0)) + return __conf_hyperg_luke(__a, __c, __x); + else + return __conf_hyperg_series(__a, __c, __x); + } +# 271 "/usr/include/c++/11/tr1/hypergeometric.tcc" 3 + template + _Tp + __hyperg_series(_Tp __a, _Tp __b, _Tp __c, _Tp __x) + { + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + _Tp __term = _Tp(1); + _Tp __Fabc = _Tp(1); + const unsigned int __max_iter = 100000; + unsigned int __i; + for (__i = 0; __i < __max_iter; ++__i) + { + __term *= (__a + _Tp(__i)) * (__b + _Tp(__i)) * __x + / ((__c + _Tp(__i)) * _Tp(1 + __i)); + if (std::abs(__term) < __eps) + { + break; + } + __Fabc += __term; + } + if (__i == __max_iter) + std::__throw_runtime_error(("Series failed to converge " "in __hyperg_series.") + ); + + return __Fabc; + } + + + + + + + + template + _Tp + __hyperg_luke(_Tp __a, _Tp __b, _Tp __c, _Tp __xin) + { + const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L)); + const int __nmax = 20000; + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __x = -__xin; + const _Tp __x3 = __x * __x * __x; + const _Tp __t0 = __a * __b / __c; + const _Tp __t1 = (__a + _Tp(1)) * (__b + _Tp(1)) / (_Tp(2) * __c); + const _Tp __t2 = (__a + _Tp(2)) * (__b + _Tp(2)) + / (_Tp(2) * (__c + _Tp(1))); + + _Tp __F = _Tp(1); + + _Tp __Bnm3 = _Tp(1); + _Tp __Bnm2 = _Tp(1) + __t1 * __x; + _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x); + + _Tp __Anm3 = _Tp(1); + _Tp __Anm2 = __Bnm2 - __t0 * __x; + _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x + + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x; + + int __n = 3; + while (1) + { + const _Tp __npam1 = _Tp(__n - 1) + __a; + const _Tp __npbm1 = _Tp(__n - 1) + __b; + const _Tp __npcm1 = _Tp(__n - 1) + __c; + const _Tp __npam2 = _Tp(__n - 2) + __a; + const _Tp __npbm2 = _Tp(__n - 2) + __b; + const _Tp __npcm2 = _Tp(__n - 2) + __c; + const _Tp __tnm1 = _Tp(2 * __n - 1); + const _Tp __tnm3 = _Tp(2 * __n - 3); + const _Tp __tnm5 = _Tp(2 * __n - 5); + const _Tp __n2 = __n * __n; + const _Tp __F1 = (_Tp(3) * __n2 + (__a + __b - _Tp(6)) * __n + + _Tp(2) - __a * __b - _Tp(2) * (__a + __b)) + / (_Tp(2) * __tnm3 * __npcm1); + const _Tp __F2 = -(_Tp(3) * __n2 - (__a + __b + _Tp(6)) * __n + + _Tp(2) - __a * __b) * __npam1 * __npbm1 + / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1); + const _Tp __F3 = (__npam2 * __npam1 * __npbm2 * __npbm1 + * (_Tp(__n - 2) - __a) * (_Tp(__n - 2) - __b)) + / (_Tp(8) * __tnm3 * __tnm3 * __tnm5 + * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1); + const _Tp __E = -__npam1 * __npbm1 * (_Tp(__n - 1) - __c) + / (_Tp(2) * __tnm3 * __npcm2 * __npcm1); + + _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1 + + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3; + _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1 + + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3; + const _Tp __r = __An / __Bn; + + const _Tp __prec = std::abs((__F - __r) / __F); + __F = __r; + + if (__prec < __eps || __n > __nmax) + break; + + if (std::abs(__An) > __big || std::abs(__Bn) > __big) + { + __An /= __big; + __Bn /= __big; + __Anm1 /= __big; + __Bnm1 /= __big; + __Anm2 /= __big; + __Bnm2 /= __big; + __Anm3 /= __big; + __Bnm3 /= __big; + } + else if (std::abs(__An) < _Tp(1) / __big + || std::abs(__Bn) < _Tp(1) / __big) + { + __An *= __big; + __Bn *= __big; + __Anm1 *= __big; + __Bnm1 *= __big; + __Anm2 *= __big; + __Bnm2 *= __big; + __Anm3 *= __big; + __Bnm3 *= __big; + } + + ++__n; + __Bnm3 = __Bnm2; + __Bnm2 = __Bnm1; + __Bnm1 = __Bn; + __Anm3 = __Anm2; + __Anm2 = __Anm1; + __Anm1 = __An; + } + + if (__n >= __nmax) + std::__throw_runtime_error(("Iteration failed to converge " "in __hyperg_luke.") + ); + + return __F; + } +# 438 "/usr/include/c++/11/tr1/hypergeometric.tcc" 3 + template + _Tp + __hyperg_reflect(_Tp __a, _Tp __b, _Tp __c, _Tp __x) + { + const _Tp __d = __c - __a - __b; + const int __intd = std::floor(__d + _Tp(0.5L)); + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __toler = _Tp(1000) * __eps; + const _Tp __log_max = std::log(std::numeric_limits<_Tp>::max()); + const bool __d_integer = (std::abs(__d - __intd) < __toler); + + if (__d_integer) + { + const _Tp __ln_omx = std::log(_Tp(1) - __x); + const _Tp __ad = std::abs(__d); + _Tp __F1, __F2; + + _Tp __d1, __d2; + if (__d >= _Tp(0)) + { + __d1 = __d; + __d2 = _Tp(0); + } + else + { + __d1 = _Tp(0); + __d2 = __d; + } + + const _Tp __lng_c = __log_gamma(__c); + + + if (__ad < __eps) + { + + __F1 = _Tp(0); + } + else + { + + bool __ok_d1 = true; + _Tp __lng_ad, __lng_ad1, __lng_bd1; + try + { + __lng_ad = __log_gamma(__ad); + __lng_ad1 = __log_gamma(__a + __d1); + __lng_bd1 = __log_gamma(__b + __d1); + } + catch(...) + { + __ok_d1 = false; + } + + if (__ok_d1) + { + + + + _Tp __sum1 = _Tp(1); + _Tp __term = _Tp(1); + _Tp __ln_pre1 = __lng_ad + __lng_c + __d2 * __ln_omx + - __lng_ad1 - __lng_bd1; + + + + for (int __i = 1; __i < __ad; ++__i) + { + const int __j = __i - 1; + __term *= (__a + __d2 + __j) * (__b + __d2 + __j) + / (_Tp(1) + __d2 + __j) / __i * (_Tp(1) - __x); + __sum1 += __term; + } + + if (__ln_pre1 > __log_max) + std::__throw_runtime_error(("Overflow of gamma functions" " in __hyperg_luke.") + ); + else + __F1 = std::exp(__ln_pre1) * __sum1; + } + else + { + + + __F1 = _Tp(0); + } + } + + + bool __ok_d2 = true; + _Tp __lng_ad2, __lng_bd2; + try + { + __lng_ad2 = __log_gamma(__a + __d2); + __lng_bd2 = __log_gamma(__b + __d2); + } + catch(...) + { + __ok_d2 = false; + } + + if (__ok_d2) + { + + + const int __maxiter = 2000; + const _Tp __psi_1 = -__numeric_constants<_Tp>::__gamma_e(); + const _Tp __psi_1pd = __psi(_Tp(1) + __ad); + const _Tp __psi_apd1 = __psi(__a + __d1); + const _Tp __psi_bpd1 = __psi(__b + __d1); + + _Tp __psi_term = __psi_1 + __psi_1pd - __psi_apd1 + - __psi_bpd1 - __ln_omx; + _Tp __fact = _Tp(1); + _Tp __sum2 = __psi_term; + _Tp __ln_pre2 = __lng_c + __d1 * __ln_omx + - __lng_ad2 - __lng_bd2; + + + int __j; + for (__j = 1; __j < __maxiter; ++__j) + { + + + const _Tp __term1 = _Tp(1) / _Tp(__j) + + _Tp(1) / (__ad + __j); + const _Tp __term2 = _Tp(1) / (__a + __d1 + _Tp(__j - 1)) + + _Tp(1) / (__b + __d1 + _Tp(__j - 1)); + __psi_term += __term1 - __term2; + __fact *= (__a + __d1 + _Tp(__j - 1)) + * (__b + __d1 + _Tp(__j - 1)) + / ((__ad + __j) * __j) * (_Tp(1) - __x); + const _Tp __delta = __fact * __psi_term; + __sum2 += __delta; + if (std::abs(__delta) < __eps * std::abs(__sum2)) + break; + } + if (__j == __maxiter) + std::__throw_runtime_error(("Sum F2 failed to converge " "in __hyperg_reflect") + ); + + if (__sum2 == _Tp(0)) + __F2 = _Tp(0); + else + __F2 = std::exp(__ln_pre2) * __sum2; + } + else + { + + + __F2 = _Tp(0); + } + + const _Tp __sgn_2 = (__intd % 2 == 1 ? -_Tp(1) : _Tp(1)); + const _Tp __F = __F1 + __sgn_2 * __F2; + + return __F; + } + else + { + + + + + bool __ok1 = true; + _Tp __sgn_g1ca = _Tp(0), __ln_g1ca = _Tp(0); + _Tp __sgn_g1cb = _Tp(0), __ln_g1cb = _Tp(0); + try + { + __sgn_g1ca = __log_gamma_sign(__c - __a); + __ln_g1ca = __log_gamma(__c - __a); + __sgn_g1cb = __log_gamma_sign(__c - __b); + __ln_g1cb = __log_gamma(__c - __b); + } + catch(...) + { + __ok1 = false; + } + + bool __ok2 = true; + _Tp __sgn_g2a = _Tp(0), __ln_g2a = _Tp(0); + _Tp __sgn_g2b = _Tp(0), __ln_g2b = _Tp(0); + try + { + __sgn_g2a = __log_gamma_sign(__a); + __ln_g2a = __log_gamma(__a); + __sgn_g2b = __log_gamma_sign(__b); + __ln_g2b = __log_gamma(__b); + } + catch(...) + { + __ok2 = false; + } + + const _Tp __sgn_gc = __log_gamma_sign(__c); + const _Tp __ln_gc = __log_gamma(__c); + const _Tp __sgn_gd = __log_gamma_sign(__d); + const _Tp __ln_gd = __log_gamma(__d); + const _Tp __sgn_gmd = __log_gamma_sign(-__d); + const _Tp __ln_gmd = __log_gamma(-__d); + + const _Tp __sgn1 = __sgn_gc * __sgn_gd * __sgn_g1ca * __sgn_g1cb; + const _Tp __sgn2 = __sgn_gc * __sgn_gmd * __sgn_g2a * __sgn_g2b; + + _Tp __pre1, __pre2; + if (__ok1 && __ok2) + { + _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb; + _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b + + __d * std::log(_Tp(1) - __x); + if (__ln_pre1 < __log_max && __ln_pre2 < __log_max) + { + __pre1 = std::exp(__ln_pre1); + __pre2 = std::exp(__ln_pre2); + __pre1 *= __sgn1; + __pre2 *= __sgn2; + } + else + { + std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect") + ); + } + } + else if (__ok1 && !__ok2) + { + _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb; + if (__ln_pre1 < __log_max) + { + __pre1 = std::exp(__ln_pre1); + __pre1 *= __sgn1; + __pre2 = _Tp(0); + } + else + { + std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect") + ); + } + } + else if (!__ok1 && __ok2) + { + _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b + + __d * std::log(_Tp(1) - __x); + if (__ln_pre2 < __log_max) + { + __pre1 = _Tp(0); + __pre2 = std::exp(__ln_pre2); + __pre2 *= __sgn2; + } + else + { + std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect") + ); + } + } + else + { + __pre1 = _Tp(0); + __pre2 = _Tp(0); + std::__throw_runtime_error(("Underflow of gamma functions " "in __hyperg_reflect") + ); + } + + const _Tp __F1 = __hyperg_series(__a, __b, _Tp(1) - __d, + _Tp(1) - __x); + const _Tp __F2 = __hyperg_series(__c - __a, __c - __b, _Tp(1) + __d, + _Tp(1) - __x); + + const _Tp __F = __pre1 * __F1 + __pre2 * __F2; + + return __F; + } + } +# 728 "/usr/include/c++/11/tr1/hypergeometric.tcc" 3 + template + _Tp + __hyperg(_Tp __a, _Tp __b, _Tp __c, _Tp __x) + { + + const _Tp __a_nint = ::std::nearbyint(__a); + const _Tp __b_nint = ::std::nearbyint(__b); + const _Tp __c_nint = ::std::nearbyint(__c); + + + + + + const _Tp __toler = _Tp(1000) * std::numeric_limits<_Tp>::epsilon(); + if (std::abs(__x) >= _Tp(1)) + std::__throw_domain_error(("Argument outside unit circle " "in __hyperg.") + ); + else if (__isnan(__a) || __isnan(__b) + || __isnan(__c) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__c_nint == __c && __c_nint <= _Tp(0)) + return std::numeric_limits<_Tp>::infinity(); + else if (std::abs(__c - __b) < __toler || std::abs(__c - __a) < __toler) + return std::pow(_Tp(1) - __x, __c - __a - __b); + else if (__a >= _Tp(0) && __b >= _Tp(0) && __c >= _Tp(0) + && __x >= _Tp(0) && __x < _Tp(0.995L)) + return __hyperg_series(__a, __b, __c, __x); + else if (std::abs(__a) < _Tp(10) && std::abs(__b) < _Tp(10)) + { + + + if (__a < _Tp(0) && std::abs(__a - __a_nint) < __toler) + return __hyperg_series(__a_nint, __b, __c, __x); + else if (__b < _Tp(0) && std::abs(__b - __b_nint) < __toler) + return __hyperg_series(__a, __b_nint, __c, __x); + else if (__x < -_Tp(0.25L)) + return __hyperg_luke(__a, __b, __c, __x); + else if (__x < _Tp(0.5L)) + return __hyperg_series(__a, __b, __c, __x); + else + if (std::abs(__c) > _Tp(10)) + return __hyperg_series(__a, __b, __c, __x); + else + return __hyperg_reflect(__a, __b, __c, __x); + } + else + return __hyperg_luke(__a, __b, __c, __x); + } + } + + + + + + +} +# 55 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/legendre_function.tcc" 1 3 +# 49 "/usr/include/c++/11/tr1/legendre_function.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/include/c++/11/tr1/legendre_function.tcc" 3 + namespace __detail + { +# 80 "/usr/include/c++/11/tr1/legendre_function.tcc" 3 + template + _Tp + __poly_legendre_p(unsigned int __l, _Tp __x) + { + + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x == +_Tp(1)) + return +_Tp(1); + else if (__x == -_Tp(1)) + return (__l % 2 == 1 ? -_Tp(1) : +_Tp(1)); + else + { + _Tp __p_lm2 = _Tp(1); + if (__l == 0) + return __p_lm2; + + _Tp __p_lm1 = __x; + if (__l == 1) + return __p_lm1; + + _Tp __p_l = 0; + for (unsigned int __ll = 2; __ll <= __l; ++__ll) + { + + + __p_l = _Tp(2) * __x * __p_lm1 - __p_lm2 + - (__x * __p_lm1 - __p_lm2) / _Tp(__ll); + __p_lm2 = __p_lm1; + __p_lm1 = __p_l; + } + + return __p_l; + } + } +# 136 "/usr/include/c++/11/tr1/legendre_function.tcc" 3 + template + _Tp + __assoc_legendre_p(unsigned int __l, unsigned int __m, _Tp __x, + _Tp __phase = _Tp(+1)) + { + + if (__m > __l) + return _Tp(0); + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__m == 0) + return __poly_legendre_p(__l, __x); + else + { + _Tp __p_mm = _Tp(1); + if (__m > 0) + { + + + _Tp __root = std::sqrt(_Tp(1) - __x) * std::sqrt(_Tp(1) + __x); + _Tp __fact = _Tp(1); + for (unsigned int __i = 1; __i <= __m; ++__i) + { + __p_mm *= __phase * __fact * __root; + __fact += _Tp(2); + } + } + if (__l == __m) + return __p_mm; + + _Tp __p_mp1m = _Tp(2 * __m + 1) * __x * __p_mm; + if (__l == __m + 1) + return __p_mp1m; + + _Tp __p_lm2m = __p_mm; + _Tp __P_lm1m = __p_mp1m; + _Tp __p_lm = _Tp(0); + for (unsigned int __j = __m + 2; __j <= __l; ++__j) + { + __p_lm = (_Tp(2 * __j - 1) * __x * __P_lm1m + - _Tp(__j + __m - 1) * __p_lm2m) / _Tp(__j - __m); + __p_lm2m = __P_lm1m; + __P_lm1m = __p_lm; + } + + return __p_lm; + } + } +# 214 "/usr/include/c++/11/tr1/legendre_function.tcc" 3 + template + _Tp + __sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta) + { + if (__isnan(__theta)) + return std::numeric_limits<_Tp>::quiet_NaN(); + + const _Tp __x = std::cos(__theta); + + if (__m > __l) + return _Tp(0); + else if (__m == 0) + { + _Tp __P = __poly_legendre_p(__l, __x); + _Tp __fact = std::sqrt(_Tp(2 * __l + 1) + / (_Tp(4) * __numeric_constants<_Tp>::__pi())); + __P *= __fact; + return __P; + } + else if (__x == _Tp(1) || __x == -_Tp(1)) + { + + return _Tp(0); + } + else + { + + + + + + const _Tp __sgn = ( __m % 2 == 1 ? -_Tp(1) : _Tp(1)); + const _Tp __y_mp1m_factor = __x * std::sqrt(_Tp(2 * __m + 3)); + + const _Tp __lncirc = ::std::log1p(-__x * __x); + + + + + + const _Tp __lnpoch = ::std::lgamma(_Tp(__m + _Tp(0.5L))) + - ::std::lgamma(_Tp(__m)); + + + + + const _Tp __lnpre_val = + -_Tp(0.25L) * __numeric_constants<_Tp>::__lnpi() + + _Tp(0.5L) * (__lnpoch + __m * __lncirc); + const _Tp __sr = std::sqrt((_Tp(2) + _Tp(1) / __m) + / (_Tp(4) * __numeric_constants<_Tp>::__pi())); + _Tp __y_mm = __sgn * __sr * std::exp(__lnpre_val); + _Tp __y_mp1m = __y_mp1m_factor * __y_mm; + + if (__l == __m) + return __y_mm; + else if (__l == __m + 1) + return __y_mp1m; + else + { + _Tp __y_lm = _Tp(0); + + + for (unsigned int __ll = __m + 2; __ll <= __l; ++__ll) + { + const _Tp __rat1 = _Tp(__ll - __m) / _Tp(__ll + __m); + const _Tp __rat2 = _Tp(__ll - __m - 1) / _Tp(__ll + __m - 1); + const _Tp __fact1 = std::sqrt(__rat1 * _Tp(2 * __ll + 1) + * _Tp(2 * __ll - 1)); + const _Tp __fact2 = std::sqrt(__rat1 * __rat2 * _Tp(2 * __ll + 1) + / _Tp(2 * __ll - 3)); + __y_lm = (__x * __y_mp1m * __fact1 + - (__ll + __m - 1) * __y_mm * __fact2) / _Tp(__ll - __m); + __y_mm = __y_mp1m; + __y_mp1m = __y_lm; + } + + return __y_lm; + } + } + } + } + + + + + + +} +# 56 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/modified_bessel_func.tcc" 1 3 +# 51 "/usr/include/c++/11/tr1/modified_bessel_func.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 65 "/usr/include/c++/11/tr1/modified_bessel_func.tcc" 3 + namespace __detail + { +# 83 "/usr/include/c++/11/tr1/modified_bessel_func.tcc" 3 + template + void + __bessel_ik(_Tp __nu, _Tp __x, + _Tp & __Inu, _Tp & __Knu, _Tp & __Ipnu, _Tp & __Kpnu) + { + if (__x == _Tp(0)) + { + if (__nu == _Tp(0)) + { + __Inu = _Tp(1); + __Ipnu = _Tp(0); + } + else if (__nu == _Tp(1)) + { + __Inu = _Tp(0); + __Ipnu = _Tp(0.5L); + } + else + { + __Inu = _Tp(0); + __Ipnu = _Tp(0); + } + __Knu = std::numeric_limits<_Tp>::infinity(); + __Kpnu = -std::numeric_limits<_Tp>::infinity(); + return; + } + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + const _Tp __fp_min = _Tp(10) * std::numeric_limits<_Tp>::epsilon(); + const int __max_iter = 15000; + const _Tp __x_min = _Tp(2); + + const int __nl = static_cast(__nu + _Tp(0.5L)); + + const _Tp __mu = __nu - __nl; + const _Tp __mu2 = __mu * __mu; + const _Tp __xi = _Tp(1) / __x; + const _Tp __xi2 = _Tp(2) * __xi; + _Tp __h = __nu * __xi; + if ( __h < __fp_min ) + __h = __fp_min; + _Tp __b = __xi2 * __nu; + _Tp __d = _Tp(0); + _Tp __c = __h; + int __i; + for ( __i = 1; __i <= __max_iter; ++__i ) + { + __b += __xi2; + __d = _Tp(1) / (__b + __d); + __c = __b + _Tp(1) / __c; + const _Tp __del = __c * __d; + __h *= __del; + if (std::abs(__del - _Tp(1)) < __eps) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Argument x too large " "in __bessel_ik; " "try asymptotic expansion.") + + ); + _Tp __Inul = __fp_min; + _Tp __Ipnul = __h * __Inul; + _Tp __Inul1 = __Inul; + _Tp __Ipnu1 = __Ipnul; + _Tp __fact = __nu * __xi; + for (int __l = __nl; __l >= 1; --__l) + { + const _Tp __Inutemp = __fact * __Inul + __Ipnul; + __fact -= __xi; + __Ipnul = __fact * __Inutemp + __Inul; + __Inul = __Inutemp; + } + _Tp __f = __Ipnul / __Inul; + _Tp __Kmu, __Knu1; + if (__x < __x_min) + { + const _Tp __x2 = __x / _Tp(2); + const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu; + const _Tp __fact = (std::abs(__pimu) < __eps + ? _Tp(1) : __pimu / std::sin(__pimu)); + _Tp __d = -std::log(__x2); + _Tp __e = __mu * __d; + const _Tp __fact2 = (std::abs(__e) < __eps + ? _Tp(1) : std::sinh(__e) / __e); + _Tp __gam1, __gam2, __gampl, __gammi; + __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi); + _Tp __ff = __fact + * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d); + _Tp __sum = __ff; + __e = std::exp(__e); + _Tp __p = __e / (_Tp(2) * __gampl); + _Tp __q = _Tp(1) / (_Tp(2) * __e * __gammi); + _Tp __c = _Tp(1); + __d = __x2 * __x2; + _Tp __sum1 = __p; + int __i; + for (__i = 1; __i <= __max_iter; ++__i) + { + __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2); + __c *= __d / __i; + __p /= __i - __mu; + __q /= __i + __mu; + const _Tp __del = __c * __ff; + __sum += __del; + const _Tp __del1 = __c * (__p - __i * __ff); + __sum1 += __del1; + if (std::abs(__del) < __eps * std::abs(__sum)) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Bessel k series failed to converge " "in __bessel_ik.") + ); + __Kmu = __sum; + __Knu1 = __sum1 * __xi2; + } + else + { + _Tp __b = _Tp(2) * (_Tp(1) + __x); + _Tp __d = _Tp(1) / __b; + _Tp __delh = __d; + _Tp __h = __delh; + _Tp __q1 = _Tp(0); + _Tp __q2 = _Tp(1); + _Tp __a1 = _Tp(0.25L) - __mu2; + _Tp __q = __c = __a1; + _Tp __a = -__a1; + _Tp __s = _Tp(1) + __q * __delh; + int __i; + for (__i = 2; __i <= __max_iter; ++__i) + { + __a -= 2 * (__i - 1); + __c = -__a * __c / __i; + const _Tp __qnew = (__q1 - __b * __q2) / __a; + __q1 = __q2; + __q2 = __qnew; + __q += __c * __qnew; + __b += _Tp(2); + __d = _Tp(1) / (__b + __a * __d); + __delh = (__b * __d - _Tp(1)) * __delh; + __h += __delh; + const _Tp __dels = __q * __delh; + __s += __dels; + if ( std::abs(__dels / __s) < __eps ) + break; + } + if (__i > __max_iter) + std::__throw_runtime_error(("Steed's method failed " "in __bessel_ik.") + ); + __h = __a1 * __h; + __Kmu = std::sqrt(__numeric_constants<_Tp>::__pi() / (_Tp(2) * __x)) + * std::exp(-__x) / __s; + __Knu1 = __Kmu * (__mu + __x + _Tp(0.5L) - __h) * __xi; + } + + _Tp __Kpmu = __mu * __xi * __Kmu - __Knu1; + _Tp __Inumu = __xi / (__f * __Kmu - __Kpmu); + __Inu = __Inumu * __Inul1 / __Inul; + __Ipnu = __Inumu * __Ipnu1 / __Inul; + for ( __i = 1; __i <= __nl; ++__i ) + { + const _Tp __Knutemp = (__mu + __i) * __xi2 * __Knu1 + __Kmu; + __Kmu = __Knu1; + __Knu1 = __Knutemp; + } + __Knu = __Kmu; + __Kpnu = __nu * __xi * __Kmu - __Knu1; + + return; + } +# 267 "/usr/include/c++/11/tr1/modified_bessel_func.tcc" 3 + template + _Tp + __cyl_bessel_i(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_i.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__x * __x < _Tp(10) * (__nu + _Tp(1))) + return __cyl_bessel_ij_series(__nu, __x, +_Tp(1), 200); + else + { + _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; + __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + return __I_nu; + } + } +# 303 "/usr/include/c++/11/tr1/modified_bessel_func.tcc" 3 + template + _Tp + __cyl_bessel_k(_Tp __nu, _Tp __x) + { + if (__nu < _Tp(0) || __x < _Tp(0)) + std::__throw_domain_error(("Bad argument " "in __cyl_bessel_k.") + ); + else if (__isnan(__nu) || __isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + { + _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; + __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + return __K_nu; + } + } +# 337 "/usr/include/c++/11/tr1/modified_bessel_func.tcc" 3 + template + void + __sph_bessel_ik(unsigned int __n, _Tp __x, + _Tp & __i_n, _Tp & __k_n, _Tp & __ip_n, _Tp & __kp_n) + { + const _Tp __nu = _Tp(__n) + _Tp(0.5L); + + _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu; + __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + + const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2() + / std::sqrt(__x); + + __i_n = __factor * __I_nu; + __k_n = __factor * __K_nu; + __ip_n = __factor * __Ip_nu - __i_n / (_Tp(2) * __x); + __kp_n = __factor * __Kp_nu - __k_n / (_Tp(2) * __x); + + return; + } +# 373 "/usr/include/c++/11/tr1/modified_bessel_func.tcc" 3 + template + void + __airy(_Tp __x, _Tp & __Ai, _Tp & __Bi, _Tp & __Aip, _Tp & __Bip) + { + const _Tp __absx = std::abs(__x); + const _Tp __rootx = std::sqrt(__absx); + const _Tp __z = _Tp(2) * __absx * __rootx / _Tp(3); + const _Tp _S_inf = std::numeric_limits<_Tp>::infinity(); + + if (__isnan(__x)) + __Bip = __Aip = __Bi = __Ai = std::numeric_limits<_Tp>::quiet_NaN(); + else if (__z == _S_inf) + { + __Aip = __Ai = _Tp(0); + __Bip = __Bi = _S_inf; + } + else if (__z == -_S_inf) + __Bip = __Aip = __Bi = __Ai = _Tp(0); + else if (__x > _Tp(0)) + { + _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu; + + __bessel_ik(_Tp(1) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + __Ai = __rootx * __K_nu + / (__numeric_constants<_Tp>::__sqrt3() + * __numeric_constants<_Tp>::__pi()); + __Bi = __rootx * (__K_nu / __numeric_constants<_Tp>::__pi() + + _Tp(2) * __I_nu / __numeric_constants<_Tp>::__sqrt3()); + + __bessel_ik(_Tp(2) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu); + __Aip = -__x * __K_nu + / (__numeric_constants<_Tp>::__sqrt3() + * __numeric_constants<_Tp>::__pi()); + __Bip = __x * (__K_nu / __numeric_constants<_Tp>::__pi() + + _Tp(2) * __I_nu + / __numeric_constants<_Tp>::__sqrt3()); + } + else if (__x < _Tp(0)) + { + _Tp __J_nu, __Jp_nu, __N_nu, __Np_nu; + + __bessel_jn(_Tp(1) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu); + __Ai = __rootx * (__J_nu + - __N_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2); + __Bi = -__rootx * (__N_nu + + __J_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2); + + __bessel_jn(_Tp(2) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu); + __Aip = __absx * (__N_nu / __numeric_constants<_Tp>::__sqrt3() + + __J_nu) / _Tp(2); + __Bip = __absx * (__J_nu / __numeric_constants<_Tp>::__sqrt3() + - __N_nu) / _Tp(2); + } + else + { + + + + __Ai = _Tp(0.35502805388781723926L); + __Bi = __Ai * __numeric_constants<_Tp>::__sqrt3(); + + + + + __Aip = -_Tp(0.25881940379280679840L); + __Bip = -__Aip * __numeric_constants<_Tp>::__sqrt3(); + } + + return; + } + } + + + + + +} +# 57 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/poly_hermite.tcc" 1 3 +# 42 "/usr/include/c++/11/tr1/poly_hermite.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 56 "/usr/include/c++/11/tr1/poly_hermite.tcc" 3 + namespace __detail + { +# 72 "/usr/include/c++/11/tr1/poly_hermite.tcc" 3 + template + _Tp + __poly_hermite_recursion(unsigned int __n, _Tp __x) + { + + _Tp __H_0 = 1; + if (__n == 0) + return __H_0; + + + _Tp __H_1 = 2 * __x; + if (__n == 1) + return __H_1; + + + _Tp __H_n, __H_nm1, __H_nm2; + unsigned int __i; + for (__H_nm2 = __H_0, __H_nm1 = __H_1, __i = 2; __i <= __n; ++__i) + { + __H_n = 2 * (__x * __H_nm1 - (__i - 1) * __H_nm2); + __H_nm2 = __H_nm1; + __H_nm1 = __H_n; + } + + return __H_n; + } +# 114 "/usr/include/c++/11/tr1/poly_hermite.tcc" 3 + template + inline _Tp + __poly_hermite(unsigned int __n, _Tp __x) + { + if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else + return __poly_hermite_recursion(__n, __x); + } + } + + + + + +} +# 58 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/poly_laguerre.tcc" 1 3 +# 44 "/usr/include/c++/11/tr1/poly_laguerre.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 60 "/usr/include/c++/11/tr1/poly_laguerre.tcc" 3 + namespace __detail + { +# 75 "/usr/include/c++/11/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre_large_n(unsigned __n, _Tpa __alpha1, _Tp __x) + { + const _Tp __a = -_Tp(__n); + const _Tp __b = _Tp(__alpha1) + _Tp(1); + const _Tp __eta = _Tp(2) * __b - _Tp(4) * __a; + const _Tp __cos2th = __x / __eta; + const _Tp __sin2th = _Tp(1) - __cos2th; + const _Tp __th = std::acos(std::sqrt(__cos2th)); + const _Tp __pre_h = __numeric_constants<_Tp>::__pi_2() + * __numeric_constants<_Tp>::__pi_2() + * __eta * __eta * __cos2th * __sin2th; + + + const _Tp __lg_b = ::std::lgamma(_Tp(__n) + __b); + const _Tp __lnfact = ::std::lgamma(_Tp(__n + 1)); + + + + + + _Tp __pre_term1 = _Tp(0.5L) * (_Tp(1) - __b) + * std::log(_Tp(0.25L) * __x * __eta); + _Tp __pre_term2 = _Tp(0.25L) * std::log(__pre_h); + _Tp __lnpre = __lg_b - __lnfact + _Tp(0.5L) * __x + + __pre_term1 - __pre_term2; + _Tp __ser_term1 = std::sin(__a * __numeric_constants<_Tp>::__pi()); + _Tp __ser_term2 = std::sin(_Tp(0.25L) * __eta + * (_Tp(2) * __th + - std::sin(_Tp(2) * __th)) + + __numeric_constants<_Tp>::__pi_4()); + _Tp __ser = __ser_term1 + __ser_term2; + + return std::exp(__lnpre) * __ser; + } +# 129 "/usr/include/c++/11/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre_hyperg(unsigned int __n, _Tpa __alpha1, _Tp __x) + { + const _Tp __b = _Tp(__alpha1) + _Tp(1); + const _Tp __mx = -__x; + const _Tp __tc_sgn = (__x < _Tp(0) ? _Tp(1) + : ((__n % 2 == 1) ? -_Tp(1) : _Tp(1))); + + _Tp __tc = _Tp(1); + const _Tp __ax = std::abs(__x); + for (unsigned int __k = 1; __k <= __n; ++__k) + __tc *= (__ax / __k); + + _Tp __term = __tc * __tc_sgn; + _Tp __sum = __term; + for (int __k = int(__n) - 1; __k >= 0; --__k) + { + __term *= ((__b + _Tp(__k)) / _Tp(int(__n) - __k)) + * _Tp(__k + 1) / __mx; + __sum += __term; + } + + return __sum; + } +# 185 "/usr/include/c++/11/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre_recursion(unsigned int __n, _Tpa __alpha1, _Tp __x) + { + + _Tp __l_0 = _Tp(1); + if (__n == 0) + return __l_0; + + + _Tp __l_1 = -__x + _Tp(1) + _Tp(__alpha1); + if (__n == 1) + return __l_1; + + + _Tp __l_n2 = __l_0; + _Tp __l_n1 = __l_1; + _Tp __l_n = _Tp(0); + for (unsigned int __nn = 2; __nn <= __n; ++__nn) + { + __l_n = (_Tp(2 * __nn - 1) + _Tp(__alpha1) - __x) + * __l_n1 / _Tp(__nn) + - (_Tp(__nn - 1) + _Tp(__alpha1)) * __l_n2 / _Tp(__nn); + __l_n2 = __l_n1; + __l_n1 = __l_n; + } + + return __l_n; + } +# 244 "/usr/include/c++/11/tr1/poly_laguerre.tcc" 3 + template + _Tp + __poly_laguerre(unsigned int __n, _Tpa __alpha1, _Tp __x) + { + if (__x < _Tp(0)) + std::__throw_domain_error(("Negative argument " "in __poly_laguerre.") + ); + + else if (__isnan(__x)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__n == 0) + return _Tp(1); + else if (__n == 1) + return _Tp(1) + _Tp(__alpha1) - __x; + else if (__x == _Tp(0)) + { + _Tp __prod = _Tp(__alpha1) + _Tp(1); + for (unsigned int __k = 2; __k <= __n; ++__k) + __prod *= (_Tp(__alpha1) + _Tp(__k)) / _Tp(__k); + return __prod; + } + else if (__n > 10000000 && _Tp(__alpha1) > -_Tp(1) + && __x < _Tp(2) * (_Tp(__alpha1) + _Tp(1)) + _Tp(4 * __n)) + return __poly_laguerre_large_n(__n, __alpha1, __x); + else if (_Tp(__alpha1) >= _Tp(0) + || (__x > _Tp(0) && _Tp(__alpha1) < -_Tp(__n + 1))) + return __poly_laguerre_recursion(__n, __alpha1, __x); + else + return __poly_laguerre_hyperg(__n, __alpha1, __x); + } +# 296 "/usr/include/c++/11/tr1/poly_laguerre.tcc" 3 + template + inline _Tp + __assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x) + { return __poly_laguerre(__n, __m, __x); } +# 316 "/usr/include/c++/11/tr1/poly_laguerre.tcc" 3 + template + inline _Tp + __laguerre(unsigned int __n, _Tp __x) + { return __poly_laguerre(__n, 0, __x); } + } + + + + + + +} +# 59 "/usr/include/c++/11/bits/specfun.h" 2 3 +# 1 "/usr/include/c++/11/tr1/riemann_zeta.tcc" 1 3 +# 47 "/usr/include/c++/11/tr1/riemann_zeta.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 63 "/usr/include/c++/11/tr1/riemann_zeta.tcc" 3 + namespace __detail + { +# 78 "/usr/include/c++/11/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_sum(_Tp __s) + { + + if (__s < _Tp(1)) + std::__throw_domain_error(("Bad argument in zeta sum.")); + + const unsigned int max_iter = 10000; + _Tp __zeta = _Tp(0); + for (unsigned int __k = 1; __k < max_iter; ++__k) + { + _Tp __term = std::pow(static_cast<_Tp>(__k), -__s); + if (__term < std::numeric_limits<_Tp>::epsilon()) + { + break; + } + __zeta += __term; + } + + return __zeta; + } +# 115 "/usr/include/c++/11/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_alt(_Tp __s) + { + _Tp __sgn = _Tp(1); + _Tp __zeta = _Tp(0); + for (unsigned int __i = 1; __i < 10000000; ++__i) + { + _Tp __term = __sgn / std::pow(__i, __s); + if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon()) + break; + __zeta += __term; + __sgn *= _Tp(-1); + } + __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s); + + return __zeta; + } +# 157 "/usr/include/c++/11/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_glob(_Tp __s) + { + _Tp __zeta = _Tp(0); + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + + + if (__s < _Tp(0)) + { + + if (::std::fmod(__s,_Tp(2)) == _Tp(0)) + return _Tp(0); + else + + { + _Tp __zeta = __riemann_zeta_glob(_Tp(1) - __s); + __zeta *= std::pow(_Tp(2) + * __numeric_constants<_Tp>::__pi(), __s) + * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) + + * std::exp(::std::lgamma(_Tp(1) - __s)) + + + + / __numeric_constants<_Tp>::__pi(); + return __zeta; + } + } + + _Tp __num = _Tp(0.5L); + const unsigned int __maxit = 10000; + for (unsigned int __i = 0; __i < __maxit; ++__i) + { + bool __punt = false; + _Tp __sgn = _Tp(1); + _Tp __term = _Tp(0); + for (unsigned int __j = 0; __j <= __i; ++__j) + { + + _Tp __bincoeff = ::std::lgamma(_Tp(1 + __i)) + - ::std::lgamma(_Tp(1 + __j)) + - ::std::lgamma(_Tp(1 + __i - __j)); + + + + + + if (__bincoeff > __max_bincoeff) + { + + __punt = true; + break; + } + __bincoeff = std::exp(__bincoeff); + __term += __sgn * __bincoeff * std::pow(_Tp(1 + __j), -__s); + __sgn *= _Tp(-1); + } + if (__punt) + break; + __term *= __num; + __zeta += __term; + if (std::abs(__term/__zeta) < __eps) + break; + __num *= _Tp(0.5L); + } + + __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s); + + return __zeta; + } +# 252 "/usr/include/c++/11/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta_product(_Tp __s) + { + static const _Tp __prime[] = { + _Tp(2), _Tp(3), _Tp(5), _Tp(7), _Tp(11), _Tp(13), _Tp(17), _Tp(19), + _Tp(23), _Tp(29), _Tp(31), _Tp(37), _Tp(41), _Tp(43), _Tp(47), + _Tp(53), _Tp(59), _Tp(61), _Tp(67), _Tp(71), _Tp(73), _Tp(79), + _Tp(83), _Tp(89), _Tp(97), _Tp(101), _Tp(103), _Tp(107), _Tp(109) + }; + static const unsigned int __num_primes = sizeof(__prime) / sizeof(_Tp); + + _Tp __zeta = _Tp(1); + for (unsigned int __i = 0; __i < __num_primes; ++__i) + { + const _Tp __fact = _Tp(1) - std::pow(__prime[__i], -__s); + __zeta *= __fact; + if (_Tp(1) - __fact < std::numeric_limits<_Tp>::epsilon()) + break; + } + + __zeta = _Tp(1) / __zeta; + + return __zeta; + } +# 293 "/usr/include/c++/11/tr1/riemann_zeta.tcc" 3 + template + _Tp + __riemann_zeta(_Tp __s) + { + if (__isnan(__s)) + return std::numeric_limits<_Tp>::quiet_NaN(); + else if (__s == _Tp(1)) + return std::numeric_limits<_Tp>::infinity(); + else if (__s < -_Tp(19)) + { + _Tp __zeta = __riemann_zeta_product(_Tp(1) - __s); + __zeta *= std::pow(_Tp(2) * __numeric_constants<_Tp>::__pi(), __s) + * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) + + * std::exp(::std::lgamma(_Tp(1) - __s)) + + + + / __numeric_constants<_Tp>::__pi(); + return __zeta; + } + else if (__s < _Tp(20)) + { + + bool __glob = true; + if (__glob) + return __riemann_zeta_glob(__s); + else + { + if (__s > _Tp(1)) + return __riemann_zeta_sum(__s); + else + { + _Tp __zeta = std::pow(_Tp(2) + * __numeric_constants<_Tp>::__pi(), __s) + * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) + + * ::std::tgamma(_Tp(1) - __s) + + + + * __riemann_zeta_sum(_Tp(1) - __s); + return __zeta; + } + } + } + else + return __riemann_zeta_product(__s); + } +# 365 "/usr/include/c++/11/tr1/riemann_zeta.tcc" 3 + template + _Tp + __hurwitz_zeta_glob(_Tp __a, _Tp __s) + { + _Tp __zeta = _Tp(0); + + const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); + + const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10 + * std::log(_Tp(10)) - _Tp(1); + + const unsigned int __maxit = 10000; + for (unsigned int __i = 0; __i < __maxit; ++__i) + { + bool __punt = false; + _Tp __sgn = _Tp(1); + _Tp __term = _Tp(0); + for (unsigned int __j = 0; __j <= __i; ++__j) + { + + _Tp __bincoeff = ::std::lgamma(_Tp(1 + __i)) + - ::std::lgamma(_Tp(1 + __j)) + - ::std::lgamma(_Tp(1 + __i - __j)); + + + + + + if (__bincoeff > __max_bincoeff) + { + + __punt = true; + break; + } + __bincoeff = std::exp(__bincoeff); + __term += __sgn * __bincoeff * std::pow(_Tp(__a + __j), -__s); + __sgn *= _Tp(-1); + } + if (__punt) + break; + __term /= _Tp(__i + 1); + if (std::abs(__term / __zeta) < __eps) + break; + __zeta += __term; + } + + __zeta /= __s - _Tp(1); + + return __zeta; + } +# 430 "/usr/include/c++/11/tr1/riemann_zeta.tcc" 3 + template + inline _Tp + __hurwitz_zeta(_Tp __a, _Tp __s) + { return __hurwitz_zeta_glob(__a, __s); } + } + + + + + + +} +# 60 "/usr/include/c++/11/bits/specfun.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 205 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + assoc_laguerref(unsigned int __n, unsigned int __m, float __x) + { return __detail::__assoc_laguerre(__n, __m, __x); } + + + + + + + + inline long double + assoc_laguerrel(unsigned int __n, unsigned int __m, long double __x) + { return __detail::__assoc_laguerre(__n, __m, __x); } +# 250 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__assoc_laguerre<__type>(__n, __m, __x); + } +# 266 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + assoc_legendref(unsigned int __l, unsigned int __m, float __x) + { return __detail::__assoc_legendre_p(__l, __m, __x); } + + + + + + + inline long double + assoc_legendrel(unsigned int __l, unsigned int __m, long double __x) + { return __detail::__assoc_legendre_p(__l, __m, __x); } +# 296 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__assoc_legendre_p<__type>(__l, __m, __x); + } +# 311 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + betaf(float __a, float __b) + { return __detail::__beta(__a, __b); } + + + + + + + + inline long double + betal(long double __a, long double __b) + { return __detail::__beta(__a, __b); } +# 341 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type + beta(_Tpa __a, _Tpb __b) + { + typedef typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type __type; + return __detail::__beta<__type>(__a, __b); + } +# 357 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + comp_ellint_1f(float __k) + { return __detail::__comp_ellint_1(__k); } + + + + + + + + inline long double + comp_ellint_1l(long double __k) + { return __detail::__comp_ellint_1(__k); } +# 389 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + comp_ellint_1(_Tp __k) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__comp_ellint_1<__type>(__k); + } +# 405 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + comp_ellint_2f(float __k) + { return __detail::__comp_ellint_2(__k); } + + + + + + + + inline long double + comp_ellint_2l(long double __k) + { return __detail::__comp_ellint_2(__k); } +# 436 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + comp_ellint_2(_Tp __k) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__comp_ellint_2<__type>(__k); + } +# 452 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + comp_ellint_3f(float __k, float __nu) + { return __detail::__comp_ellint_3(__k, __nu); } + + + + + + + + inline long double + comp_ellint_3l(long double __k, long double __nu) + { return __detail::__comp_ellint_3(__k, __nu); } +# 487 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type + comp_ellint_3(_Tp __k, _Tpn __nu) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type; + return __detail::__comp_ellint_3<__type>(__k, __nu); + } +# 503 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + cyl_bessel_if(float __nu, float __x) + { return __detail::__cyl_bessel_i(__nu, __x); } + + + + + + + + inline long double + cyl_bessel_il(long double __nu, long double __x) + { return __detail::__cyl_bessel_i(__nu, __x); } +# 533 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_bessel_i(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_bessel_i<__type>(__nu, __x); + } +# 549 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + cyl_bessel_jf(float __nu, float __x) + { return __detail::__cyl_bessel_j(__nu, __x); } + + + + + + + + inline long double + cyl_bessel_jl(long double __nu, long double __x) + { return __detail::__cyl_bessel_j(__nu, __x); } +# 579 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_bessel_j(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_bessel_j<__type>(__nu, __x); + } +# 595 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + cyl_bessel_kf(float __nu, float __x) + { return __detail::__cyl_bessel_k(__nu, __x); } + + + + + + + + inline long double + cyl_bessel_kl(long double __nu, long double __x) + { return __detail::__cyl_bessel_k(__nu, __x); } +# 631 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_bessel_k(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_bessel_k<__type>(__nu, __x); + } +# 647 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + cyl_neumannf(float __nu, float __x) + { return __detail::__cyl_neumann_n(__nu, __x); } + + + + + + + + inline long double + cyl_neumannl(long double __nu, long double __x) + { return __detail::__cyl_neumann_n(__nu, __x); } +# 679 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type + cyl_neumann(_Tpnu __nu, _Tp __x) + { + typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; + return __detail::__cyl_neumann_n<__type>(__nu, __x); + } +# 695 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + ellint_1f(float __k, float __phi) + { return __detail::__ellint_1(__k, __phi); } + + + + + + + + inline long double + ellint_1l(long double __k, long double __phi) + { return __detail::__ellint_1(__k, __phi); } +# 727 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type + ellint_1(_Tp __k, _Tpp __phi) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type; + return __detail::__ellint_1<__type>(__k, __phi); + } +# 743 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + ellint_2f(float __k, float __phi) + { return __detail::__ellint_2(__k, __phi); } + + + + + + + + inline long double + ellint_2l(long double __k, long double __phi) + { return __detail::__ellint_2(__k, __phi); } +# 775 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type + ellint_2(_Tp __k, _Tpp __phi) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type; + return __detail::__ellint_2<__type>(__k, __phi); + } +# 791 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + ellint_3f(float __k, float __nu, float __phi) + { return __detail::__ellint_3(__k, __nu, __phi); } + + + + + + + + inline long double + ellint_3l(long double __k, long double __nu, long double __phi) + { return __detail::__ellint_3(__k, __nu, __phi); } +# 828 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type + ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi) + { + typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __type; + return __detail::__ellint_3<__type>(__k, __nu, __phi); + } +# 843 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + expintf(float __x) + { return __detail::__expint(__x); } + + + + + + + + inline long double + expintl(long double __x) + { return __detail::__expint(__x); } +# 868 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + expint(_Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__expint<__type>(__x); + } +# 884 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + hermitef(unsigned int __n, float __x) + { return __detail::__poly_hermite(__n, __x); } + + + + + + + + inline long double + hermitel(unsigned int __n, long double __x) + { return __detail::__poly_hermite(__n, __x); } +# 916 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + hermite(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__poly_hermite<__type>(__n, __x); + } +# 932 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + laguerref(unsigned int __n, float __x) + { return __detail::__laguerre(__n, __x); } + + + + + + + + inline long double + laguerrel(unsigned int __n, long double __x) + { return __detail::__laguerre(__n, __x); } +# 960 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + laguerre(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__laguerre<__type>(__n, __x); + } +# 976 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + legendref(unsigned int __l, float __x) + { return __detail::__poly_legendre_p(__l, __x); } + + + + + + + + inline long double + legendrel(unsigned int __l, long double __x) + { return __detail::__poly_legendre_p(__l, __x); } +# 1005 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + legendre(unsigned int __l, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__poly_legendre_p<__type>(__l, __x); + } +# 1021 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + riemann_zetaf(float __s) + { return __detail::__riemann_zeta(__s); } + + + + + + + + inline long double + riemann_zetal(long double __s) + { return __detail::__riemann_zeta(__s); } +# 1056 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + riemann_zeta(_Tp __s) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__riemann_zeta<__type>(__s); + } +# 1072 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + sph_besself(unsigned int __n, float __x) + { return __detail::__sph_bessel(__n, __x); } + + + + + + + + inline long double + sph_bessell(unsigned int __n, long double __x) + { return __detail::__sph_bessel(__n, __x); } +# 1100 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + sph_bessel(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__sph_bessel<__type>(__n, __x); + } +# 1116 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + sph_legendref(unsigned int __l, unsigned int __m, float __theta) + { return __detail::__sph_legendre(__l, __m, __theta); } +# 1127 "/usr/include/c++/11/bits/specfun.h" 3 + inline long double + sph_legendrel(unsigned int __l, unsigned int __m, long double __theta) + { return __detail::__sph_legendre(__l, __m, __theta); } +# 1147 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__sph_legendre<__type>(__l, __m, __theta); + } +# 1163 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + sph_neumannf(unsigned int __n, float __x) + { return __detail::__sph_neumann(__n, __x); } + + + + + + + + inline long double + sph_neumannl(unsigned int __n, long double __x) + { return __detail::__sph_neumann(__n, __x); } +# 1191 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote<_Tp>::__type + sph_neumann(unsigned int __n, _Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __detail::__sph_neumann<__type>(__n, __x); + } + + + + +} + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 1218 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + airy_aif(float __x) + { + float __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Ai; + } + + + + + inline long double + airy_ail(long double __x) + { + long double __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Ai; + } + + + + + template + inline typename __gnu_cxx::__promote<_Tp>::__type + airy_ai(_Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + __type __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy<__type>(__x, __Ai, __Bi, __Aip, __Bip); + return __Ai; + } + + + + + inline float + airy_bif(float __x) + { + float __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Bi; + } + + + + + inline long double + airy_bil(long double __x) + { + long double __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy(__x, __Ai, __Bi, __Aip, __Bip); + return __Bi; + } + + + + + template + inline typename __gnu_cxx::__promote<_Tp>::__type + airy_bi(_Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + __type __Ai, __Bi, __Aip, __Bip; + std::__detail::__airy<__type>(__x, __Ai, __Bi, __Aip, __Bip); + return __Bi; + } +# 1294 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + conf_hypergf(float __a, float __c, float __x) + { return std::__detail::__conf_hyperg(__a, __c, __x); } +# 1305 "/usr/include/c++/11/bits/specfun.h" 3 + inline long double + conf_hypergl(long double __a, long double __c, long double __x) + { return std::__detail::__conf_hyperg(__a, __c, __x); } +# 1325 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type + conf_hyperg(_Tpa __a, _Tpc __c, _Tp __x) + { + typedef typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type __type; + return std::__detail::__conf_hyperg<__type>(__a, __c, __x); + } +# 1342 "/usr/include/c++/11/bits/specfun.h" 3 + inline float + hypergf(float __a, float __b, float __c, float __x) + { return std::__detail::__hyperg(__a, __b, __c, __x); } +# 1353 "/usr/include/c++/11/bits/specfun.h" 3 + inline long double + hypergl(long double __a, long double __b, long double __c, long double __x) + { return std::__detail::__hyperg(__a, __b, __c, __x); } +# 1374 "/usr/include/c++/11/bits/specfun.h" 3 + template + inline typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type + hyperg(_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x) + { + typedef typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp> + ::__type __type; + return std::__detail::__hyperg<__type>(__a, __b, __c, __x); + } + + + +} + + +#pragma GCC visibility pop +# 1936 "/usr/include/c++/11/cmath" 2 3 + + +} +# 37 "/usr/include/c++/11/math.h" 2 3 + +using std::abs; +using std::acos; +using std::asin; +using std::atan; +using std::atan2; +using std::cos; +using std::sin; +using std::tan; +using std::cosh; +using std::sinh; +using std::tanh; +using std::exp; +using std::frexp; +using std::ldexp; +using std::log; +using std::log10; +using std::modf; +using std::pow; +using std::sqrt; +using std::ceil; +using std::fabs; +using std::floor; +using std::fmod; + + +using std::fpclassify; +using std::isfinite; +using std::isinf; +using std::isnan; +using std::isnormal; +using std::signbit; +using std::isgreater; +using std::isgreaterequal; +using std::isless; +using std::islessequal; +using std::islessgreater; +using std::isunordered; + + + +using std::acosh; +using std::asinh; +using std::atanh; +using std::cbrt; +using std::copysign; +using std::erf; +using std::erfc; +using std::exp2; +using std::expm1; +using std::fdim; +using std::fma; +using std::fmax; +using std::fmin; +using std::hypot; +using std::ilogb; +using std::lgamma; +using std::llrint; +using std::llround; +using std::log1p; +using std::log2; +using std::logb; +using std::lrint; +using std::lround; +using std::nearbyint; +using std::nextafter; +using std::nexttoward; +using std::remainder; +using std::remquo; +using std::rint; +using std::round; +using std::scalbln; +using std::scalbn; +using std::tgamma; +using std::trunc; +# 4572 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 1 "/usr/include/c++/11/stdlib.h" 1 3 +# 4573 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 + + +# 1 "/usr/include/c++/11/cmath" 1 3 +# 39 "/usr/include/c++/11/cmath" 3 + +# 40 "/usr/include/c++/11/cmath" 3 +# 4576 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 1 "/usr/include/c++/11/cstdlib" 1 3 +# 39 "/usr/include/c++/11/cstdlib" 3 + +# 40 "/usr/include/c++/11/cstdlib" 3 +# 4577 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 4647 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" + +# 4647 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool signbit(float x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool signbit(double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool signbit(long double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isfinite(float x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isfinite(double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isfinite(long double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isnan(float x); + + + + +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isnan(double x); + +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isnan(long double x); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isinf(float x); + + + + +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isinf(double x); + +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr bool isinf(long double x); +} +# 4826 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std +{ + template extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) T __pow_helper(T, int); + template extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) T __cmath_power(T, unsigned int); +} + +using std::abs; +using std::fabs; +using std::ceil; +using std::floor; +using std::sqrt; + +using std::pow; + +using std::log; +using std::log10; +using std::fmod; +using std::modf; +using std::exp; +using std::frexp; +using std::ldexp; +using std::asin; +using std::sin; +using std::sinh; +using std::acos; +using std::cos; +using std::cosh; +using std::atan; +using std::atan2; +using std::tan; +using std::tanh; +# 5237 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +# 5246 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int abs(long long int); +# 5266 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int abs(long int a); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float abs(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double abs(double); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float fabs(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float ceil(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float floor(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sqrt(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float pow(float, float); + + + + +template +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) +typename __gnu_cxx::__promote_2<_Tp, _Up>::__type pow(_Tp, _Up); + + + + + + + +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float log(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float log10(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float fmod(float, float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float modf(float, float*); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float exp(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float frexp(float, int*); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float ldexp(float, int); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float asin(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sin(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sinh(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float acos(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cos(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cosh(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float atan(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float atan2(float, float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float tan(float); +extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float tanh(float); +# 5391 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +} +# 5497 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +namespace std { +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float logb(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr int ilogb(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float scalbn(float a, int b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float scalbln(float a, long int b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float exp2(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float expm1(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float log2(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float log1p(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float acosh(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float asinh(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float atanh(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float hypot(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float cbrt(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float erf(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float erfc(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float lgamma(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float tgamma(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float copysign(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float nextafter(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float remainder(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float remquo(float a, float b, int *quo); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float round(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr long int lround(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr long long int llround(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float trunc(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float rint(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr long int lrint(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr long long int llrint(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float nearbyint(float a); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float fdim(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float fma(float a, float b, float c); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float fmax(float a, float b); +__attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) constexpr float fmin(float a, float b); +} +# 5636 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float exp10(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float rsqrt(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float rcbrt(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sinpi(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cospi(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void sincospi(const float a, float *const sptr, float *const cptr); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void sincos(const float a, float *const sptr, float *const cptr); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float j0(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float j1(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float jn(const int n, const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float y0(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float y1(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float yn(const int n, const float a); + +static inline __attribute__((device)) __attribute__((cudart_builtin)) float cyl_bessel_i0(const float a); + +static inline __attribute__((device)) __attribute__((cudart_builtin)) float cyl_bessel_i1(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erfinv(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erfcinv(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float normcdfinv(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float normcdf(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erfcx(const float a); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double copysign(const double a, const float b); + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double copysign(const float a, const double b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int min(const unsigned int a, const unsigned int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int min(const int a, const unsigned int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int min(const unsigned int a, const int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int min(const long int a, const long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int min(const unsigned long int a, const unsigned long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int min(const long int a, const unsigned long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int min(const unsigned long int a, const long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int min(const long long int a, const long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int min(const unsigned long long int a, const unsigned long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int min(const long long int a, const unsigned long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int min(const unsigned long long int a, const long long int b); +# 5777 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float min(const float a, const float b); +# 5788 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(const double a, const double b); +# 5798 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(const float a, const double b); +# 5808 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(const double a, const float b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int max(const unsigned int a, const unsigned int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int max(const int a, const unsigned int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int max(const unsigned int a, const int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int max(const long int a, const long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int max(const unsigned long int a, const unsigned long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int max(const long int a, const unsigned long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int max(const unsigned long int a, const long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int max(const long long int a, const long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int max(const unsigned long long int a, const unsigned long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int max(const long long int a, const unsigned long long int b); + + + + + + + +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int max(const unsigned long long int a, const long long int b); +# 5907 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float max(const float a, const float b); +# 5918 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(const double a, const double b); +# 5928 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(const float a, const double b); +# 5938 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(const double a, const float b); +# 5950 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +extern "C"{ +inline __attribute__((device)) void *__nv_aligned_device_malloc(size_t size, size_t align) +{ + __attribute__((device)) void *__nv_aligned_device_malloc_impl(size_t, size_t); + return __nv_aligned_device_malloc_impl(size, align); +} +} +# 6240 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" 1 +# 77 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 78 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 79 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" 2 +# 758 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" +static inline __attribute__((host)) __attribute__((device)) float exp10(const float a) +{ + return exp10f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float rsqrt(const float a) +{ + return rsqrtf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float rcbrt(const float a) +{ + return rcbrtf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float sinpi(const float a) +{ + return sinpif(a); +} + +static inline __attribute__((host)) __attribute__((device)) float cospi(const float a) +{ + return cospif(a); +} + +static inline __attribute__((host)) __attribute__((device)) void sincospi(const float a, float *const sptr, float *const cptr) +{ + sincospif(a, sptr, cptr); +} + +static inline __attribute__((host)) __attribute__((device)) void sincos(const float a, float *const sptr, float *const cptr) +{ + sincosf(a, sptr, cptr); +} + +static inline __attribute__((host)) __attribute__((device)) float j0(const float a) +{ + return j0f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float j1(const float a) +{ + return j1f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float jn(const int n, const float a) +{ + return jnf(n, a); +} + +static inline __attribute__((host)) __attribute__((device)) float y0(const float a) +{ + return y0f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float y1(const float a) +{ + return y1f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float yn(const int n, const float a) +{ + return ynf(n, a); +} + +static inline __attribute__((device)) float cyl_bessel_i0(const float a) +{ + return cyl_bessel_i0f(a); +} + +static inline __attribute__((device)) float cyl_bessel_i1(const float a) +{ + return cyl_bessel_i1f(a); +} + +static inline __attribute__((host)) __attribute__((device)) float erfinv(const float a) +{ + return erfinvf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float erfcinv(const float a) +{ + return erfcinvf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float normcdfinv(const float a) +{ + return normcdfinvf(a); +} + +static inline __attribute__((host)) __attribute__((device)) float normcdf(const float a) +{ + return normcdff(a); +} + +static inline __attribute__((host)) __attribute__((device)) float erfcx(const float a) +{ + return erfcxf(a); +} + +static inline __attribute__((host)) __attribute__((device)) double copysign(const double a, const float b) +{ + return copysign(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) double copysign(const float a, const double b) +{ + return copysign(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int min(const unsigned int a, const unsigned int b) +{ + return umin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int min(const int a, const unsigned int b) +{ + return umin(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int min(const unsigned int a, const int b) +{ + return umin(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) long int min(const long int a, const long int b) +{ + long int retval; + + + + + + + if (sizeof(long int) == sizeof(int)) { + + + + retval = static_cast(min(static_cast(a), static_cast(b))); + } else { + retval = static_cast(llmin(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int min(const unsigned long int a, const unsigned long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umin(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmin(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int min(const long int a, const unsigned long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umin(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmin(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int min(const unsigned long int a, const long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umin(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmin(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) long long int min(const long long int a, const long long int b) +{ + return llmin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(const unsigned long long int a, const unsigned long long int b) +{ + return ullmin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(const long long int a, const unsigned long long int b) +{ + return ullmin(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(const unsigned long long int a, const long long int b) +{ + return ullmin(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) float min(const float a, const float b) +{ + return fminf(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double min(const double a, const double b) +{ + return fmin(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double min(const float a, const double b) +{ + return fmin(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) double min(const double a, const float b) +{ + return fmin(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int max(const unsigned int a, const unsigned int b) +{ + return umax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int max(const int a, const unsigned int b) +{ + return umax(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned int max(const unsigned int a, const int b) +{ + return umax(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) long int max(const long int a, const long int b) +{ + long int retval; + + + + + + if (sizeof(long int) == sizeof(int)) { + + + + retval = static_cast(max(static_cast(a), static_cast(b))); + } else { + retval = static_cast(llmax(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int max(const unsigned long int a, const unsigned long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umax(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmax(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int max(const long int a, const unsigned long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umax(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmax(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long int max(const unsigned long int a, const long int b) +{ + unsigned long int retval; + + + + + if (sizeof(unsigned long int) == sizeof(unsigned int)) { + + + + retval = static_cast(umax(static_cast(a), static_cast(b))); + } else { + retval = static_cast(ullmax(static_cast(a), static_cast(b))); + } + return retval; +} + +static inline __attribute__((host)) __attribute__((device)) long long int max(const long long int a, const long long int b) +{ + return llmax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(const unsigned long long int a, const unsigned long long int b) +{ + return ullmax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(const long long int a, const unsigned long long int b) +{ + return ullmax(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(const unsigned long long int a, const long long int b) +{ + return ullmax(a, static_cast(b)); +} + +static inline __attribute__((host)) __attribute__((device)) float max(const float a, const float b) +{ + return fmaxf(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double max(const double a, const double b) +{ + return fmax(a, b); +} + +static inline __attribute__((host)) __attribute__((device)) double max(const float a, const double b) +{ + return fmax(static_cast(a), b); +} + +static inline __attribute__((host)) __attribute__((device)) double max(const double a, const float b) +{ + return fmax(a, static_cast(b)); +} +# 1135 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.hpp" +inline __attribute__((host)) __attribute__((device)) int min(const int a, const int b) +{ + return (a < b) ? a : b; +} + +inline __attribute__((host)) __attribute__((device)) unsigned int umin(const unsigned int a, const unsigned int b) +{ + return (a < b) ? a : b; +} + +inline __attribute__((host)) __attribute__((device)) long long int llmin(const long long int a, const long long int b) +{ + return (a < b) ? a : b; +} + +inline __attribute__((host)) __attribute__((device)) unsigned long long int ullmin(const unsigned long long int a, + const unsigned long long int b) +{ + return (a < b) ? a : b; +} + +inline __attribute__((host)) __attribute__((device)) int max(const int a, const int b) +{ + return (a > b) ? a : b; +} + +inline __attribute__((host)) __attribute__((device)) unsigned int umax(const unsigned int a, const unsigned int b) +{ + return (a > b) ? a : b; +} + +inline __attribute__((host)) __attribute__((device)) long long int llmax(const long long int a, const long long int b) +{ + return (a > b) ? a : b; +} + +inline __attribute__((host)) __attribute__((device)) unsigned long long int ullmax(const unsigned long long int a, + const unsigned long long int b) +{ + return (a > b) ? a : b; +} +# 6241 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h" 2 +# 304 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/common_functions.h" 2 +# 118 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 1 +# 81 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 82 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/device_types.h" 1 +# 83 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 84 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 95 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +extern "C" +{ +# 106 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __mulhi(int x, int y); +# 116 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __umulhi(unsigned int x, unsigned int y); +# 126 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __mul64hi(long long int x, long long int y); +# 136 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __umul64hi(unsigned long long int x, unsigned long long int y); +# 145 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int_as_float(int x); +# 154 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float_as_int(float x); +# 163 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint_as_float(unsigned int x); +# 172 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float_as_uint(float x); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __syncthreads(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __prof_trigger(int); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __threadfence(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __threadfence_block(void); +__attribute__((device)) __attribute__((cudart_builtin)) + +__attribute__((__noreturn__)) + + + +__attribute__((device_builtin)) void __trap(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __brkpt(); +# 196 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __saturatef(float x); +# 215 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __sad(int x, int y, unsigned int z); +# 233 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __usad(unsigned int x, unsigned int y, unsigned int z); +# 243 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __mul24(int x, int y); +# 253 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __umul24(unsigned int x, unsigned int y); +# 269 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float fdividef(float x, float y); +# 289 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdividef(float x, float y); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) double fdivide(double x, double y); +# 303 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __sinf(float x) +# 303 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 303 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 315 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __cosf(float x) +# 315 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 315 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 328 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __tanf(float x) +# 328 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 328 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 341 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void __sincosf(float x, float *sptr, float *cptr) +# 341 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 341 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 359 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __expf(float x) +# 359 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 359 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 373 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __exp10f(float x) +# 373 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 373 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 386 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __log2f(float x) +# 386 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 386 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 399 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __log10f(float x) +# 399 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 399 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 416 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __logf(float x) +# 416 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 416 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 431 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __powf(float x, float y) +# 431 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 3 4 + noexcept (true) +# 431 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" + ; +# 441 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rn(float x); +# 451 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rz(float x); +# 461 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_ru(float); +# 471 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rd(float x); +# 481 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rn(float x); +# 491 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rz(float x); +# 501 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_ru(float x); +# 511 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rd(float x); +# 520 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rn(int x); +# 529 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rz(int x); +# 538 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_ru(int x); +# 547 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rd(int x); +# 556 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rn(unsigned int x); +# 565 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rz(unsigned int x); +# 574 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_ru(unsigned int x); +# 583 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rd(unsigned int x); +# 593 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rn(float x); +# 603 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rz(float x); +# 613 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_ru(float x); +# 623 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rd(float x); +# 633 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rn(float x); +# 643 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rz(float x); +# 653 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_ru(float x); +# 663 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rd(float x); +# 672 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rn(long long int x); +# 681 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rz(long long int x); +# 690 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_ru(long long int x); +# 699 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rd(long long int x); +# 708 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rn(unsigned long long int x); +# 717 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rz(unsigned long long int x); +# 726 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_ru(unsigned long long int x); +# 735 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rd(unsigned long long int x); +# 754 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rn(float x, float y); +# 773 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rz(float x, float y); +# 792 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_ru(float x, float y); +# 811 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rd(float x, float y); +# 830 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rn(float x, float y); +# 849 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rz(float x, float y); +# 868 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_ru(float x, float y); +# 887 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rd(float x, float y); +# 905 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rn(float x, float y); +# 923 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rz(float x, float y); +# 941 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_ru(float x, float y); +# 959 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rd(float x, float y); +# 1003 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rn(float x, float y, float z); +# 1047 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rz(float x, float y, float z); +# 1091 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_ru(float x, float y, float z); +# 1135 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rd(float x, float y, float z); +# 1152 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rn(float x); +# 1169 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rz(float x); +# 1186 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_ru(float x); +# 1203 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rd(float x); +# 1221 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rn(float x); +# 1239 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rz(float x); +# 1257 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_ru(float x); +# 1275 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rd(float x); +# 1293 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frsqrt_rn(float x); +# 1312 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rn(float x, float y); +# 1331 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rz(float x, float y); +# 1350 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_ru(float x, float y); +# 1369 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rd(float x, float y); +# 1378 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __clz(int x); +# 1389 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __ffs(int x); +# 1398 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __popc(unsigned int x); +# 1407 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __brev(unsigned int x); +# 1416 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __clzll(long long int x); +# 1427 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __ffsll(long long int x); +# 1438 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __popcll(unsigned long long int x); +# 1447 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __brevll(unsigned long long int x); +# 1470 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __byte_perm(unsigned int x, unsigned int y, unsigned int s); +# 1482 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __hadd(int x, int y); +# 1495 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __rhadd(int x, int y); +# 1507 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __uhadd(unsigned int x, unsigned int y); +# 1520 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __urhadd(unsigned int x, unsigned int y); +# 1531 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __double2int_rz(double x); +# 1541 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __double2uint_rz(double x); +# 1551 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __double2ll_rz(double x); +# 1561 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __double2ull_rz(double x); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __pm0(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __pm1(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __pm2(void); +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __pm3(void); +# 1591 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabs2(unsigned int a); +# 1602 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsss2(unsigned int a); +# 1613 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vadd2(unsigned int a, unsigned int b); +# 1624 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddss2 (unsigned int a, unsigned int b); +# 1634 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddus2 (unsigned int a, unsigned int b); +# 1645 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgs2(unsigned int a, unsigned int b); +# 1656 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgu2(unsigned int a, unsigned int b); +# 1667 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vhaddu2(unsigned int a, unsigned int b); +# 1678 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpeq2(unsigned int a, unsigned int b); +# 1689 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpges2(unsigned int a, unsigned int b); +# 1700 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgeu2(unsigned int a, unsigned int b); +# 1711 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgts2(unsigned int a, unsigned int b); +# 1722 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgtu2(unsigned int a, unsigned int b); +# 1733 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmples2(unsigned int a, unsigned int b); +# 1745 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpleu2(unsigned int a, unsigned int b); +# 1756 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmplts2(unsigned int a, unsigned int b); +# 1767 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpltu2(unsigned int a, unsigned int b); +# 1778 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpne2(unsigned int a, unsigned int b); +# 1789 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffu2(unsigned int a, unsigned int b); +# 1800 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxs2(unsigned int a, unsigned int b); +# 1811 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxu2(unsigned int a, unsigned int b); +# 1822 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmins2(unsigned int a, unsigned int b); +# 1833 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vminu2(unsigned int a, unsigned int b); +# 1844 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vseteq2(unsigned int a, unsigned int b); +# 1855 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetges2(unsigned int a, unsigned int b); +# 1866 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgeu2(unsigned int a, unsigned int b); +# 1877 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgts2(unsigned int a, unsigned int b); +# 1888 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgtu2(unsigned int a, unsigned int b); +# 1899 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetles2(unsigned int a, unsigned int b); +# 1910 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetleu2(unsigned int a, unsigned int b); +# 1921 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetlts2(unsigned int a, unsigned int b); +# 1932 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetltu2(unsigned int a, unsigned int b); +# 1943 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetne2(unsigned int a, unsigned int b); +# 1954 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsadu2(unsigned int a, unsigned int b); +# 1965 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsub2(unsigned int a, unsigned int b); +# 1976 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubss2 (unsigned int a, unsigned int b); +# 1987 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubus2 (unsigned int a, unsigned int b); +# 1997 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vneg2(unsigned int a); +# 2007 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vnegss2(unsigned int a); +# 2018 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffs2(unsigned int a, unsigned int b); +# 2029 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsads2(unsigned int a, unsigned int b); +# 2039 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabs4(unsigned int a); +# 2050 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsss4(unsigned int a); +# 2061 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vadd4(unsigned int a, unsigned int b); +# 2072 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddss4 (unsigned int a, unsigned int b); +# 2082 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddus4 (unsigned int a, unsigned int b); +# 2093 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgs4(unsigned int a, unsigned int b); +# 2104 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgu4(unsigned int a, unsigned int b); +# 2115 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vhaddu4(unsigned int a, unsigned int b); +# 2126 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpeq4(unsigned int a, unsigned int b); +# 2137 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpges4(unsigned int a, unsigned int b); +# 2148 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgeu4(unsigned int a, unsigned int b); +# 2159 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgts4(unsigned int a, unsigned int b); +# 2170 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgtu4(unsigned int a, unsigned int b); +# 2181 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmples4(unsigned int a, unsigned int b); +# 2192 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpleu4(unsigned int a, unsigned int b); +# 2203 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmplts4(unsigned int a, unsigned int b); +# 2214 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpltu4(unsigned int a, unsigned int b); +# 2225 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpne4(unsigned int a, unsigned int b); +# 2236 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffu4(unsigned int a, unsigned int b); +# 2247 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxs4(unsigned int a, unsigned int b); +# 2258 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxu4(unsigned int a, unsigned int b); +# 2269 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmins4(unsigned int a, unsigned int b); +# 2280 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vminu4(unsigned int a, unsigned int b); +# 2291 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vseteq4(unsigned int a, unsigned int b); +# 2302 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetles4(unsigned int a, unsigned int b); +# 2313 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetleu4(unsigned int a, unsigned int b); +# 2324 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetlts4(unsigned int a, unsigned int b); +# 2335 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetltu4(unsigned int a, unsigned int b); +# 2346 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetges4(unsigned int a, unsigned int b); +# 2357 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgeu4(unsigned int a, unsigned int b); +# 2368 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgts4(unsigned int a, unsigned int b); +# 2379 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgtu4(unsigned int a, unsigned int b); +# 2390 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetne4(unsigned int a, unsigned int b); +# 2401 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsadu4(unsigned int a, unsigned int b); +# 2412 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsub4(unsigned int a, unsigned int b); +# 2423 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubss4(unsigned int a, unsigned int b); +# 2434 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubus4(unsigned int a, unsigned int b); +# 2444 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vneg4(unsigned int a); +# 2454 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vnegss4(unsigned int a); +# 2465 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffs4(unsigned int a, unsigned int b); +# 2476 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsads4(unsigned int a, unsigned int b); +# 2486 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax_s32_relu(const int a, const int b); +# 2498 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax_s16x2_relu(const unsigned int a, const unsigned int b); +# 2507 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin_s32_relu(const int a, const int b); +# 2519 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin_s16x2_relu(const unsigned int a, const unsigned int b); +# 2528 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax3_s32(const int a, const int b, const int c); +# 2540 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_s16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2549 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_u32(const unsigned int a, const unsigned int b, const unsigned int c); +# 2561 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_u16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2570 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin3_s32(const int a, const int b, const int c); +# 2582 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_s16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2591 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_u32(const unsigned int a, const unsigned int b, const unsigned int c); +# 2603 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_u16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2612 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax3_s32_relu(const int a, const int b, const int c); +# 2624 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c); +# 2633 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin3_s32_relu(const int a, const int b, const int c); +# 2645 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c); +# 2654 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmax_s32(const int a, const int b, const int c); +# 2666 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_s16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2675 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_u32(const unsigned int a, const unsigned int b, const unsigned int c); +# 2687 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_u16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2696 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmin_s32(const int a, const int b, const int c); +# 2708 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_s16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2717 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_u32(const unsigned int a, const unsigned int b, const unsigned int c); +# 2729 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_u16x2(const unsigned int a, const unsigned int b, const unsigned int c); +# 2739 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmax_s32_relu(const int a, const int b, const int c); +# 2751 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c); +# 2761 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmin_s32_relu(const int a, const int b, const int c); +# 2773 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c); +# 2782 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vibmax_s32(const int a, const int b, bool* const pred); +# 2791 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_u32(const unsigned int a, const unsigned int b, bool* const pred); +# 2800 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vibmin_s32(const int a, const int b, bool* const pred); +# 2809 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_u32(const unsigned int a, const unsigned int b, bool* const pred); +# 2823 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_s16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo); +# 2837 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo); +# 2851 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_s16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo); +# 2865 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo); + + + + + + +} +# 2888 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" 1 +# 81 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 82 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" 2 + +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 84 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" 2 +# 108 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax_s32_relu(const int a, const int b){ + + + + + + + int ans = max(a, b); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax_s16x2_relu(const unsigned int a, const unsigned int b){ + unsigned int res; + + + + + + + + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + short aS_lo = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + + short ansS_lo = (short)max(aS_lo, bS_lo); + short ansS_hi = (short)max(aS_hi, bS_hi); + + + if(ansS_lo < 0){ ansS_lo = 0; } + if(ansS_hi < 0){ ansS_hi = 0; } + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + res = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin_s32_relu(const int a, const int b){ + + + + + + + int ans = min(a, b); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin_s16x2_relu(const unsigned int a, const unsigned int b){ + unsigned int res; + + + + + + + + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + short aS_lo = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + + short ansS_lo = (short)min(aS_lo, bS_lo); + short ansS_hi = (short)min(aS_hi, bS_hi); + + + if(ansS_lo < 0){ ansS_lo = 0; } + if(ansS_hi < 0){ ansS_hi = 0; } + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + res = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax3_s32(const int a, const int b, const int c){ +# 226 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return max(max(a, b), c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_s16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 243 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + short cS_lo = *(short*)& cU_lo; + short cS_hi = *(short*)& cU_hi; + + + short ansS_lo = (short)max(max(aS_lo, bS_lo), cS_lo); + short ansS_hi = (short)max(max(aS_hi, bS_hi), cS_hi); + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + res = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_u32(const unsigned int a, const unsigned int b, const unsigned int c){ +# 286 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return max(max(a, b), c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_u16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 302 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + unsigned short ansU_lo = (unsigned short)max(max(aU_lo, bU_lo), cU_lo); + unsigned short ansU_hi = (unsigned short)max(max(aU_hi, bU_hi), cU_hi); + + + res = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin3_s32(const int a, const int b, const int c){ +# 332 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return min(min(a, b), c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_s16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 348 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + short cS_lo = *(short*)& cU_lo; + short cS_hi = *(short*)& cU_hi; + + + short ansS_lo = (short)min(min(aS_lo, bS_lo), cS_lo); + short ansS_hi = (short)min(min(aS_hi, bS_hi), cS_hi); + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + res = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_u32(const unsigned int a, const unsigned int b, const unsigned int c){ +# 392 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return min(min(a, b), c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_u16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 408 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + unsigned short ansU_lo = (unsigned short)min(min(aU_lo, bU_lo), cU_lo); + unsigned short ansU_hi = (unsigned short)min(min(aU_hi, bU_hi), cU_hi); + + + res = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimax3_s32_relu(const int a, const int b, const int c){ +# 438 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = max(max(a, b), c); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimax3_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 456 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + short cS_lo = *(short*)& cU_lo; + short cS_hi = *(short*)& cU_hi; + + + short ansS_lo = (short)max(max(aS_lo, bS_lo), cS_lo); + short ansS_hi = (short)max(max(aS_hi, bS_hi), cS_hi); + + + if(ansS_lo < 0){ansS_lo = 0;} + if(ansS_hi < 0){ansS_hi = 0;} + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + res = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vimin3_s32_relu(const int a, const int b, const int c){ +# 504 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = min(min(a, b), c); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vimin3_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned res; +# 522 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + short cS_lo = *(short*)& cU_lo; + short cS_hi = *(short*)& cU_hi; + + + short ansS_lo = (short)min(min(aS_lo, bS_lo), cS_lo); + short ansS_hi = (short)min(min(aS_hi, bS_hi), cS_hi); + + + if(ansS_lo < 0){ansS_lo = 0;} + if(ansS_hi < 0){ansS_hi = 0;} + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + res = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmax_s32(const int a, const int b, const int c){ +# 570 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return max(a + b, c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_s16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 586 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + short cS_lo = *(short*)& cU_lo; + short cS_hi = *(short*)& cU_hi; + + + short ansS_lo = (short)max((short)(aS_lo + bS_lo), cS_lo); + short ansS_hi = (short)max((short)(aS_hi + bS_hi), cS_hi); + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + res = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_u32(const unsigned int a, const unsigned int b, const unsigned int c){ +# 630 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return max(a + b, c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_u16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 646 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + unsigned short ansU_lo = (unsigned short)max((unsigned short)(aU_lo + bU_lo), cU_lo); + unsigned short ansU_hi = (unsigned short)max((unsigned short)(aU_hi + bU_hi), cU_hi); + + + res = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmin_s32(const int a, const int b, const int c){ +# 676 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return min(a + b, c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_s16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 692 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + short cS_lo = *(short*)& cU_lo; + short cS_hi = *(short*)& cU_hi; + + + short ansS_lo = (short)min((short)(aS_lo + bS_lo), cS_lo); + short ansS_hi = (short)min((short)(aS_hi + bS_hi), cS_hi); + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + res = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_u32(const unsigned int a, const unsigned int b, const unsigned int c){ +# 736 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + return min(a + b, c); + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_u16x2(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 752 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + unsigned short ansU_lo = (unsigned short)min((unsigned short)(aU_lo + bU_lo), cU_lo); + unsigned short ansU_hi = (unsigned short)min((unsigned short)(aU_hi + bU_hi), cU_hi); + + + res = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmax_s32_relu(const int a, const int b, const int c){ +# 782 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = max(a + b, c); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmax_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 800 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + short cS_lo = *(short*)& cU_lo; + short cS_hi = *(short*)& cU_hi; + + + short ansS_lo = (short)max((short)(aS_lo + bS_lo), cS_lo); + short ansS_hi = (short)max((short)(aS_hi + bS_hi), cS_hi); + + if(ansS_lo < 0){ansS_lo = 0;} + if(ansS_hi < 0){ansS_hi = 0;} + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + res = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + + return res; +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __viaddmin_s32_relu(const int a, const int b, const int c){ +# 847 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = min(a + b, c); + + return (ans > 0) ? ans : 0; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __viaddmin_s16x2_relu(const unsigned int a, const unsigned int b, const unsigned int c){ + unsigned int res; +# 865 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + unsigned short cU_lo = (unsigned short)(c & 0xFFFFU); + unsigned short cU_hi = (unsigned short)(c >> 16); + + + short aS_lo = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + short cS_lo = *(short*)& cU_lo; + short cS_hi = *(short*)& cU_hi; + + + short ansS_lo = (short)min((short)(aS_lo + bS_lo), cS_lo); + short ansS_hi = (short)min((short)(aS_hi + bS_hi), cS_hi); + + if(ansS_lo < 0){ansS_lo = 0;} + if(ansS_hi < 0){ansS_hi = 0;} + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + res = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + + return res; +} + + + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vibmax_s32(const int a, const int b, bool* const pred){ +# 918 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = max(a, b); + + *pred = (a >= b); + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_u32(const unsigned int a, const unsigned int b, bool* const pred){ +# 939 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned int ans = max(a, b); + + *pred = (a >= b); + return ans; + +} + + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) int __vibmin_s32(const int a, const int b, bool* const pred){ +# 961 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + int ans = min(a, b); + + *pred = (a <= b); + return ans; + +} + + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_u32(const unsigned int a, const unsigned int b, bool* const pred){ +# 983 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned int ans = min(a, b); + + *pred = (a <= b); + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_s16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 1012 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + short aS_lo = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + + short ansS_lo = (short)max(aS_lo, bS_lo); + short ansS_hi = (short)max(aS_hi, bS_hi); + + *pred_hi = (aS_hi >= bS_hi); + *pred_lo = (aS_lo >= bS_lo); + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + unsigned int ans = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmax_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 1065 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + unsigned short ansU_lo = (unsigned short)max(aU_lo, bU_lo); + unsigned short ansU_hi = (unsigned short)max(aU_hi, bU_hi); + + *pred_hi = (aU_hi >= bU_hi); + *pred_lo = (aU_lo >= bU_lo); + + + unsigned int ans = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_s16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 1107 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + short aS_lo = *(short*)& aU_lo; + short aS_hi = *(short*)& aU_hi; + + short bS_lo = *(short*)& bU_lo; + short bS_hi = *(short*)& bU_hi; + + + short ansS_lo = (short)min(aS_lo, bS_lo); + short ansS_hi = (short)min(aS_hi, bS_hi); + + *pred_hi = (aS_hi <= bS_hi); + *pred_lo = (aS_lo <= bS_lo); + + + unsigned short ansU_lo = *(unsigned short*)& ansS_lo; + unsigned short ansU_hi = *(unsigned short*)& ansS_hi; + + + unsigned int ans = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + return ans; + +} + +static __inline__ __attribute__((device)) __attribute__((host)) __attribute__((cudart_builtin)) unsigned int __vibmin_u16x2(const unsigned int a, const unsigned int b, bool* const pred_hi, bool* const pred_lo){ +# 1160 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.hpp" + unsigned short aU_lo = (unsigned short)(a & 0xFFFFU); + unsigned short aU_hi = (unsigned short)(a >> 16); + + unsigned short bU_lo = (unsigned short)(b & 0xFFFFU); + unsigned short bU_hi = (unsigned short)(b >> 16); + + + unsigned short ansU_lo = (unsigned short)min(aU_lo, bU_lo); + unsigned short ansU_hi = (unsigned short)min(aU_hi, bU_hi); + + *pred_hi = (aU_hi <= bU_hi); + *pred_lo = (aU_lo <= bU_lo); + + + unsigned int ans = ((unsigned int) ansU_lo) | (((unsigned int) ansU_hi) << 16); + + return ans; + +} +# 2889 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 + + +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" 1 +# 89 "/usr/local/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +static __inline__ __attribute__((device)) int atomicAdd(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicAdd(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) int atomicSub(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicSub(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) int atomicExch(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicExch(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) float atomicExch(float *address, float val) { } + +static __inline__ __attribute__((device)) int atomicMin(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicMin(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) int atomicMax(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicMax(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicInc(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicDec(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) int atomicAnd(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicAnd(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) int atomicOr(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicOr(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) int atomicXor(int *address, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicXor(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) int atomicCAS(int *address, int compare, int val) { } + +static __inline__ __attribute__((device)) unsigned int atomicCAS(unsigned int *address, unsigned int compare, unsigned int val) { } +# 156 "/usr/local/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) __attribute__((deprecated("__any""() is deprecated in favor of ""__any""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __any(int cond); +extern __attribute__((device)) __attribute__((device_builtin)) __attribute__((deprecated("__all""() is deprecated in favor of ""__all""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __all(int cond); +} +# 169 "/usr/local/cuda/bin/../targets/x86_64-linux/include/device_atomic_functions.h" +static __inline__ __attribute__((device)) unsigned long long int atomicAdd(unsigned long long int *address, unsigned long long int val) { } + +static __inline__ __attribute__((device)) unsigned long long int atomicExch(unsigned long long int *address, unsigned long long int val) { } + +static __inline__ __attribute__((device)) unsigned long long int atomicCAS(unsigned long long int *address, unsigned long long int compare, unsigned long long int val) { } + +static __inline__ __attribute__((device)) __attribute__((deprecated("__any""() is deprecated in favor of ""__any""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) bool any(bool cond) { } + +static __inline__ __attribute__((device)) __attribute__((deprecated("__all""() is deprecated in favor of ""__all""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) bool all(bool cond) { } +# 2892 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" 1 +# 83 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 84 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" 2 + +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 86 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" 2 + + + + +extern "C" +{ +# 100 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double_as_longlong(double x); +# 109 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __longlong_as_double(long long int x); +# 266 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rn(double x, double y, double z); +# 423 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rz(double x, double y, double z); +# 580 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_ru(double x, double y, double z); +# 737 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rd(double x, double y, double z); +# 749 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rn(double x, double y); +# 761 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rz(double x, double y); +# 773 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_ru(double x, double y); +# 785 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rd(double x, double y); +# 797 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rn(double x, double y); +# 809 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rz(double x, double y); +# 821 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_ru(double x, double y); +# 833 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rd(double x, double y); +# 845 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rn(double x, double y); +# 857 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rz(double x, double y); +# 869 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_ru(double x, double y); +# 881 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rd(double x, double y); +# 890 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rn(double x); +# 899 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rz(double x); +# 908 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_ru(double x); +# 917 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rd(double x); +# 926 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rn(double x); +# 935 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_ru(double x); +# 944 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rd(double x); +# 953 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rn(double x); +# 962 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_ru(double x); +# 971 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rd(double x); +# 980 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rn(double x); +# 989 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_ru(double x); +# 998 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rd(double x); +# 1007 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rn(double x); +# 1016 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_ru(double x); +# 1025 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rd(double x); + + + + + + + +extern __attribute__((device)) __attribute__((device_builtin)) double __int2double_rn(int x); + + + + + + + +extern __attribute__((device)) __attribute__((device_builtin)) double __uint2double_rn(unsigned int x); +# 1050 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rn(long long int x); +# 1059 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rz(long long int x); +# 1068 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_ru(long long int x); +# 1077 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rd(long long int x); +# 1086 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rn(unsigned long long int x); +# 1095 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rz(unsigned long long int x); +# 1104 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_ru(unsigned long long int x); +# 1113 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rd(unsigned long long int x); +# 1122 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2hiint(double x); +# 1131 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2loint(double x); +# 1141 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __hiloint2double(int hi, int lo); +} + + + + + + + +static __inline__ __attribute__((device)) double fma(double a, double b, double c, enum cudaRoundMode mode); + + + +static __inline__ __attribute__((device)) double dmul(double a, double b, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double dadd(double a, double b, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double dsub(double a, double b, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) int double2int(double a, enum cudaRoundMode mode = cudaRoundZero); + +static __inline__ __attribute__((device)) unsigned int double2uint(double a, enum cudaRoundMode mode = cudaRoundZero); + +static __inline__ __attribute__((device)) long long int double2ll(double a, enum cudaRoundMode mode = cudaRoundZero); + +static __inline__ __attribute__((device)) unsigned long long int double2ull(double a, enum cudaRoundMode mode = cudaRoundZero); + +static __inline__ __attribute__((device)) double ll2double(long long int a, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double ull2double(unsigned long long int a, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double int2double(int a, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double uint2double(unsigned int a, enum cudaRoundMode mode = cudaRoundNearest); + +static __inline__ __attribute__((device)) double float2double(float a, enum cudaRoundMode mode = cudaRoundNearest); + + + + + + + +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" 1 +# 83 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 84 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" 2 + +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 86 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.hpp" 2 + + + + + + + +static __inline__ __attribute__((device)) double fma(double a, double b, double c, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __fma_rz(a, b, c) : + mode == cudaRoundPosInf ? __fma_ru(a, b, c) : + mode == cudaRoundMinInf ? __fma_rd(a, b, c) : + __fma_rn(a, b, c); +} + +static __inline__ __attribute__((device)) double dmul(double a, double b, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __dmul_rz(a, b) : + mode == cudaRoundPosInf ? __dmul_ru(a, b) : + mode == cudaRoundMinInf ? __dmul_rd(a, b) : + __dmul_rn(a, b); +} + +static __inline__ __attribute__((device)) double dadd(double a, double b, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __dadd_rz(a, b) : + mode == cudaRoundPosInf ? __dadd_ru(a, b) : + mode == cudaRoundMinInf ? __dadd_rd(a, b) : + __dadd_rn(a, b); +} + +static __inline__ __attribute__((device)) double dsub(double a, double b, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __dsub_rz(a, b) : + mode == cudaRoundPosInf ? __dsub_ru(a, b) : + mode == cudaRoundMinInf ? __dsub_rd(a, b) : + __dsub_rn(a, b); +} + +static __inline__ __attribute__((device)) int double2int(double a, enum cudaRoundMode mode) +{ + return mode == cudaRoundNearest ? __double2int_rn(a) : + mode == cudaRoundPosInf ? __double2int_ru(a) : + mode == cudaRoundMinInf ? __double2int_rd(a) : + __double2int_rz(a); +} + +static __inline__ __attribute__((device)) unsigned int double2uint(double a, enum cudaRoundMode mode) +{ + return mode == cudaRoundNearest ? __double2uint_rn(a) : + mode == cudaRoundPosInf ? __double2uint_ru(a) : + mode == cudaRoundMinInf ? __double2uint_rd(a) : + __double2uint_rz(a); +} + +static __inline__ __attribute__((device)) long long int double2ll(double a, enum cudaRoundMode mode) +{ + return mode == cudaRoundNearest ? __double2ll_rn(a) : + mode == cudaRoundPosInf ? __double2ll_ru(a) : + mode == cudaRoundMinInf ? __double2ll_rd(a) : + __double2ll_rz(a); +} + +static __inline__ __attribute__((device)) unsigned long long int double2ull(double a, enum cudaRoundMode mode) +{ + return mode == cudaRoundNearest ? __double2ull_rn(a) : + mode == cudaRoundPosInf ? __double2ull_ru(a) : + mode == cudaRoundMinInf ? __double2ull_rd(a) : + __double2ull_rz(a); +} + +static __inline__ __attribute__((device)) double ll2double(long long int a, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __ll2double_rz(a) : + mode == cudaRoundPosInf ? __ll2double_ru(a) : + mode == cudaRoundMinInf ? __ll2double_rd(a) : + __ll2double_rn(a); +} + +static __inline__ __attribute__((device)) double ull2double(unsigned long long int a, enum cudaRoundMode mode) +{ + return mode == cudaRoundZero ? __ull2double_rz(a) : + mode == cudaRoundPosInf ? __ull2double_ru(a) : + mode == cudaRoundMinInf ? __ull2double_rd(a) : + __ull2double_rn(a); +} + +static __inline__ __attribute__((device)) double int2double(int a, enum cudaRoundMode mode) +{ + return (double)a; +} + +static __inline__ __attribute__((device)) double uint2double(unsigned int a, enum cudaRoundMode mode) +{ + return (double)a; +} + +static __inline__ __attribute__((device)) double float2double(float a, enum cudaRoundMode mode) +{ + return (double)a; +} +# 1185 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_double_functions.h" 2 +# 2893 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_atomic_functions.h" 1 +# 88 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_atomic_functions.h" +static __inline__ __attribute__((device)) float atomicAdd(float *address, float val) { } +# 2894 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" 1 +# 89 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" +static __inline__ __attribute__((device)) long long atomicMin(long long *address, long long val) { } + +static __inline__ __attribute__((device)) long long atomicMax(long long *address, long long val) { } + +static __inline__ __attribute__((device)) long long atomicAnd(long long *address, long long val) { } + +static __inline__ __attribute__((device)) long long atomicOr(long long *address, long long val) { } + +static __inline__ __attribute__((device)) long long atomicXor(long long *address, long long val) { } + +static __inline__ __attribute__((device)) unsigned long long atomicMin(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) unsigned long long atomicMax(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) unsigned long long atomicAnd(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) unsigned long long atomicOr(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) unsigned long long atomicXor(unsigned long long *address, unsigned long long val) { } +# 2895 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_35_atomic_functions.h" 1 +# 56 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_35_atomic_functions.h" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_32_atomic_functions.h" 1 +# 57 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_35_atomic_functions.h" 2 +# 2896 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" 1 +# 93 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_60_atomic_functions.h" +static __inline__ __attribute__((device)) double atomicAdd(double *address, double val) { } + +static __inline__ __attribute__((device)) +int atomicAdd_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicAdd_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicAdd_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicAdd_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicAdd_block(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicAdd_system(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +float atomicAdd_block(float *address, float val) { } + +static __inline__ __attribute__((device)) +float atomicAdd_system(float *address, float val) { } + +static __inline__ __attribute__((device)) +double atomicAdd_block(double *address, double val) { } + +static __inline__ __attribute__((device)) +double atomicAdd_system(double *address, double val) { } + +static __inline__ __attribute__((device)) +int atomicSub_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicSub_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicSub_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicSub_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +int atomicExch_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicExch_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicExch_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicExch_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicExch_block(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicExch_system(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +float atomicExch_block(float *address, float val) { } + +static __inline__ __attribute__((device)) +float atomicExch_system(float *address, float val) { } + +static __inline__ __attribute__((device)) +int atomicMin_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicMin_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +long long atomicMin_block(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +long long atomicMin_system(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicMin_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicMin_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicMin_block(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicMin_system(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +int atomicMax_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicMax_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +long long atomicMax_block(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +long long atomicMax_system(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicMax_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicMax_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicMax_block(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicMax_system(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicInc_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicInc_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicDec_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicDec_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +int atomicCAS_block(int *address, int compare, int val) { } + +static __inline__ __attribute__((device)) +int atomicCAS_system(int *address, int compare, int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicCAS_block(unsigned int *address, unsigned int compare, + unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicCAS_system(unsigned int *address, unsigned int compare, + unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long int atomicCAS_block(unsigned long long int *address, + unsigned long long int compare, + unsigned long long int val) { } + +static __inline__ __attribute__((device)) +unsigned long long int atomicCAS_system(unsigned long long int *address, + unsigned long long int compare, + unsigned long long int val) { } + +static __inline__ __attribute__((device)) +int atomicAnd_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicAnd_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +long long atomicAnd_block(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +long long atomicAnd_system(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicAnd_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicAnd_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicAnd_block(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicAnd_system(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +int atomicOr_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicOr_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +long long atomicOr_block(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +long long atomicOr_system(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicOr_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicOr_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicOr_block(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicOr_system(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +int atomicXor_block(int *address, int val) { } + +static __inline__ __attribute__((device)) +int atomicXor_system(int *address, int val) { } + +static __inline__ __attribute__((device)) +long long atomicXor_block(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +long long atomicXor_system(long long *address, long long val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicXor_block(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned int atomicXor_system(unsigned int *address, unsigned int val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicXor_block(unsigned long long *address, unsigned long long val) { } + +static __inline__ __attribute__((device)) +unsigned long long atomicXor_system(unsigned long long *address, unsigned long long val) { } +# 2897 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" 1 +# 95 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern "C" +{ +extern __attribute__((device)) __attribute__((device_builtin)) void __threadfence_system(void); +# 117 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rn(double x, double y); +# 137 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rz(double x, double y); +# 157 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_ru(double x, double y); +# 177 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rd(double x, double y); +# 192 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rn(double x); +# 207 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rz(double x); +# 222 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_ru(double x); +# 237 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rd(double x); +# 252 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rn(double x); +# 267 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rz(double x); +# 282 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_ru(double x); +# 297 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rd(double x); +extern __attribute__((device)) __attribute__((device_builtin)) __attribute__((deprecated("__ballot""() is deprecated in favor of ""__ballot""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __ballot(int); +extern __attribute__((device)) __attribute__((device_builtin)) int __syncthreads_count(int); +extern __attribute__((device)) __attribute__((device_builtin)) int __syncthreads_and(int); +extern __attribute__((device)) __attribute__((device_builtin)) int __syncthreads_or(int); +extern __attribute__((device)) __attribute__((device_builtin)) long long int clock64(void); +# 312 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rn(float x, float y, float z); +# 321 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rd(float x, float y, float z); +# 330 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_ru(float x, float y, float z); +# 339 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rz(float x, float y, float z); +# 352 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double_as_longlong(double x); +# 361 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __longlong_as_double(long long int x); +# 405 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rn(double x, double y, double z); +# 449 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rz(double x, double y, double z); +# 493 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_ru(double x, double y, double z); +# 537 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rd(double x, double y, double z); +# 556 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rn(double x, double y); +# 575 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rz(double x, double y); +# 594 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_ru(double x, double y); +# 613 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rd(double x, double y); +# 632 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rn(double x, double y); +# 651 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rz(double x, double y); +# 670 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_ru(double x, double y); +# 689 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rd(double x, double y); +# 707 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rn(double x, double y); +# 725 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rz(double x, double y); +# 743 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_ru(double x, double y); +# 761 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rd(double x, double y); +# 770 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rn(double x); +# 779 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rz(double x); +# 788 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_ru(double x); +# 797 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rd(double x); +# 807 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rn(double x); +# 817 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_ru(double x); +# 827 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rd(double x); +# 837 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rn(double x); +# 847 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_ru(double x); +# 857 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rd(double x); +# 867 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rn(double x); +# 877 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_ru(double x); +# 887 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rd(double x); +# 897 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rn(double x); +# 907 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_ru(double x); +# 917 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rd(double x); + + + + + + + +extern __attribute__((device)) __attribute__((device_builtin)) double __int2double_rn(int x); + + + + + + + +extern __attribute__((device)) __attribute__((device_builtin)) double __uint2double_rn(unsigned int x); +# 942 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rn(long long int x); +# 951 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rz(long long int x); +# 960 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_ru(long long int x); +# 969 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rd(long long int x); +# 978 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rn(unsigned long long int x); +# 987 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rz(unsigned long long int x); +# 996 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_ru(unsigned long long int x); +# 1005 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rd(unsigned long long int x); +# 1014 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2hiint(double x); +# 1023 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) int __double2loint(double x); +# 1033 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_20_intrinsics.h" +extern __attribute__((device)) __attribute__((device_builtin)) double __hiloint2double(int hi, int lo); + + +} + + + + + + +static __inline__ __attribute__((device)) __attribute__((deprecated("__ballot""() is deprecated in favor of ""__ballot""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int ballot(bool pred) { } + +static __inline__ __attribute__((device)) int syncthreads_count(bool pred) { } + +static __inline__ __attribute__((device)) bool syncthreads_and(bool pred) { } + +static __inline__ __attribute__((device)) bool syncthreads_or(bool pred) { } + + + + +static __inline__ __attribute__((device)) unsigned int __isGlobal(const void *ptr) { } +static __inline__ __attribute__((device)) unsigned int __isShared(const void *ptr) { } +static __inline__ __attribute__((device)) unsigned int __isConstant(const void *ptr) { } +static __inline__ __attribute__((device)) unsigned int __isLocal(const void *ptr) { } + +static __inline__ __attribute__((device)) unsigned int __isGridConstant(const void *ptr) { } + +static __inline__ __attribute__((device)) size_t __cvta_generic_to_global(const void *ptr) { } +static __inline__ __attribute__((device)) size_t __cvta_generic_to_shared(const void *ptr) { } +static __inline__ __attribute__((device)) size_t __cvta_generic_to_constant(const void *ptr) { } +static __inline__ __attribute__((device)) size_t __cvta_generic_to_local(const void *ptr) { } + +static __inline__ __attribute__((device)) size_t __cvta_generic_to_grid_constant(const void *ptr) { } + + +static __inline__ __attribute__((device)) void * __cvta_global_to_generic(size_t rawbits) { } +static __inline__ __attribute__((device)) void * __cvta_shared_to_generic(size_t rawbits) { } +static __inline__ __attribute__((device)) void * __cvta_constant_to_generic(size_t rawbits) { } +static __inline__ __attribute__((device)) void * __cvta_local_to_generic(size_t rawbits) { } + +static __inline__ __attribute__((device)) void * __cvta_grid_constant_to_generic(size_t rawbits) { } +# 2898 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" 1 +# 123 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +static __attribute__((device)) __inline__ unsigned __fns(unsigned mask, unsigned base, int offset) { } +static __attribute__((device)) __inline__ void __barrier_sync(unsigned id) { } +static __attribute__((device)) __inline__ void __barrier_sync_count(unsigned id, unsigned cnt) { } +static __attribute__((device)) __inline__ void __syncwarp(unsigned mask=0xFFFFFFFF) { } +static __attribute__((device)) __inline__ int __all_sync(unsigned mask, int pred) { } +static __attribute__((device)) __inline__ int __any_sync(unsigned mask, int pred) { } +static __attribute__((device)) __inline__ int __uni_sync(unsigned mask, int pred) { } +static __attribute__((device)) __inline__ unsigned __ballot_sync(unsigned mask, int pred) { } +static __attribute__((device)) __inline__ unsigned __activemask() { } +# 140 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_30_intrinsics.h" +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __shfl(int var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __shfl(unsigned int var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __shfl_up(int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __shfl_up(unsigned int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __shfl_down(int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __shfl_down(unsigned int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) int __shfl_xor(int var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned int __shfl_xor(unsigned int var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) float __shfl(float var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) float __shfl_up(float var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) float __shfl_down(float var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) float __shfl_xor(float var, int laneMask, int width=32) { } + + +static __attribute__((device)) __inline__ int __shfl_sync(unsigned mask, int var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ unsigned int __shfl_sync(unsigned mask, unsigned int var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ int __shfl_up_sync(unsigned mask, int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ unsigned int __shfl_up_sync(unsigned mask, unsigned int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ int __shfl_down_sync(unsigned mask, int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ unsigned int __shfl_down_sync(unsigned mask, unsigned int var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ int __shfl_xor_sync(unsigned mask, int var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ unsigned int __shfl_xor_sync(unsigned mask, unsigned int var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ float __shfl_sync(unsigned mask, float var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ float __shfl_up_sync(unsigned mask, float var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ float __shfl_down_sync(unsigned mask, float var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ float __shfl_xor_sync(unsigned mask, float var, int laneMask, int width=32) { } + + + +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long long __shfl(unsigned long long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long long __shfl(long long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long long __shfl_up(long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long long __shfl_up(unsigned long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long long __shfl_down(long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long long __shfl_down(unsigned long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long long __shfl_xor(long long var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long long __shfl_xor(unsigned long long var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) double __shfl(double var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) double __shfl_up(double var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) double __shfl_down(double var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) double __shfl_xor(double var, int laneMask, int width=32) { } + + +static __attribute__((device)) __inline__ long long __shfl_sync(unsigned mask, long long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ unsigned long long __shfl_sync(unsigned mask, unsigned long long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ long long __shfl_up_sync(unsigned mask, long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ unsigned long long __shfl_up_sync(unsigned mask, unsigned long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ long long __shfl_down_sync(unsigned mask, long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ unsigned long long __shfl_down_sync(unsigned mask, unsigned long long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ long long __shfl_xor_sync(unsigned mask, long long var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ unsigned long long __shfl_xor_sync(unsigned mask, unsigned long long var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ double __shfl_sync(unsigned mask, double var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ double __shfl_up_sync(unsigned mask, double var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ double __shfl_down_sync(unsigned mask, double var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ double __shfl_xor_sync(unsigned mask, double var, int laneMask, int width=32) { } + + + +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long __shfl(long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl""() is deprecated in favor of ""__shfl""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long __shfl(unsigned long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long __shfl_up(long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_up""() is deprecated in favor of ""__shfl_up""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long __shfl_up(unsigned long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long __shfl_down(long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_down""() is deprecated in favor of ""__shfl_down""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long __shfl_down(unsigned long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) long __shfl_xor(long var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ __attribute__((deprecated("__shfl_xor""() is deprecated in favor of ""__shfl_xor""_sync() and may be removed in a future release (Use -Wno-deprecated-declarations to suppress this warning)."))) unsigned long __shfl_xor(unsigned long var, int laneMask, int width=32) { } + + +static __attribute__((device)) __inline__ long __shfl_sync(unsigned mask, long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ unsigned long __shfl_sync(unsigned mask, unsigned long var, int srcLane, int width=32) { } +static __attribute__((device)) __inline__ long __shfl_up_sync(unsigned mask, long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ unsigned long __shfl_up_sync(unsigned mask, unsigned long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ long __shfl_down_sync(unsigned mask, long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ unsigned long __shfl_down_sync(unsigned mask, unsigned long var, unsigned int delta, int width=32) { } +static __attribute__((device)) __inline__ long __shfl_xor_sync(unsigned mask, long var, int laneMask, int width=32) { } +static __attribute__((device)) __inline__ unsigned long __shfl_xor_sync(unsigned mask, unsigned long var, int laneMask, int width=32) { } +# 2899 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" 1 +# 91 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ long __ldg(const long *ptr) { } +static __attribute__((device)) __inline__ unsigned long __ldg(const unsigned long *ptr) { } + +static __attribute__((device)) __inline__ char __ldg(const char *ptr) { } +static __attribute__((device)) __inline__ signed char __ldg(const signed char *ptr) { } +static __attribute__((device)) __inline__ short __ldg(const short *ptr) { } +static __attribute__((device)) __inline__ int __ldg(const int *ptr) { } +static __attribute__((device)) __inline__ long long __ldg(const long long *ptr) { } +static __attribute__((device)) __inline__ char2 __ldg(const char2 *ptr) { } +static __attribute__((device)) __inline__ char4 __ldg(const char4 *ptr) { } +static __attribute__((device)) __inline__ short2 __ldg(const short2 *ptr) { } +static __attribute__((device)) __inline__ short4 __ldg(const short4 *ptr) { } +static __attribute__((device)) __inline__ int2 __ldg(const int2 *ptr) { } +static __attribute__((device)) __inline__ int4 __ldg(const int4 *ptr) { } +static __attribute__((device)) __inline__ longlong2 __ldg(const longlong2 *ptr) { } + +static __attribute__((device)) __inline__ unsigned char __ldg(const unsigned char *ptr) { } +static __attribute__((device)) __inline__ unsigned short __ldg(const unsigned short *ptr) { } +static __attribute__((device)) __inline__ unsigned int __ldg(const unsigned int *ptr) { } +static __attribute__((device)) __inline__ unsigned long long __ldg(const unsigned long long *ptr) { } +static __attribute__((device)) __inline__ uchar2 __ldg(const uchar2 *ptr) { } +static __attribute__((device)) __inline__ uchar4 __ldg(const uchar4 *ptr) { } +static __attribute__((device)) __inline__ ushort2 __ldg(const ushort2 *ptr) { } +static __attribute__((device)) __inline__ ushort4 __ldg(const ushort4 *ptr) { } +static __attribute__((device)) __inline__ uint2 __ldg(const uint2 *ptr) { } +static __attribute__((device)) __inline__ uint4 __ldg(const uint4 *ptr) { } +static __attribute__((device)) __inline__ ulonglong2 __ldg(const ulonglong2 *ptr) { } + +static __attribute__((device)) __inline__ float __ldg(const float *ptr) { } +static __attribute__((device)) __inline__ double __ldg(const double *ptr) { } +static __attribute__((device)) __inline__ float2 __ldg(const float2 *ptr) { } +static __attribute__((device)) __inline__ float4 __ldg(const float4 *ptr) { } +static __attribute__((device)) __inline__ double2 __ldg(const double2 *ptr) { } + + + + +static __attribute__((device)) __inline__ long __ldcg(const long *ptr) { } +static __attribute__((device)) __inline__ unsigned long __ldcg(const unsigned long *ptr) { } + +static __attribute__((device)) __inline__ char __ldcg(const char *ptr) { } +static __attribute__((device)) __inline__ signed char __ldcg(const signed char *ptr) { } +static __attribute__((device)) __inline__ short __ldcg(const short *ptr) { } +static __attribute__((device)) __inline__ int __ldcg(const int *ptr) { } +static __attribute__((device)) __inline__ long long __ldcg(const long long *ptr) { } +static __attribute__((device)) __inline__ char2 __ldcg(const char2 *ptr) { } +static __attribute__((device)) __inline__ char4 __ldcg(const char4 *ptr) { } +static __attribute__((device)) __inline__ short2 __ldcg(const short2 *ptr) { } +static __attribute__((device)) __inline__ short4 __ldcg(const short4 *ptr) { } +static __attribute__((device)) __inline__ int2 __ldcg(const int2 *ptr) { } +static __attribute__((device)) __inline__ int4 __ldcg(const int4 *ptr) { } +static __attribute__((device)) __inline__ longlong2 __ldcg(const longlong2 *ptr) { } + +static __attribute__((device)) __inline__ unsigned char __ldcg(const unsigned char *ptr) { } +static __attribute__((device)) __inline__ unsigned short __ldcg(const unsigned short *ptr) { } +static __attribute__((device)) __inline__ unsigned int __ldcg(const unsigned int *ptr) { } +static __attribute__((device)) __inline__ unsigned long long __ldcg(const unsigned long long *ptr) { } +static __attribute__((device)) __inline__ uchar2 __ldcg(const uchar2 *ptr) { } +static __attribute__((device)) __inline__ uchar4 __ldcg(const uchar4 *ptr) { } +static __attribute__((device)) __inline__ ushort2 __ldcg(const ushort2 *ptr) { } +static __attribute__((device)) __inline__ ushort4 __ldcg(const ushort4 *ptr) { } +static __attribute__((device)) __inline__ uint2 __ldcg(const uint2 *ptr) { } +static __attribute__((device)) __inline__ uint4 __ldcg(const uint4 *ptr) { } +static __attribute__((device)) __inline__ ulonglong2 __ldcg(const ulonglong2 *ptr) { } + +static __attribute__((device)) __inline__ float __ldcg(const float *ptr) { } +static __attribute__((device)) __inline__ double __ldcg(const double *ptr) { } +static __attribute__((device)) __inline__ float2 __ldcg(const float2 *ptr) { } +static __attribute__((device)) __inline__ float4 __ldcg(const float4 *ptr) { } +static __attribute__((device)) __inline__ double2 __ldcg(const double2 *ptr) { } + + + +static __attribute__((device)) __inline__ long __ldca(const long *ptr) { } +static __attribute__((device)) __inline__ unsigned long __ldca(const unsigned long *ptr) { } + +static __attribute__((device)) __inline__ char __ldca(const char *ptr) { } +static __attribute__((device)) __inline__ signed char __ldca(const signed char *ptr) { } +static __attribute__((device)) __inline__ short __ldca(const short *ptr) { } +static __attribute__((device)) __inline__ int __ldca(const int *ptr) { } +static __attribute__((device)) __inline__ long long __ldca(const long long *ptr) { } +static __attribute__((device)) __inline__ char2 __ldca(const char2 *ptr) { } +static __attribute__((device)) __inline__ char4 __ldca(const char4 *ptr) { } +static __attribute__((device)) __inline__ short2 __ldca(const short2 *ptr) { } +static __attribute__((device)) __inline__ short4 __ldca(const short4 *ptr) { } +static __attribute__((device)) __inline__ int2 __ldca(const int2 *ptr) { } +static __attribute__((device)) __inline__ int4 __ldca(const int4 *ptr) { } +static __attribute__((device)) __inline__ longlong2 __ldca(const longlong2 *ptr) { } + +static __attribute__((device)) __inline__ unsigned char __ldca(const unsigned char *ptr) { } +static __attribute__((device)) __inline__ unsigned short __ldca(const unsigned short *ptr) { } +static __attribute__((device)) __inline__ unsigned int __ldca(const unsigned int *ptr) { } +static __attribute__((device)) __inline__ unsigned long long __ldca(const unsigned long long *ptr) { } +static __attribute__((device)) __inline__ uchar2 __ldca(const uchar2 *ptr) { } +static __attribute__((device)) __inline__ uchar4 __ldca(const uchar4 *ptr) { } +static __attribute__((device)) __inline__ ushort2 __ldca(const ushort2 *ptr) { } +static __attribute__((device)) __inline__ ushort4 __ldca(const ushort4 *ptr) { } +static __attribute__((device)) __inline__ uint2 __ldca(const uint2 *ptr) { } +static __attribute__((device)) __inline__ uint4 __ldca(const uint4 *ptr) { } +static __attribute__((device)) __inline__ ulonglong2 __ldca(const ulonglong2 *ptr) { } + +static __attribute__((device)) __inline__ float __ldca(const float *ptr) { } +static __attribute__((device)) __inline__ double __ldca(const double *ptr) { } +static __attribute__((device)) __inline__ float2 __ldca(const float2 *ptr) { } +static __attribute__((device)) __inline__ float4 __ldca(const float4 *ptr) { } +static __attribute__((device)) __inline__ double2 __ldca(const double2 *ptr) { } + + + +static __attribute__((device)) __inline__ long __ldcs(const long *ptr) { } +static __attribute__((device)) __inline__ unsigned long __ldcs(const unsigned long *ptr) { } + +static __attribute__((device)) __inline__ char __ldcs(const char *ptr) { } +static __attribute__((device)) __inline__ signed char __ldcs(const signed char *ptr) { } +static __attribute__((device)) __inline__ short __ldcs(const short *ptr) { } +static __attribute__((device)) __inline__ int __ldcs(const int *ptr) { } +static __attribute__((device)) __inline__ long long __ldcs(const long long *ptr) { } +static __attribute__((device)) __inline__ char2 __ldcs(const char2 *ptr) { } +static __attribute__((device)) __inline__ char4 __ldcs(const char4 *ptr) { } +static __attribute__((device)) __inline__ short2 __ldcs(const short2 *ptr) { } +static __attribute__((device)) __inline__ short4 __ldcs(const short4 *ptr) { } +static __attribute__((device)) __inline__ int2 __ldcs(const int2 *ptr) { } +static __attribute__((device)) __inline__ int4 __ldcs(const int4 *ptr) { } +static __attribute__((device)) __inline__ longlong2 __ldcs(const longlong2 *ptr) { } + +static __attribute__((device)) __inline__ unsigned char __ldcs(const unsigned char *ptr) { } +static __attribute__((device)) __inline__ unsigned short __ldcs(const unsigned short *ptr) { } +static __attribute__((device)) __inline__ unsigned int __ldcs(const unsigned int *ptr) { } +static __attribute__((device)) __inline__ unsigned long long __ldcs(const unsigned long long *ptr) { } +static __attribute__((device)) __inline__ uchar2 __ldcs(const uchar2 *ptr) { } +static __attribute__((device)) __inline__ uchar4 __ldcs(const uchar4 *ptr) { } +static __attribute__((device)) __inline__ ushort2 __ldcs(const ushort2 *ptr) { } +static __attribute__((device)) __inline__ ushort4 __ldcs(const ushort4 *ptr) { } +static __attribute__((device)) __inline__ uint2 __ldcs(const uint2 *ptr) { } +static __attribute__((device)) __inline__ uint4 __ldcs(const uint4 *ptr) { } +static __attribute__((device)) __inline__ ulonglong2 __ldcs(const ulonglong2 *ptr) { } + +static __attribute__((device)) __inline__ float __ldcs(const float *ptr) { } +static __attribute__((device)) __inline__ double __ldcs(const double *ptr) { } +static __attribute__((device)) __inline__ float2 __ldcs(const float2 *ptr) { } +static __attribute__((device)) __inline__ float4 __ldcs(const float4 *ptr) { } +static __attribute__((device)) __inline__ double2 __ldcs(const double2 *ptr) { } + + + +static __attribute__((device)) __inline__ long __ldlu(const long *ptr) { } +static __attribute__((device)) __inline__ unsigned long __ldlu(const unsigned long *ptr) { } + +static __attribute__((device)) __inline__ char __ldlu(const char *ptr) { } +static __attribute__((device)) __inline__ signed char __ldlu(const signed char *ptr) { } +static __attribute__((device)) __inline__ short __ldlu(const short *ptr) { } +static __attribute__((device)) __inline__ int __ldlu(const int *ptr) { } +static __attribute__((device)) __inline__ long long __ldlu(const long long *ptr) { } +static __attribute__((device)) __inline__ char2 __ldlu(const char2 *ptr) { } +static __attribute__((device)) __inline__ char4 __ldlu(const char4 *ptr) { } +static __attribute__((device)) __inline__ short2 __ldlu(const short2 *ptr) { } +static __attribute__((device)) __inline__ short4 __ldlu(const short4 *ptr) { } +static __attribute__((device)) __inline__ int2 __ldlu(const int2 *ptr) { } +static __attribute__((device)) __inline__ int4 __ldlu(const int4 *ptr) { } +static __attribute__((device)) __inline__ longlong2 __ldlu(const longlong2 *ptr) { } + +static __attribute__((device)) __inline__ unsigned char __ldlu(const unsigned char *ptr) { } +static __attribute__((device)) __inline__ unsigned short __ldlu(const unsigned short *ptr) { } +static __attribute__((device)) __inline__ unsigned int __ldlu(const unsigned int *ptr) { } +static __attribute__((device)) __inline__ unsigned long long __ldlu(const unsigned long long *ptr) { } +static __attribute__((device)) __inline__ uchar2 __ldlu(const uchar2 *ptr) { } +static __attribute__((device)) __inline__ uchar4 __ldlu(const uchar4 *ptr) { } +static __attribute__((device)) __inline__ ushort2 __ldlu(const ushort2 *ptr) { } +static __attribute__((device)) __inline__ ushort4 __ldlu(const ushort4 *ptr) { } +static __attribute__((device)) __inline__ uint2 __ldlu(const uint2 *ptr) { } +static __attribute__((device)) __inline__ uint4 __ldlu(const uint4 *ptr) { } +static __attribute__((device)) __inline__ ulonglong2 __ldlu(const ulonglong2 *ptr) { } + +static __attribute__((device)) __inline__ float __ldlu(const float *ptr) { } +static __attribute__((device)) __inline__ double __ldlu(const double *ptr) { } +static __attribute__((device)) __inline__ float2 __ldlu(const float2 *ptr) { } +static __attribute__((device)) __inline__ float4 __ldlu(const float4 *ptr) { } +static __attribute__((device)) __inline__ double2 __ldlu(const double2 *ptr) { } + + + +static __attribute__((device)) __inline__ long __ldcv(const long *ptr) { } +static __attribute__((device)) __inline__ unsigned long __ldcv(const unsigned long *ptr) { } + +static __attribute__((device)) __inline__ char __ldcv(const char *ptr) { } +static __attribute__((device)) __inline__ signed char __ldcv(const signed char *ptr) { } +static __attribute__((device)) __inline__ short __ldcv(const short *ptr) { } +static __attribute__((device)) __inline__ int __ldcv(const int *ptr) { } +static __attribute__((device)) __inline__ long long __ldcv(const long long *ptr) { } +static __attribute__((device)) __inline__ char2 __ldcv(const char2 *ptr) { } +static __attribute__((device)) __inline__ char4 __ldcv(const char4 *ptr) { } +static __attribute__((device)) __inline__ short2 __ldcv(const short2 *ptr) { } +static __attribute__((device)) __inline__ short4 __ldcv(const short4 *ptr) { } +static __attribute__((device)) __inline__ int2 __ldcv(const int2 *ptr) { } +static __attribute__((device)) __inline__ int4 __ldcv(const int4 *ptr) { } +static __attribute__((device)) __inline__ longlong2 __ldcv(const longlong2 *ptr) { } + +static __attribute__((device)) __inline__ unsigned char __ldcv(const unsigned char *ptr) { } +static __attribute__((device)) __inline__ unsigned short __ldcv(const unsigned short *ptr) { } +static __attribute__((device)) __inline__ unsigned int __ldcv(const unsigned int *ptr) { } +static __attribute__((device)) __inline__ unsigned long long __ldcv(const unsigned long long *ptr) { } +static __attribute__((device)) __inline__ uchar2 __ldcv(const uchar2 *ptr) { } +static __attribute__((device)) __inline__ uchar4 __ldcv(const uchar4 *ptr) { } +static __attribute__((device)) __inline__ ushort2 __ldcv(const ushort2 *ptr) { } +static __attribute__((device)) __inline__ ushort4 __ldcv(const ushort4 *ptr) { } +static __attribute__((device)) __inline__ uint2 __ldcv(const uint2 *ptr) { } +static __attribute__((device)) __inline__ uint4 __ldcv(const uint4 *ptr) { } +static __attribute__((device)) __inline__ ulonglong2 __ldcv(const ulonglong2 *ptr) { } + +static __attribute__((device)) __inline__ float __ldcv(const float *ptr) { } +static __attribute__((device)) __inline__ double __ldcv(const double *ptr) { } +static __attribute__((device)) __inline__ float2 __ldcv(const float2 *ptr) { } +static __attribute__((device)) __inline__ float4 __ldcv(const float4 *ptr) { } +static __attribute__((device)) __inline__ double2 __ldcv(const double2 *ptr) { } + + + +static __attribute__((device)) __inline__ void __stwb(long *ptr, long value) { } +static __attribute__((device)) __inline__ void __stwb(unsigned long *ptr, unsigned long value) { } + +static __attribute__((device)) __inline__ void __stwb(char *ptr, char value) { } +static __attribute__((device)) __inline__ void __stwb(signed char *ptr, signed char value) { } +static __attribute__((device)) __inline__ void __stwb(short *ptr, short value) { } +static __attribute__((device)) __inline__ void __stwb(int *ptr, int value) { } +static __attribute__((device)) __inline__ void __stwb(long long *ptr, long long value) { } +static __attribute__((device)) __inline__ void __stwb(char2 *ptr, char2 value) { } +static __attribute__((device)) __inline__ void __stwb(char4 *ptr, char4 value) { } +static __attribute__((device)) __inline__ void __stwb(short2 *ptr, short2 value) { } +static __attribute__((device)) __inline__ void __stwb(short4 *ptr, short4 value) { } +static __attribute__((device)) __inline__ void __stwb(int2 *ptr, int2 value) { } +static __attribute__((device)) __inline__ void __stwb(int4 *ptr, int4 value) { } +static __attribute__((device)) __inline__ void __stwb(longlong2 *ptr, longlong2 value) { } + +static __attribute__((device)) __inline__ void __stwb(unsigned char *ptr, unsigned char value) { } +static __attribute__((device)) __inline__ void __stwb(unsigned short *ptr, unsigned short value) { } +static __attribute__((device)) __inline__ void __stwb(unsigned int *ptr, unsigned int value) { } +static __attribute__((device)) __inline__ void __stwb(unsigned long long *ptr, unsigned long long value) { } +static __attribute__((device)) __inline__ void __stwb(uchar2 *ptr, uchar2 value) { } +static __attribute__((device)) __inline__ void __stwb(uchar4 *ptr, uchar4 value) { } +static __attribute__((device)) __inline__ void __stwb(ushort2 *ptr, ushort2 value) { } +static __attribute__((device)) __inline__ void __stwb(ushort4 *ptr, ushort4 value) { } +static __attribute__((device)) __inline__ void __stwb(uint2 *ptr, uint2 value) { } +static __attribute__((device)) __inline__ void __stwb(uint4 *ptr, uint4 value) { } +static __attribute__((device)) __inline__ void __stwb(ulonglong2 *ptr, ulonglong2 value) { } + +static __attribute__((device)) __inline__ void __stwb(float *ptr, float value) { } +static __attribute__((device)) __inline__ void __stwb(double *ptr, double value) { } +static __attribute__((device)) __inline__ void __stwb(float2 *ptr, float2 value) { } +static __attribute__((device)) __inline__ void __stwb(float4 *ptr, float4 value) { } +static __attribute__((device)) __inline__ void __stwb(double2 *ptr, double2 value) { } + + + +static __attribute__((device)) __inline__ void __stcg(long *ptr, long value) { } +static __attribute__((device)) __inline__ void __stcg(unsigned long *ptr, unsigned long value) { } + +static __attribute__((device)) __inline__ void __stcg(char *ptr, char value) { } +static __attribute__((device)) __inline__ void __stcg(signed char *ptr, signed char value) { } +static __attribute__((device)) __inline__ void __stcg(short *ptr, short value) { } +static __attribute__((device)) __inline__ void __stcg(int *ptr, int value) { } +static __attribute__((device)) __inline__ void __stcg(long long *ptr, long long value) { } +static __attribute__((device)) __inline__ void __stcg(char2 *ptr, char2 value) { } +static __attribute__((device)) __inline__ void __stcg(char4 *ptr, char4 value) { } +static __attribute__((device)) __inline__ void __stcg(short2 *ptr, short2 value) { } +static __attribute__((device)) __inline__ void __stcg(short4 *ptr, short4 value) { } +static __attribute__((device)) __inline__ void __stcg(int2 *ptr, int2 value) { } +static __attribute__((device)) __inline__ void __stcg(int4 *ptr, int4 value) { } +static __attribute__((device)) __inline__ void __stcg(longlong2 *ptr, longlong2 value) { } + +static __attribute__((device)) __inline__ void __stcg(unsigned char *ptr, unsigned char value) { } +static __attribute__((device)) __inline__ void __stcg(unsigned short *ptr, unsigned short value) { } +static __attribute__((device)) __inline__ void __stcg(unsigned int *ptr, unsigned int value) { } +static __attribute__((device)) __inline__ void __stcg(unsigned long long *ptr, unsigned long long value) { } +static __attribute__((device)) __inline__ void __stcg(uchar2 *ptr, uchar2 value) { } +static __attribute__((device)) __inline__ void __stcg(uchar4 *ptr, uchar4 value) { } +static __attribute__((device)) __inline__ void __stcg(ushort2 *ptr, ushort2 value) { } +static __attribute__((device)) __inline__ void __stcg(ushort4 *ptr, ushort4 value) { } +static __attribute__((device)) __inline__ void __stcg(uint2 *ptr, uint2 value) { } +static __attribute__((device)) __inline__ void __stcg(uint4 *ptr, uint4 value) { } +static __attribute__((device)) __inline__ void __stcg(ulonglong2 *ptr, ulonglong2 value) { } + +static __attribute__((device)) __inline__ void __stcg(float *ptr, float value) { } +static __attribute__((device)) __inline__ void __stcg(double *ptr, double value) { } +static __attribute__((device)) __inline__ void __stcg(float2 *ptr, float2 value) { } +static __attribute__((device)) __inline__ void __stcg(float4 *ptr, float4 value) { } +static __attribute__((device)) __inline__ void __stcg(double2 *ptr, double2 value) { } + + + +static __attribute__((device)) __inline__ void __stcs(long *ptr, long value) { } +static __attribute__((device)) __inline__ void __stcs(unsigned long *ptr, unsigned long value) { } + +static __attribute__((device)) __inline__ void __stcs(char *ptr, char value) { } +static __attribute__((device)) __inline__ void __stcs(signed char *ptr, signed char value) { } +static __attribute__((device)) __inline__ void __stcs(short *ptr, short value) { } +static __attribute__((device)) __inline__ void __stcs(int *ptr, int value) { } +static __attribute__((device)) __inline__ void __stcs(long long *ptr, long long value) { } +static __attribute__((device)) __inline__ void __stcs(char2 *ptr, char2 value) { } +static __attribute__((device)) __inline__ void __stcs(char4 *ptr, char4 value) { } +static __attribute__((device)) __inline__ void __stcs(short2 *ptr, short2 value) { } +static __attribute__((device)) __inline__ void __stcs(short4 *ptr, short4 value) { } +static __attribute__((device)) __inline__ void __stcs(int2 *ptr, int2 value) { } +static __attribute__((device)) __inline__ void __stcs(int4 *ptr, int4 value) { } +static __attribute__((device)) __inline__ void __stcs(longlong2 *ptr, longlong2 value) { } + +static __attribute__((device)) __inline__ void __stcs(unsigned char *ptr, unsigned char value) { } +static __attribute__((device)) __inline__ void __stcs(unsigned short *ptr, unsigned short value) { } +static __attribute__((device)) __inline__ void __stcs(unsigned int *ptr, unsigned int value) { } +static __attribute__((device)) __inline__ void __stcs(unsigned long long *ptr, unsigned long long value) { } +static __attribute__((device)) __inline__ void __stcs(uchar2 *ptr, uchar2 value) { } +static __attribute__((device)) __inline__ void __stcs(uchar4 *ptr, uchar4 value) { } +static __attribute__((device)) __inline__ void __stcs(ushort2 *ptr, ushort2 value) { } +static __attribute__((device)) __inline__ void __stcs(ushort4 *ptr, ushort4 value) { } +static __attribute__((device)) __inline__ void __stcs(uint2 *ptr, uint2 value) { } +static __attribute__((device)) __inline__ void __stcs(uint4 *ptr, uint4 value) { } +static __attribute__((device)) __inline__ void __stcs(ulonglong2 *ptr, ulonglong2 value) { } + +static __attribute__((device)) __inline__ void __stcs(float *ptr, float value) { } +static __attribute__((device)) __inline__ void __stcs(double *ptr, double value) { } +static __attribute__((device)) __inline__ void __stcs(float2 *ptr, float2 value) { } +static __attribute__((device)) __inline__ void __stcs(float4 *ptr, float4 value) { } +static __attribute__((device)) __inline__ void __stcs(double2 *ptr, double2 value) { } + + + +static __attribute__((device)) __inline__ void __stwt(long *ptr, long value) { } +static __attribute__((device)) __inline__ void __stwt(unsigned long *ptr, unsigned long value) { } + +static __attribute__((device)) __inline__ void __stwt(char *ptr, char value) { } +static __attribute__((device)) __inline__ void __stwt(signed char *ptr, signed char value) { } +static __attribute__((device)) __inline__ void __stwt(short *ptr, short value) { } +static __attribute__((device)) __inline__ void __stwt(int *ptr, int value) { } +static __attribute__((device)) __inline__ void __stwt(long long *ptr, long long value) { } +static __attribute__((device)) __inline__ void __stwt(char2 *ptr, char2 value) { } +static __attribute__((device)) __inline__ void __stwt(char4 *ptr, char4 value) { } +static __attribute__((device)) __inline__ void __stwt(short2 *ptr, short2 value) { } +static __attribute__((device)) __inline__ void __stwt(short4 *ptr, short4 value) { } +static __attribute__((device)) __inline__ void __stwt(int2 *ptr, int2 value) { } +static __attribute__((device)) __inline__ void __stwt(int4 *ptr, int4 value) { } +static __attribute__((device)) __inline__ void __stwt(longlong2 *ptr, longlong2 value) { } + +static __attribute__((device)) __inline__ void __stwt(unsigned char *ptr, unsigned char value) { } +static __attribute__((device)) __inline__ void __stwt(unsigned short *ptr, unsigned short value) { } +static __attribute__((device)) __inline__ void __stwt(unsigned int *ptr, unsigned int value) { } +static __attribute__((device)) __inline__ void __stwt(unsigned long long *ptr, unsigned long long value) { } +static __attribute__((device)) __inline__ void __stwt(uchar2 *ptr, uchar2 value) { } +static __attribute__((device)) __inline__ void __stwt(uchar4 *ptr, uchar4 value) { } +static __attribute__((device)) __inline__ void __stwt(ushort2 *ptr, ushort2 value) { } +static __attribute__((device)) __inline__ void __stwt(ushort4 *ptr, ushort4 value) { } +static __attribute__((device)) __inline__ void __stwt(uint2 *ptr, uint2 value) { } +static __attribute__((device)) __inline__ void __stwt(uint4 *ptr, uint4 value) { } +static __attribute__((device)) __inline__ void __stwt(ulonglong2 *ptr, ulonglong2 value) { } + +static __attribute__((device)) __inline__ void __stwt(float *ptr, float value) { } +static __attribute__((device)) __inline__ void __stwt(double *ptr, double value) { } +static __attribute__((device)) __inline__ void __stwt(float2 *ptr, float2 value) { } +static __attribute__((device)) __inline__ void __stwt(float4 *ptr, float4 value) { } +static __attribute__((device)) __inline__ void __stwt(double2 *ptr, double2 value) { } +# 465 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_l(unsigned int lo, unsigned int hi, unsigned int shift) { } +# 477 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_lc(unsigned int lo, unsigned int hi, unsigned int shift) { } +# 490 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_r(unsigned int lo, unsigned int hi, unsigned int shift) { } +# 502 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_32_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __funnelshift_rc(unsigned int lo, unsigned int hi, unsigned int shift) { } +# 2900 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_35_intrinsics.h" 1 +# 2901 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" 1 +# 102 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp2a_lo(int srcA, int srcB, int c) { } +# 113 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp2a_lo(unsigned int srcA, unsigned int srcB, unsigned int c) { } +# 125 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp2a_lo(short2 srcA, char4 srcB, int c) { } +# 136 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp2a_lo(ushort2 srcA, uchar4 srcB, unsigned int c) { } +# 148 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp2a_hi(int srcA, int srcB, int c) { } +# 159 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp2a_hi(unsigned int srcA, unsigned int srcB, unsigned int c) { } +# 171 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp2a_hi(short2 srcA, char4 srcB, int c) { } +# 182 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp2a_hi(ushort2 srcA, uchar4 srcB, unsigned int c) { } +# 197 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp4a(int srcA, int srcB, int c) { } +# 206 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp4a(unsigned int srcA, unsigned int srcB, unsigned int c) { } +# 216 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ int __dp4a(char4 srcA, char4 srcB, int c) { } +# 225 "/usr/local/cuda/bin/../targets/x86_64-linux/include/sm_61_intrinsics.h" +static __attribute__((device)) __inline__ unsigned int __dp4a(uchar4 srcA, uchar4 srcB, unsigned int c) { } +# 2902 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" 1 +# 84 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 85 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" 2 + +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 87 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" 2 +# 98 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/sm_70_rt.h" +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, unsigned value) { } +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, int value) { } +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, unsigned long value) { } +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, long value) { } +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, unsigned long long value) { } +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, long long value) { } +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, float value) { } +static __attribute__((device)) __inline__ unsigned int __match_any_sync(unsigned mask, double value) { } + +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, unsigned value, int *pred) { } +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, int value, int *pred) { } +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, unsigned long value, int *pred) { } +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, long value, int *pred) { } +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, unsigned long long value, int *pred) { } +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, long long value, int *pred) { } +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, float value, int *pred) { } +static __attribute__((device)) __inline__ unsigned int __match_all_sync(unsigned mask, double value, int *pred) { } + +static __attribute__((device)) __inline__ void __nanosleep(unsigned int ns) { } + +static __attribute__((device)) __inline__ unsigned short int atomicCAS(unsigned short int *address, unsigned short int compare, unsigned short int val) { } +# 2903 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" 1 +# 81 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 82 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" 2 + +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 84 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" 2 +# 97 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/sm_80_rt.h" +static __attribute__((device)) __inline__ unsigned __reduce_add_sync(unsigned mask, unsigned value) { } +static __attribute__((device)) __inline__ unsigned __reduce_min_sync(unsigned mask, unsigned value) { } +static __attribute__((device)) __inline__ unsigned __reduce_max_sync(unsigned mask, unsigned value) { } + +static __attribute__((device)) __inline__ int __reduce_add_sync(unsigned mask, int value) { } +static __attribute__((device)) __inline__ int __reduce_min_sync(unsigned mask, int value) { } +static __attribute__((device)) __inline__ int __reduce_max_sync(unsigned mask, int value) { } + +static __attribute__((device)) __inline__ unsigned __reduce_and_sync(unsigned mask, unsigned value) { } +static __attribute__((device)) __inline__ unsigned __reduce_or_sync(unsigned mask, unsigned value) { } +static __attribute__((device)) __inline__ unsigned __reduce_xor_sync(unsigned mask, unsigned value) { } + + + + +extern "C" { +inline __attribute__((device)) void *__nv_associate_access_property(const void *ptr, + unsigned long long property) { + extern __attribute__((device)) void *__nv_associate_access_property_impl(const void *, + unsigned long long); + return __nv_associate_access_property_impl(ptr, property); +} + +inline __attribute__((device)) void __nv_memcpy_async_shared_global_4(void *dst, + const void *src, + unsigned src_size) { + extern __attribute__((device)) void __nv_memcpy_async_shared_global_4_impl(void *, + const void *, + unsigned); + __nv_memcpy_async_shared_global_4_impl(dst, src, src_size); +} + +inline __attribute__((device)) void __nv_memcpy_async_shared_global_8(void *dst, + const void *src, + unsigned src_size) { + extern __attribute__((device)) void __nv_memcpy_async_shared_global_8_impl(void *, + const void *, + unsigned); + __nv_memcpy_async_shared_global_8_impl(dst, src, src_size); +} + +inline __attribute__((device)) void __nv_memcpy_async_shared_global_16(void *dst, + const void *src, + unsigned src_size) { + extern __attribute__((device)) void __nv_memcpy_async_shared_global_16_impl(void *, + const void *, + unsigned); + __nv_memcpy_async_shared_global_16_impl(dst, src, src_size); +} + +} +# 2904 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" 1 +# 79 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/builtin_types.h" 1 +# 80 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" 2 + +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/host_defines.h" 1 +# 82 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" 2 +# 92 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +static __attribute__((device)) __inline__ unsigned __isCtaShared(const void *ptr) { } +static __attribute__((device)) __inline__ unsigned __isClusterShared(const void *ptr) { } +static __attribute__((device)) __inline__ void *__cluster_map_shared_rank(const void *ptr, unsigned target_block_rank) { } +static __attribute__((device)) __inline__ unsigned __cluster_query_shared_rank(const void *ptr) { } +static __attribute__((device)) __inline__ uint2 __cluster_map_shared_multicast(const void *ptr, unsigned cluster_cta_mask) { } +static __attribute__((device)) __inline__ unsigned __clusterDimIsSpecified() { } +static __attribute__((device)) __inline__ dim3 __clusterDim() { } +static __attribute__((device)) __inline__ dim3 __clusterRelativeBlockIdx() { } +static __attribute__((device)) __inline__ dim3 __clusterGridDimInClusters() { } +static __attribute__((device)) __inline__ dim3 __clusterIdx() { } +static __attribute__((device)) __inline__ unsigned __clusterRelativeBlockRank() { } +static __attribute__((device)) __inline__ unsigned __clusterSizeInBlocks() { } +static __attribute__((device)) __inline__ void __cluster_barrier_arrive() { } +static __attribute__((device)) __inline__ void __cluster_barrier_arrive_relaxed() { } +static __attribute__((device)) __inline__ void __cluster_barrier_wait() { } +static __attribute__((device)) __inline__ void __threadfence_cluster() { } + +static __attribute__((device)) __inline__ float2 atomicAdd(float2 *__address, float2 val) { } +static __attribute__((device)) __inline__ float2 atomicAdd_block(float2 *__address, float2 val) { } +static __attribute__((device)) __inline__ float2 atomicAdd_system(float2 *__address, float2 val) { } +static __attribute__((device)) __inline__ float4 atomicAdd(float4 *__address, float4 val) { } +static __attribute__((device)) __inline__ float4 atomicAdd_block(float4 *__address, float4 val) { } +static __attribute__((device)) __inline__ float4 atomicAdd_system(float4 *__address, float4 val) { } +# 125 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +extern "C" { + __attribute__((device)) __attribute__((device_builtin)) void __u128AtomicCAS(void *, void *, void *, void *); + __attribute__((device)) __attribute__((device_builtin)) void __u128AtomicCAS_block(void *, void *, void *, void *); + __attribute__((device)) __attribute__((device_builtin)) void __u128AtomicCAS_system(void *, void *, void *, void *); + __attribute__((device)) __attribute__((device_builtin)) void __u128AtomicExch(void *, void *, void *); + __attribute__((device)) __attribute__((device_builtin)) void __u128AtomicExch_block(void *, void *, void *); + __attribute__((device)) __attribute__((device_builtin)) void __u128AtomicExch_system(void *, void *, void *); +} + + + + + + +template +struct __nv_atomic_enable_if { }; + +template +struct __nv_atomic_enable_if { typedef _T __type; }; +# 153 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +template +struct __nv_atomic_triv_cp_helper { + + + + + + + static const bool __val = __is_trivially_copyable(_T); + + + + +}; +# 201 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/sm_90_rt.h" +template +static __attribute__((device)) __inline__ typename __nv_atomic_enable_if= 16 && __nv_atomic_triv_cp_helper<_T>::__val, _T>::__type +atomicCAS(_T *__address, _T __compare, _T __val) { + union _U {_T __ret; __attribute__((device)) __inline__ _U() {}}; _U __u; + __u128AtomicCAS((void *)(__address), + (void *)(&(const_cast(reinterpret_cast(__compare)))), + (void *)(&(const_cast(reinterpret_cast(__val)))), + (void *)(&(const_cast(reinterpret_cast(__u.__ret))))); + return __u.__ret; +} + +template +static __attribute__((device)) __inline__ typename __nv_atomic_enable_if= 16 && __nv_atomic_triv_cp_helper<_T>::__val, _T>::__type +atomicCAS_block(_T *__address, _T __compare, _T __val) { + union _U {_T __ret; __attribute__((device)) __inline__ _U() {}}; _U __u; + __u128AtomicCAS_block((void *)(__address), + (void *)(&(const_cast(reinterpret_cast(__compare)))), + (void *)(&(const_cast(reinterpret_cast(__val)))), + (void *)(&(const_cast(reinterpret_cast(__u.__ret))))); + return __u.__ret; +} + +template +static __attribute__((device)) __inline__ typename __nv_atomic_enable_if= 16 && __nv_atomic_triv_cp_helper<_T>::__val, _T>::__type +atomicCAS_system(_T *__address, _T __compare, _T __val) { + union _U {_T __ret; __attribute__((device)) __inline__ _U() {}}; _U __u; + __u128AtomicCAS_system((void *)(__address), + (void *)(&(const_cast(reinterpret_cast(__compare)))), + (void *)(&(const_cast(reinterpret_cast(__val)))), + (void *)(&(const_cast(reinterpret_cast(__u.__ret))))); + return __u.__ret; +} + +template +static __attribute__((device)) __inline__ typename __nv_atomic_enable_if= 16 && __nv_atomic_triv_cp_helper<_T>::__val, _T>::__type +atomicExch(_T *__address, _T __val) { + union _U {_T __ret; __attribute__((device)) __inline__ _U() {}}; _U __u; + __u128AtomicExch((void *)(__address), + (void *)(&(const_cast(reinterpret_cast(__val)))), + (void *)(&(const_cast(reinterpret_cast(__u.__ret))))); + return __u.__ret; +} + +template +static __attribute__((device)) __inline__ typename __nv_atomic_enable_if= 16 && __nv_atomic_triv_cp_helper<_T>::__val, _T>::__type +atomicExch_block(_T *__address, _T __val) { + union _U {_T __ret; __attribute__((device)) __inline__ _U() {}}; _U __u; + __u128AtomicExch_block((void *)(__address), + (void *)(&(const_cast(reinterpret_cast(__val)))), + (void *)(&(const_cast(reinterpret_cast(__u.__ret))))); + return __u.__ret; +} + +template +static __attribute__((device)) __inline__ typename __nv_atomic_enable_if= 16 && __nv_atomic_triv_cp_helper<_T>::__val, _T>::__type +atomicExch_system(_T *__address, _T __val) { + union _U {_T __ret; __attribute__((device)) __inline__ _U() {}}; _U __u; + __u128AtomicExch_system((void *)(__address), + (void *)(&(const_cast(reinterpret_cast(__val)))), + (void *)(&(const_cast(reinterpret_cast(__u.__ret))))); + return __u.__ret; +} +# 2905 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 + +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" 1 +# 65 "/usr/local/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template struct __nv_itex_trait { }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +# 101 "/usr/local/cuda/bin/../targets/x86_64-linux/include/texture_indirect_functions.h" +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; +template<> struct __nv_itex_trait { typedef void type; }; + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1Dfetch(T *ptr, cudaTextureObject_t obj, int x) +{ + __nv_tex_surf_handler("__itex1Dfetch", ptr, obj, x); +} + +template +static __attribute__((device)) T tex1Dfetch(cudaTextureObject_t texObject, int x) +{ + T ret; + tex1Dfetch(&ret, texObject, x); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1D(T *ptr, cudaTextureObject_t obj, float x) +{ + __nv_tex_surf_handler("__itex1D", ptr, obj, x); +} + + +template +static __attribute__((device)) T tex1D(cudaTextureObject_t texObject, float x) +{ + T ret; + tex1D(&ret, texObject, x); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2D(T *ptr, cudaTextureObject_t obj, float x, float y) +{ + __nv_tex_surf_handler("__itex2D", ptr, obj, x, y); +} + +template +static __attribute__((device)) T tex2D(cudaTextureObject_t texObject, float x, float y) +{ + T ret; + tex2D(&ret, texObject, x, y); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2D(T *ptr, cudaTextureObject_t obj, float x, float y, + bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex2D_sparse", ptr, obj, x, y, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex2D(cudaTextureObject_t texObject, float x, float y, bool* isResident) +{ + T ret; + tex2D(&ret, texObject, x, y, isResident); + return ret; +} + + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex3D(T *ptr, cudaTextureObject_t obj, float x, float y, float z) +{ + __nv_tex_surf_handler("__itex3D", ptr, obj, x, y, z); +} + +template +static __attribute__((device)) T tex3D(cudaTextureObject_t texObject, float x, float y, float z) +{ + T ret; + tex3D(&ret, texObject, x, y, z); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex3D(T *ptr, cudaTextureObject_t obj, float x, float y, float z, + bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex3D_sparse", ptr, obj, x, y, z, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex3D(cudaTextureObject_t texObject, float x, float y, float z, bool* isResident) +{ + T ret; + tex3D(&ret, texObject, x, y, z, isResident); + return ret; +} + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DLayered(T *ptr, cudaTextureObject_t obj, float x, int layer) +{ + __nv_tex_surf_handler("__itex1DLayered", ptr, obj, x, layer); +} + +template +static __attribute__((device)) T tex1DLayered(cudaTextureObject_t texObject, float x, int layer) +{ + T ret; + tex1DLayered(&ret, texObject, x, layer); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayered(T *ptr, cudaTextureObject_t obj, float x, float y, int layer) +{ + __nv_tex_surf_handler("__itex2DLayered", ptr, obj, x, y, layer); +} + +template +static __attribute__((device)) T tex2DLayered(cudaTextureObject_t texObject, float x, float y, int layer) +{ + T ret; + tex2DLayered(&ret, texObject, x, y, layer); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayered(T *ptr, cudaTextureObject_t obj, float x, float y, int layer, bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex2DLayered_sparse", ptr, obj, x, y, layer, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex2DLayered(cudaTextureObject_t texObject, float x, float y, int layer, bool* isResident) +{ + T ret; + tex2DLayered(&ret, texObject, x, y, layer, isResident); + return ret; +} + + + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemap(T *ptr, cudaTextureObject_t obj, float x, float y, float z) +{ + __nv_tex_surf_handler("__itexCubemap", ptr, obj, x, y, z); +} + + +template +static __attribute__((device)) T texCubemap(cudaTextureObject_t texObject, float x, float y, float z) +{ + T ret; + texCubemap(&ret, texObject, x, y, z); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapLayered(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer) +{ + __nv_tex_surf_handler("__itexCubemapLayered", ptr, obj, x, y, z, layer); +} + +template +static __attribute__((device)) T texCubemapLayered(cudaTextureObject_t texObject, float x, float y, float z, int layer) +{ + T ret; + texCubemapLayered(&ret, texObject, x, y, z, layer); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2Dgather(T *ptr, cudaTextureObject_t obj, float x, float y, int comp = 0) +{ + __nv_tex_surf_handler("__itex2Dgather", ptr, obj, x, y, comp); +} + +template +static __attribute__((device)) T tex2Dgather(cudaTextureObject_t to, float x, float y, int comp = 0) +{ + T ret; + tex2Dgather(&ret, to, x, y, comp); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2Dgather(T *ptr, cudaTextureObject_t obj, float x, float y, bool* isResident, int comp = 0) +{ + unsigned char res; + __nv_tex_surf_handler("__itex2Dgather_sparse", ptr, obj, x, y, comp, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex2Dgather(cudaTextureObject_t to, float x, float y, bool* isResident, int comp = 0) +{ + T ret; + tex2Dgather(&ret, to, x, y, isResident, comp); + return ret; +} + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DLod(T *ptr, cudaTextureObject_t obj, float x, float level) +{ + __nv_tex_surf_handler("__itex1DLod", ptr, obj, x, level); +} + +template +static __attribute__((device)) T tex1DLod(cudaTextureObject_t texObject, float x, float level) +{ + T ret; + tex1DLod(&ret, texObject, x, level); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float level) +{ + __nv_tex_surf_handler("__itex2DLod", ptr, obj, x, y, level); +} + +template +static __attribute__((device)) T tex2DLod(cudaTextureObject_t texObject, float x, float y, float level) +{ + T ret; + tex2DLod(&ret, texObject, x, y, level); + return ret; +} + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float level, bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex2DLod_sparse", ptr, obj, x, y, level, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex2DLod(cudaTextureObject_t texObject, float x, float y, float level, bool* isResident) +{ + T ret; + tex2DLod(&ret, texObject, x, y, level, isResident); + return ret; +} + + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex3DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float level) +{ + __nv_tex_surf_handler("__itex3DLod", ptr, obj, x, y, z, level); +} + +template +static __attribute__((device)) T tex3DLod(cudaTextureObject_t texObject, float x, float y, float z, float level) +{ + T ret; + tex3DLod(&ret, texObject, x, y, z, level); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex3DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float level, bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex3DLod_sparse", ptr, obj, x, y, z, level, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex3DLod(cudaTextureObject_t texObject, float x, float y, float z, float level, bool* isResident) +{ + T ret; + tex3DLod(&ret, texObject, x, y, z, level, isResident); + return ret; +} + + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DLayeredLod(T *ptr, cudaTextureObject_t obj, float x, int layer, float level) +{ + __nv_tex_surf_handler("__itex1DLayeredLod", ptr, obj, x, layer, level); +} + +template +static __attribute__((device)) T tex1DLayeredLod(cudaTextureObject_t texObject, float x, int layer, float level) +{ + T ret; + tex1DLayeredLod(&ret, texObject, x, layer, level); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayeredLod(T *ptr, cudaTextureObject_t obj, float x, float y, int layer, float level) +{ + __nv_tex_surf_handler("__itex2DLayeredLod", ptr, obj, x, y, layer, level); +} + +template +static __attribute__((device)) T tex2DLayeredLod(cudaTextureObject_t texObject, float x, float y, int layer, float level) +{ + T ret; + tex2DLayeredLod(&ret, texObject, x, y, layer, level); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayeredLod(T *ptr, cudaTextureObject_t obj, float x, float y, int layer, float level, bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex2DLayeredLod_sparse", ptr, obj, x, y, layer, level, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex2DLayeredLod(cudaTextureObject_t texObject, float x, float y, int layer, float level, bool* isResident) +{ + T ret; + tex2DLayeredLod(&ret, texObject, x, y, layer, level, isResident); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float level) +{ + __nv_tex_surf_handler("__itexCubemapLod", ptr, obj, x, y, z, level); +} + +template +static __attribute__((device)) T texCubemapLod(cudaTextureObject_t texObject, float x, float y, float z, float level) +{ + T ret; + texCubemapLod(&ret, texObject, x, y, z, level); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + __nv_tex_surf_handler("__itexCubemapGrad_v2", ptr, obj, x, y, z, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T texCubemapGrad(cudaTextureObject_t texObject, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + T ret; + texCubemapGrad(&ret, texObject, x, y, z, dPdx, dPdy); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapLayeredLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer, float level) +{ + __nv_tex_surf_handler("__itexCubemapLayeredLod", ptr, obj, x, y, z, layer, level); +} + +template +static __attribute__((device)) T texCubemapLayeredLod(cudaTextureObject_t texObject, float x, float y, float z, int layer, float level) +{ + T ret; + texCubemapLayeredLod(&ret, texObject, x, y, z, layer, level); + return ret; +} + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DGrad(T *ptr, cudaTextureObject_t obj, float x, float dPdx, float dPdy) +{ + __nv_tex_surf_handler("__itex1DGrad", ptr, obj, x, dPdx, dPdy); +} + +template +static __attribute__((device)) T tex1DGrad(cudaTextureObject_t texObject, float x, float dPdx, float dPdy) +{ + T ret; + tex1DGrad(&ret, texObject, x, dPdx, dPdy); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float2 dPdx, float2 dPdy) +{ + __nv_tex_surf_handler("__itex2DGrad_v2", ptr, obj, x, y, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T tex2DGrad(cudaTextureObject_t texObject, float x, float y, float2 dPdx, float2 dPdy) +{ + T ret; + tex2DGrad(&ret, texObject, x, y, dPdx, dPdy); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float2 dPdx, float2 dPdy, bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex2DGrad_sparse", ptr, obj, x, y, &dPdx, &dPdy, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex2DGrad(cudaTextureObject_t texObject, float x, float y, float2 dPdx, float2 dPdy, bool* isResident) +{ + T ret; + tex2DGrad(&ret, texObject, x, y, dPdx, dPdy, isResident); + return ret; +} + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex3DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + __nv_tex_surf_handler("__itex3DGrad_v2", ptr, obj, x, y, z, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T tex3DGrad(cudaTextureObject_t texObject, float x, float y, float z, float4 dPdx, float4 dPdy) +{ + T ret; + tex3DGrad(&ret, texObject, x, y, z, dPdx, dPdy); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex3DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float4 dPdx, float4 dPdy, bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex3DGrad_sparse", ptr, obj, x, y, z, &dPdx, &dPdy, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex3DGrad(cudaTextureObject_t texObject, float x, float y, float z, float4 dPdx, float4 dPdy, bool* isResident) +{ + T ret; + tex3DGrad(&ret, texObject, x, y, z, dPdx, dPdy, isResident); + return ret; +} + + + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex1DLayeredGrad(T *ptr, cudaTextureObject_t obj, float x, int layer, float dPdx, float dPdy) +{ + __nv_tex_surf_handler("__itex1DLayeredGrad", ptr, obj, x, layer, dPdx, dPdy); +} + +template +static __attribute__((device)) T tex1DLayeredGrad(cudaTextureObject_t texObject, float x, int layer, float dPdx, float dPdy) +{ + T ret; + tex1DLayeredGrad(&ret, texObject, x, layer, dPdx, dPdy); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayeredGrad(T * ptr, cudaTextureObject_t obj, float x, float y, int layer, float2 dPdx, float2 dPdy) +{ + __nv_tex_surf_handler("__itex2DLayeredGrad_v2", ptr, obj, x, y, layer, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T tex2DLayeredGrad(cudaTextureObject_t texObject, float x, float y, int layer, float2 dPdx, float2 dPdy) +{ + T ret; + tex2DLayeredGrad(&ret, texObject, x, y, layer, dPdx, dPdy); + return ret; +} + + +template +static __attribute__((device)) typename __nv_itex_trait::type tex2DLayeredGrad(T * ptr, cudaTextureObject_t obj, float x, float y, int layer, float2 dPdx, float2 dPdy, bool* isResident) +{ + unsigned char res; + __nv_tex_surf_handler("__itex2DLayeredGrad_sparse", ptr, obj, x, y, layer, &dPdx, &dPdy, &res); + *isResident = (res != 0); +} + +template +static __attribute__((device)) T tex2DLayeredGrad(cudaTextureObject_t texObject, float x, float y, int layer, float2 dPdx, float2 dPdy, bool* isResident) +{ + T ret; + tex2DLayeredGrad(&ret, texObject, x, y, layer, dPdx, dPdy, isResident); + return ret; +} + + + +template +static __attribute__((device)) typename __nv_itex_trait::type texCubemapLayeredGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer, float4 dPdx, float4 dPdy) +{ + __nv_tex_surf_handler("__itexCubemapLayeredGrad_v2", ptr, obj, x, y, z, layer, &dPdx, &dPdy); +} + +template +static __attribute__((device)) T texCubemapLayeredGrad(cudaTextureObject_t texObject, float x, float y, float z, int layer, float4 dPdx, float4 dPdy) +{ + T ret; + texCubemapLayeredGrad(&ret, texObject, x, y, z, layer, dPdx, dPdy); + return ret; +} +# 2907 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" 1 +# 58 "/usr/local/cuda/bin/../targets/x86_64-linux/include/surface_indirect_functions.h" +template struct __nv_isurf_trait { }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; + +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; + +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; +template<> struct __nv_isurf_trait { typedef void type; }; + + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf1Dread(T *ptr, cudaSurfaceObject_t obj, int x, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf1Dread", ptr, obj, x, mode); +} + +template +static __attribute__((device)) T surf1Dread(cudaSurfaceObject_t surfObject, int x, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf1Dread(&ret, surfObject, x, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf2Dread(T *ptr, cudaSurfaceObject_t obj, int x, int y, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf2Dread", ptr, obj, x, y, mode); +} + +template +static __attribute__((device)) T surf2Dread(cudaSurfaceObject_t surfObject, int x, int y, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf2Dread(&ret, surfObject, x, y, boundaryMode); + return ret; +} + + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf3Dread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int z, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf3Dread", ptr, obj, x, y, z, mode); +} + +template +static __attribute__((device)) T surf3Dread(cudaSurfaceObject_t surfObject, int x, int y, int z, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf3Dread(&ret, surfObject, x, y, z, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf1DLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf1DLayeredread", ptr, obj, x, layer, mode); +} + +template +static __attribute__((device)) T surf1DLayeredread(cudaSurfaceObject_t surfObject, int x, int layer, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf1DLayeredread(&ret, surfObject, x, layer, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf2DLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf2DLayeredread", ptr, obj, x, y, layer, mode); +} + +template +static __attribute__((device)) T surf2DLayeredread(cudaSurfaceObject_t surfObject, int x, int y, int layer, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surf2DLayeredread(&ret, surfObject, x, y, layer, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surfCubemapread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int face, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurfCubemapread", ptr, obj, x, y, face, mode); +} + +template +static __attribute__((device)) T surfCubemapread(cudaSurfaceObject_t surfObject, int x, int y, int face, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surfCubemapread(&ret, surfObject, x, y, face, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surfCubemapLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int layerface, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurfCubemapLayeredread", ptr, obj, x, y, layerface, mode); +} + +template +static __attribute__((device)) T surfCubemapLayeredread(cudaSurfaceObject_t surfObject, int x, int y, int layerface, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap) +{ + T ret; + surfCubemapLayeredread(&ret, surfObject, x, y, layerface, boundaryMode); + return ret; +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf1Dwrite(T val, cudaSurfaceObject_t obj, int x, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf1Dwrite_v2", &val, obj, x, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf2Dwrite(T val, cudaSurfaceObject_t obj, int x, int y, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf2Dwrite_v2", &val, obj, x, y, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf3Dwrite(T val, cudaSurfaceObject_t obj, int x, int y, int z, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf3Dwrite_v2", &val, obj, x, y, z, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf1DLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf1DLayeredwrite_v2", &val, obj, x, layer, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surf2DLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int y, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurf2DLayeredwrite_v2", &val, obj, x, y, layer, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surfCubemapwrite(T val, cudaSurfaceObject_t obj, int x, int y, int face, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurfCubemapwrite_v2", &val, obj, x, y, face, mode); +} + +template +static __attribute__((device)) typename __nv_isurf_trait::type surfCubemapLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int y, int layerface, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap) +{ + __nv_tex_surf_handler("__isurfCubemapLayeredwrite_v2", &val, obj, x, y, layerface, mode); +} +# 2908 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 + +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/cudacc_ext.h" 1 +# 2910 "/usr/local/cuda/bin/../targets/x86_64-linux/include/crt/device_functions.h" 2 + + +extern "C" __attribute__((host)) __attribute__((device)) unsigned __cudaPushCallConfiguration(dim3 gridDim, + dim3 blockDim, + size_t sharedMem = 0, + struct CUstream_st *stream = 0); +# 119 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 1 "/usr/local/cuda/bin/../targets/x86_64-linux/include/device_launch_parameters.h" 1 +# 68 "/usr/local/cuda/bin/../targets/x86_64-linux/include/device_launch_parameters.h" +extern "C" { + + +uint3 __attribute__((device_builtin)) extern const threadIdx; +uint3 __attribute__((device_builtin)) extern const blockIdx; +dim3 __attribute__((device_builtin)) extern const blockDim; +dim3 __attribute__((device_builtin)) extern const gridDim; +int __attribute__((device_builtin)) extern const warpSize; + + + + +} +# 120 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 148 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +# 1 "/usr/include/c++/11/utility" 1 3 +# 58 "/usr/include/c++/11/utility" 3 + +# 59 "/usr/include/c++/11/utility" 3 +# 69 "/usr/include/c++/11/utility" 3 +# 1 "/usr/include/c++/11/bits/stl_relops.h" 1 3 +# 67 "/usr/include/c++/11/bits/stl_relops.h" 3 + +# 67 "/usr/include/c++/11/bits/stl_relops.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + namespace rel_ops + { +# 85 "/usr/include/c++/11/bits/stl_relops.h" 3 + template + inline bool + operator!=(const _Tp& __x, const _Tp& __y) + { return !(__x == __y); } +# 98 "/usr/include/c++/11/bits/stl_relops.h" 3 + template + inline bool + operator>(const _Tp& __x, const _Tp& __y) + { return __y < __x; } +# 111 "/usr/include/c++/11/bits/stl_relops.h" 3 + template + inline bool + operator<=(const _Tp& __x, const _Tp& __y) + { return !(__y < __x); } +# 124 "/usr/include/c++/11/bits/stl_relops.h" 3 + template + inline bool + operator>=(const _Tp& __x, const _Tp& __y) + { return !(__x < __y); } + } + + +} +# 70 "/usr/include/c++/11/utility" 2 3 + + + + + + +# 1 "/usr/include/c++/11/initializer_list" 1 3 +# 33 "/usr/include/c++/11/initializer_list" 3 + +# 34 "/usr/include/c++/11/initializer_list" 3 + + + + + +#pragma GCC visibility push(default) + + + +namespace std +{ + + template + class initializer_list + { + public: + typedef _E value_type; + typedef const _E& reference; + typedef const _E& const_reference; + typedef size_t size_type; + typedef const _E* iterator; + typedef const _E* const_iterator; + + private: + iterator _M_array; + size_type _M_len; + + + constexpr initializer_list(const_iterator __a, size_type __l) + : _M_array(__a), _M_len(__l) { } + + public: + constexpr initializer_list() noexcept + : _M_array(0), _M_len(0) { } + + + constexpr size_type + size() const noexcept { return _M_len; } + + + constexpr const_iterator + begin() const noexcept { return _M_array; } + + + constexpr const_iterator + end() const noexcept { return begin() + size(); } + }; + + + + + + + + template + constexpr const _Tp* + begin(initializer_list<_Tp> __ils) noexcept + { return __ils.begin(); } + + + + + + + + template + constexpr const _Tp* + end(initializer_list<_Tp> __ils) noexcept + { return __ils.end(); } +} + +#pragma GCC visibility pop +# 77 "/usr/include/c++/11/utility" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct tuple_size; + + + + + + template::type, + typename = typename enable_if::value>::type, + size_t = tuple_size<_Tp>::value> + using __enable_if_has_tuple_size = _Tp; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + + template + struct tuple_element; + + + template + using __tuple_element_t = typename tuple_element<__i, _Tp>::type; + + template + struct tuple_element<__i, const _Tp> + { + typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type; + }; + + template + struct tuple_element<__i, volatile _Tp> + { + typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type; + }; + + template + struct tuple_element<__i, const volatile _Tp> + { + typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type; + }; + + + + + + + + template + using tuple_element_t = typename tuple_element<__i, _Tp>::type; + + + + + + template + struct __is_tuple_like_impl> : true_type + { }; + + + template + struct tuple_size> + : public integral_constant { }; + + + template + struct tuple_element<0, pair<_Tp1, _Tp2>> + { typedef _Tp1 type; }; + + + template + struct tuple_element<1, pair<_Tp1, _Tp2>> + { typedef _Tp2 type; }; + + template + struct __pair_get; + + template<> + struct __pair_get<0> + { + template + static constexpr _Tp1& + __get(pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr _Tp1&& + __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp1>(__pair.first); } + + template + static constexpr const _Tp1& + __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr const _Tp1&& + __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward(__pair.first); } + }; + + template<> + struct __pair_get<1> + { + template + static constexpr _Tp2& + __get(pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr _Tp2&& + __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp2>(__pair.second); } + + template + static constexpr const _Tp2& + __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr const _Tp2&& + __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward(__pair.second); } + }; + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__get(__in); } + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__move_get(std::move(__in)); } + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(const pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__const_get(__in); } + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(const pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__const_move_get(std::move(__in)); } + + + + + + template + constexpr _Tp& + get(pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr const _Tp& + get(const pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr _Tp&& + get(pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr const _Tp&& + get(const pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr _Tp& + get(pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr const _Tp& + get(const pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr _Tp&& + get(pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } + + template + constexpr const _Tp&& + get(const pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } + + + + + template + + inline _Tp + exchange(_Tp& __obj, _Up&& __new_val) + { return std::__exchange(__obj, std::forward<_Up>(__new_val)); } + + + + + + template struct _Index_tuple { }; + + + template + struct _Build_index_tuple + { +# 312 "/usr/include/c++/11/utility" 3 + using __type = _Index_tuple<__integer_pack(_Num)...>; + + }; + + + + + + + template + struct integer_sequence + { + typedef _Tp value_type; + static constexpr size_t size() noexcept { return sizeof...(_Idx); } + }; + + + template + using make_integer_sequence + + + + = integer_sequence<_Tp, __integer_pack(_Num)...>; + + + + template + using index_sequence = integer_sequence; + + + template + using make_index_sequence = make_integer_sequence; + + + template + using index_sequence_for = make_index_sequence; + + + + + struct in_place_t { + explicit in_place_t() = default; + }; + + inline constexpr in_place_t in_place{}; + + template struct in_place_type_t + { + explicit in_place_type_t() = default; + }; + + template + inline constexpr in_place_type_t<_Tp> in_place_type{}; + + template struct in_place_index_t + { + explicit in_place_index_t() = default; + }; + + template + inline constexpr in_place_index_t<_Idx> in_place_index{}; + + template + inline constexpr bool __is_in_place_type_v = false; + + template + inline constexpr bool __is_in_place_type_v> = true; + + template + using __is_in_place_type = bool_constant<__is_in_place_type_v<_Tp>>; + + + template + [[nodiscard]] + constexpr add_const_t<_Tp>& + as_const(_Tp& __t) noexcept + { return __t; } + + template + void as_const(const _Tp&&) = delete; +# 476 "/usr/include/c++/11/utility" 3 + +} +# 149 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" 2 +# 206 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" + +# 206 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchKernel( + const T *func, + dim3 gridDim, + dim3 blockDim, + void **args, + size_t sharedMem = 0, + cudaStream_t stream = 0 +) +{ + return ::cudaLaunchKernel((const void *)func, gridDim, blockDim, args, sharedMem, stream); +} +# 277 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchKernelEx( + const cudaLaunchConfig_t *config, + void (*kernel)(ExpTypes...), + ActTypes &&... args +) +{ + return [&](ExpTypes... coercedArgs){ + void *pArgs[] = { &coercedArgs... }; + return ::cudaLaunchKernelExC(config, (const void *)kernel, pArgs); + }(std::forward(args)...); +} +# 340 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaLaunchCooperativeKernel( + const T *func, + dim3 gridDim, + dim3 blockDim, + void **args, + size_t sharedMem = 0, + cudaStream_t stream = 0 +) +{ + return ::cudaLaunchCooperativeKernel((const void *)func, gridDim, blockDim, args, sharedMem, stream); +} +# 384 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static __inline__ __attribute__((host)) cudaError_t cudaEventCreate( + cudaEvent_t *event, + unsigned int flags +) +{ + return ::cudaEventCreateWithFlags(event, flags); +} +# 428 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static __inline__ __attribute__((host)) cudaError_t cudaGraphInstantiate( + cudaGraphExec_t *pGraphExec, + cudaGraph_t graph, + cudaGraphNode_t *pErrorNode, + char *pLogBuffer, + size_t bufferSize +) +{ + (void)pErrorNode; + (void)pLogBuffer; + (void)bufferSize; + return ::cudaGraphInstantiate(pGraphExec, graph, 0); +} +# 499 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static __inline__ __attribute__((host)) cudaError_t cudaMallocHost( + void **ptr, + size_t size, + unsigned int flags +) +{ + return ::cudaHostAlloc(ptr, size, flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaHostAlloc( + T **ptr, + size_t size, + unsigned int flags +) +{ + return ::cudaHostAlloc((void**)(void*)ptr, size, flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaHostGetDevicePointer( + T **pDevice, + void *pHost, + unsigned int flags +) +{ + return ::cudaHostGetDevicePointer((void**)(void*)pDevice, pHost, flags); +} +# 628 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocManaged( + T **devPtr, + size_t size, + unsigned int flags = 0x01 +) +{ + return ::cudaMallocManaged((void**)(void*)devPtr, size, flags); +} +# 646 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +cudaError_t cudaMemAdvise( + T *devPtr, + size_t count, + enum cudaMemoryAdvise advice, + struct cudaMemLocation location +) +{ + return ::cudaMemAdvise_v2((const void *)devPtr, count, advice, location); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMemPrefetchAsync( + T *devPtr, + size_t count, + struct cudaMemLocation location, + unsigned int flags, + cudaStream_t stream = 0 +) +{ + return ::cudaMemPrefetchAsync_v2((const void *)devPtr, count, location, flags, stream); +} +# 749 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaStreamAttachMemAsync( + cudaStream_t stream, + T *devPtr, + size_t length = 0, + unsigned int flags = 0x04 +) +{ + return ::cudaStreamAttachMemAsync(stream, (void*)devPtr, length, flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMalloc( + T **devPtr, + size_t size +) +{ + return ::cudaMalloc((void**)(void*)devPtr, size); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocHost( + T **ptr, + size_t size, + unsigned int flags = 0 +) +{ + return cudaMallocHost((void**)(void*)ptr, size, flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocPitch( + T **devPtr, + size_t *pitch, + size_t width, + size_t height +) +{ + return ::cudaMallocPitch((void**)(void*)devPtr, pitch, width, height); +} +# 799 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +static __inline__ __attribute__((host)) cudaError_t cudaMallocAsync( + void **ptr, + size_t size, + cudaMemPool_t memPool, + cudaStream_t stream +) +{ + return ::cudaMallocFromPoolAsync(ptr, size, memPool, stream); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocAsync( + T **ptr, + size_t size, + cudaMemPool_t memPool, + cudaStream_t stream +) +{ + return ::cudaMallocFromPoolAsync((void**)(void*)ptr, size, memPool, stream); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocAsync( + T **ptr, + size_t size, + cudaStream_t stream +) +{ + return ::cudaMallocAsync((void**)(void*)ptr, size, stream); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaMallocFromPoolAsync( + T **ptr, + size_t size, + cudaMemPool_t memPool, + cudaStream_t stream +) +{ + return ::cudaMallocFromPoolAsync((void**)(void*)ptr, size, memPool, stream); +} +# 878 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyToSymbol( + const T &symbol, + const void *src, + size_t count, + size_t offset = 0, + enum cudaMemcpyKind kind = cudaMemcpyHostToDevice +) +{ + return ::cudaMemcpyToSymbol((const void*)&symbol, src, count, offset, kind); +} +# 932 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyToSymbolAsync( + const T &symbol, + const void *src, + size_t count, + size_t offset = 0, + enum cudaMemcpyKind kind = cudaMemcpyHostToDevice, + cudaStream_t stream = 0 +) +{ + return ::cudaMemcpyToSymbolAsync((const void*)&symbol, src, count, offset, kind, stream); +} +# 980 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyFromSymbol( + void *dst, + const T &symbol, + size_t count, + size_t offset = 0, + enum cudaMemcpyKind kind = cudaMemcpyDeviceToHost +) +{ + return ::cudaMemcpyFromSymbol(dst, (const void*)&symbol, count, offset, kind); +} +# 1034 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaMemcpyFromSymbolAsync( + void *dst, + const T &symbol, + size_t count, + size_t offset = 0, + enum cudaMemcpyKind kind = cudaMemcpyDeviceToHost, + cudaStream_t stream = 0 +) +{ + return ::cudaMemcpyFromSymbolAsync(dst, (const void*)&symbol, count, offset, kind, stream); +} +# 1103 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphAddMemcpyNodeToSymbol( + cudaGraphNode_t *pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t *pDependencies, + size_t numDependencies, + const T &symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphAddMemcpyNodeToSymbol(pGraphNode, graph, pDependencies, numDependencies, (const void*)&symbol, src, count, offset, kind); +} +# 1174 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphAddMemcpyNodeFromSymbol( + cudaGraphNode_t* pGraphNode, + cudaGraph_t graph, + const cudaGraphNode_t* pDependencies, + size_t numDependencies, + void* dst, + const T &symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphAddMemcpyNodeFromSymbol(pGraphNode, graph, pDependencies, numDependencies, dst, (const void*)&symbol, count, offset, kind); +} +# 1225 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParamsToSymbol( + cudaGraphNode_t node, + const T &symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphMemcpyNodeSetParamsToSymbol(node, (const void*)&symbol, src, count, offset, kind); +} +# 1273 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphMemcpyNodeSetParamsFromSymbol( + cudaGraphNode_t node, + void* dst, + const T &symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphMemcpyNodeSetParamsFromSymbol(node, dst, (const void*)&symbol, count, offset, kind); +} +# 1331 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParamsToSymbol( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + const T &symbol, + const void* src, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphExecMemcpyNodeSetParamsToSymbol(hGraphExec, node, (const void*)&symbol, src, count, offset, kind); +} +# 1390 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGraphExecMemcpyNodeSetParamsFromSymbol( + cudaGraphExec_t hGraphExec, + cudaGraphNode_t node, + void* dst, + const T &symbol, + size_t count, + size_t offset, + enum cudaMemcpyKind kind) +{ + return ::cudaGraphExecMemcpyNodeSetParamsFromSymbol(hGraphExec, node, dst, (const void*)&symbol, count, offset, kind); +} + + +static __inline__ __attribute__((host)) cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphNode_t *hErrorNode_out, enum cudaGraphExecUpdateResult *updateResult_out) +{ + cudaGraphExecUpdateResultInfo resultInfo; + cudaError_t status = cudaGraphExecUpdate(hGraphExec, hGraph, &resultInfo); + if (hErrorNode_out) { + *hErrorNode_out = resultInfo.errorNode; + } + if (updateResult_out) { + *updateResult_out = resultInfo.result; + } + return status; +} +# 1443 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaUserObjectCreate( + cudaUserObject_t *object_out, + T *objectToWrap, + unsigned int initialRefcount, + unsigned int flags) +{ + return ::cudaUserObjectCreate( + object_out, + objectToWrap, + [](void *vpObj) { delete reinterpret_cast(vpObj); }, + initialRefcount, + flags); +} + +template +static __inline__ __attribute__((host)) cudaError_t cudaUserObjectCreate( + cudaUserObject_t *object_out, + T *objectToWrap, + unsigned int initialRefcount, + cudaUserObjectFlags flags) +{ + return cudaUserObjectCreate(object_out, objectToWrap, initialRefcount, (unsigned int)flags); +} +# 1493 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGetSymbolAddress( + void **devPtr, + const T &symbol +) +{ + return ::cudaGetSymbolAddress(devPtr, (const void*)&symbol); +} +# 1525 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGetSymbolSize( + size_t *size, + const T &symbol +) +{ + return ::cudaGetSymbolSize(size, (const void*)&symbol); +} +# 1577 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncSetCacheConfig( + T *func, + enum cudaFuncCache cacheConfig +) +{ + return ::cudaFuncSetCacheConfig((const void*)func, cacheConfig); +} + +template +static __inline__ +__attribute__((deprecated)) +__attribute__((host)) cudaError_t cudaFuncSetSharedMemConfig( + T *func, + enum cudaSharedMemConfig config +) +{ + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + + return ::cudaFuncSetSharedMemConfig((const void*)func, config); + +#pragma GCC diagnostic pop + +} +# 1636 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor( + int *numBlocks, + T func, + int blockSize, + size_t dynamicSMemSize) +{ + return ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, (const void*)func, blockSize, dynamicSMemSize, 0x00); +} +# 1688 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags( + int *numBlocks, + T func, + int blockSize, + size_t dynamicSMemSize, + unsigned int flags) +{ + return ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, (const void*)func, blockSize, dynamicSMemSize, flags); +} + + + + +class __cudaOccupancyB2DHelper { + size_t n; +public: + inline __attribute__((host)) __attribute__((device)) __cudaOccupancyB2DHelper(size_t n_) : n(n_) {} + inline __attribute__((host)) __attribute__((device)) size_t operator()(int) + { + return n; + } +}; +# 1758 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) __attribute__((device)) cudaError_t cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags( + int *minGridSize, + int *blockSize, + T func, + UnaryFunction blockSizeToDynamicSMemSize, + int blockSizeLimit = 0, + unsigned int flags = 0) +{ + cudaError_t status; + + + int device; + struct cudaFuncAttributes attr; + + + int maxThreadsPerMultiProcessor; + int warpSize; + int devMaxThreadsPerBlock; + int multiProcessorCount; + int funcMaxThreadsPerBlock; + int occupancyLimit; + int granularity; + + + int maxBlockSize = 0; + int numBlocks = 0; + int maxOccupancy = 0; + + + int blockSizeToTryAligned; + int blockSizeToTry; + int blockSizeLimitAligned; + int occupancyInBlocks; + int occupancyInThreads; + size_t dynamicSMemSize; + + + + + + if (!minGridSize || !blockSize || !func) { + return cudaErrorInvalidValue; + } + + + + + + status = ::cudaGetDevice(&device); + if (status != cudaSuccess) { + return status; + } + + status = cudaDeviceGetAttribute( + &maxThreadsPerMultiProcessor, + cudaDevAttrMaxThreadsPerMultiProcessor, + device); + if (status != cudaSuccess) { + return status; + } + + status = cudaDeviceGetAttribute( + &warpSize, + cudaDevAttrWarpSize, + device); + if (status != cudaSuccess) { + return status; + } + + status = cudaDeviceGetAttribute( + &devMaxThreadsPerBlock, + cudaDevAttrMaxThreadsPerBlock, + device); + if (status != cudaSuccess) { + return status; + } + + status = cudaDeviceGetAttribute( + &multiProcessorCount, + cudaDevAttrMultiProcessorCount, + device); + if (status != cudaSuccess) { + return status; + } + + status = cudaFuncGetAttributes(&attr, func); + if (status != cudaSuccess) { + return status; + } + + funcMaxThreadsPerBlock = attr.maxThreadsPerBlock; + + + + + + occupancyLimit = maxThreadsPerMultiProcessor; + granularity = warpSize; + + if (blockSizeLimit == 0) { + blockSizeLimit = devMaxThreadsPerBlock; + } + + if (devMaxThreadsPerBlock < blockSizeLimit) { + blockSizeLimit = devMaxThreadsPerBlock; + } + + if (funcMaxThreadsPerBlock < blockSizeLimit) { + blockSizeLimit = funcMaxThreadsPerBlock; + } + + blockSizeLimitAligned = ((blockSizeLimit + (granularity - 1)) / granularity) * granularity; + + for (blockSizeToTryAligned = blockSizeLimitAligned; blockSizeToTryAligned > 0; blockSizeToTryAligned -= granularity) { + + + + if (blockSizeLimit < blockSizeToTryAligned) { + blockSizeToTry = blockSizeLimit; + } else { + blockSizeToTry = blockSizeToTryAligned; + } + + dynamicSMemSize = blockSizeToDynamicSMemSize(blockSizeToTry); + + status = cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags( + &occupancyInBlocks, + func, + blockSizeToTry, + dynamicSMemSize, + flags); + + if (status != cudaSuccess) { + return status; + } + + occupancyInThreads = blockSizeToTry * occupancyInBlocks; + + if (occupancyInThreads > maxOccupancy) { + maxBlockSize = blockSizeToTry; + numBlocks = occupancyInBlocks; + maxOccupancy = occupancyInThreads; + } + + + + if (occupancyLimit == maxOccupancy) { + break; + } + } + + + + + + + + *minGridSize = numBlocks * multiProcessorCount; + *blockSize = maxBlockSize; + + return status; +} +# 1954 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) __attribute__((device)) cudaError_t cudaOccupancyMaxPotentialBlockSizeVariableSMem( + int *minGridSize, + int *blockSize, + T func, + UnaryFunction blockSizeToDynamicSMemSize, + int blockSizeLimit = 0) +{ + return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, blockSizeToDynamicSMemSize, blockSizeLimit, 0x00); +} +# 2000 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) __attribute__((device)) cudaError_t cudaOccupancyMaxPotentialBlockSize( + int *minGridSize, + int *blockSize, + T func, + size_t dynamicSMemSize = 0, + int blockSizeLimit = 0) +{ + return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, __cudaOccupancyB2DHelper(dynamicSMemSize), blockSizeLimit, 0x00); +} +# 2038 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock( + size_t *dynamicSmemSize, + T func, + int numBlocks, + int blockSize) +{ + return ::cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, (const void*)func, numBlocks, blockSize); +} +# 2097 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) __attribute__((device)) cudaError_t cudaOccupancyMaxPotentialBlockSizeWithFlags( + int *minGridSize, + int *blockSize, + T func, + size_t dynamicSMemSize = 0, + int blockSizeLimit = 0, + unsigned int flags = 0) +{ + return cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(minGridSize, blockSize, func, __cudaOccupancyB2DHelper(dynamicSMemSize), blockSizeLimit, flags); +} +# 2141 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyMaxPotentialClusterSize( + int *clusterSize, + T *func, + const cudaLaunchConfig_t *config) +{ + return ::cudaOccupancyMaxPotentialClusterSize(clusterSize, (const void*)func, config); +} +# 2184 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaOccupancyMaxActiveClusters( + int *numClusters, + T *func, + const cudaLaunchConfig_t *config) +{ + return ::cudaOccupancyMaxActiveClusters(numClusters, (const void*)func, config); +} +# 2224 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncGetAttributes( + struct cudaFuncAttributes *attr, + T *entry +) +{ + return ::cudaFuncGetAttributes(attr, (const void*)entry); +} +# 2289 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncSetAttribute( + T *entry, + enum cudaFuncAttribute attr, + int value +) +{ + return ::cudaFuncSetAttribute((const void*)entry, attr, value); +} +# 2321 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaFuncGetName( + const char **name, + const T *func +) +{ + return ::cudaFuncGetName(name, (const void *)func); +} +# 2344 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +template +static __inline__ __attribute__((host)) cudaError_t cudaGetKernel( + cudaKernel_t *kernelPtr, + const T *entryFuncAddr +) +{ + return ::cudaGetKernel(kernelPtr, (const void *)entryFuncAddr); +} +# 2362 "/usr/local/cuda/bin/../targets/x86_64-linux/include/cuda_runtime.h" +#pragma GCC diagnostic pop +# 0 "" 2 +# 1 "CMakeCUDACompilerId.cu" +# 476 "CMakeCUDACompilerId.cu" +char const* info_compiler = "INFO" ":" "compiler[" "NVIDIA" "]"; + +char const* info_simulate = "INFO" ":" "simulate[" "GNU" "]"; +# 789 "CMakeCUDACompilerId.cu" +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + ('0' + (((12) / 10000000)%10)), ('0' + (((12) / 1000000)%10)), ('0' + (((12) / 100000)%10)), ('0' + (((12) / 10000)%10)), ('0' + (((12) / 1000)%10)), ('0' + (((12) / 100)%10)), ('0' + (((12) / 10)%10)), ('0' + ((12) % 10)), + + '.', ('0' + (((5) / 10000000)%10)), ('0' + (((5) / 1000000)%10)), ('0' + (((5) / 100000)%10)), ('0' + (((5) / 10000)%10)), ('0' + (((5) / 1000)%10)), ('0' + (((5) / 100)%10)), ('0' + (((5) / 10)%10)), ('0' + ((5) % 10)), + + '.', ('0' + (((82) / 10000000)%10)), ('0' + (((82) / 1000000)%10)), ('0' + (((82) / 100000)%10)), ('0' + (((82) / 10000)%10)), ('0' + (((82) / 1000)%10)), ('0' + (((82) / 100)%10)), ('0' + (((82) / 10)%10)), ('0' + ((82) % 10)), + + + + + + ']','\0'}; +# 818 "CMakeCUDACompilerId.cu" +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + ('0' + (((11) / 10000000)%10)), ('0' + (((11) / 1000000)%10)), ('0' + (((11) / 100000)%10)), ('0' + (((11) / 10000)%10)), ('0' + (((11) / 1000)%10)), ('0' + (((11) / 100)%10)), ('0' + (((11) / 10)%10)), ('0' + ((11) % 10)), + + '.', ('0' + (((4) / 10000000)%10)), ('0' + (((4) / 1000000)%10)), ('0' + (((4) / 100000)%10)), ('0' + (((4) / 10000)%10)), ('0' + (((4) / 1000)%10)), ('0' + (((4) / 100)%10)), ('0' + (((4) / 10)%10)), ('0' + ((4) % 10)), + + + + + + + + ']','\0'}; + + + + + + +char const* info_platform = "INFO" ":" "platform[" "Linux" "]"; +char const* info_arch = "INFO" ":" "arch[" "]"; + + + + +char const* info_host_compiler = "INFO" ":" "host_compiler[" "GNU" "]"; + + + + +char const info_host_compiler_version[] = { + 'I', 'N', 'F', 'O', ':','h','o','s','t','_', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + ('0' + (((11) / 10000000)%10)), ('0' + (((11) / 1000000)%10)), ('0' + (((11) / 100000)%10)), ('0' + (((11) / 10000)%10)), ('0' + (((11) / 1000)%10)), ('0' + (((11) / 100)%10)), ('0' + (((11) / 10)%10)), ('0' + ((11) % 10)), + + '.', ('0' + (((4) / 10000000)%10)), ('0' + (((4) / 1000000)%10)), ('0' + (((4) / 100000)%10)), ('0' + (((4) / 10000)%10)), ('0' + (((4) / 1000)%10)), ('0' + (((4) / 100)%10)), ('0' + (((4) / 10)%10)), ('0' + ((4) % 10)), + + '.', ('0' + (((0) / 10000000)%10)), ('0' + (((0) / 1000000)%10)), ('0' + (((0) / 100000)%10)), ('0' + (((0) / 10000)%10)), ('0' + (((0) / 1000)%10)), ('0' + (((0) / 100)%10)), ('0' + (((0) / 10)%10)), ('0' + ((0) % 10)), + + + + + + ']','\0'}; +# 881 "CMakeCUDACompilerId.cu" +const char* info_language_standard_default = "INFO" ":" "standard_default[" + + + + + + + + "17" + + + + + + + +"]"; + +const char* info_language_extensions_default = "INFO" ":" "extensions_default[" + + + "ON" + + + +"]"; + + + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; + + require += info_version[argc]; + + + require += info_simulate[argc]; + + + require += info_simulate_version[argc]; + + + require += info_host_compiler[argc]; + + + require += info_host_compiler_version[argc]; + + require += info_language_standard_default[argc]; + require += info_language_extensions_default[argc]; + (void)argv; + return require; +}